gcc/toplev.c

   1 /* Top level of GNU C compiler
   2    Copyright (C) 1987, 1988, 1989, 1992 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  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 #include <sys/types.h>
  28 #include <stdio.h>
  29 #include <signal.h>
  30 #include <setjmp.h>
  31
  32 #include <sys/stat.h>
  33
  34 #ifdef USG
  35 #undef FLOAT
  36 #include <sys/param.h>
  37 /* This is for hpux.  It is a real screw.  They should change hpux.  */
  38 #undef FLOAT
  39 #include <sys/times.h>
  40 #include <time.h>   /* Correct for hpux at least.  Is it good on other USG?  */
  41 #undef FFS  /* Some systems define this in param.h.  */
  42 #else
  43 #ifndef VMS
  44 #include <sys/time.h>
  45 #include <sys/resource.h>
  46 #endif
  47 #endif
  48
  49 #include "input.h"
  50 #include "tree.h"
  51 /* #include "c-tree.h" */
  52 #include "rtl.h"
  53 #include "flags.h"
  54 #include "insn-attr.h"
  55 #include "defaults.h"
  56
  57 #ifdef XCOFF_DEBUGGING_INFO
  58 #include "xcoffout.h"
  59 #endif
  60 \f
  61 #ifdef VMS
  62 /* The extra parameters substantially improve the I/O performance.  */
  63 static FILE *
  64 VMS_fopen (fname, type)
  65      char * fname;
  66      char * type;
  67 {
  68   if (strcmp (type, "w") == 0)
  69     return fopen (fname, type, "mbc=16", "deq=64", "fop=tef", "shr=nil");
  70   return fopen (fname, type, "mbc=16");
  71 }
  72 #define fopen VMS_fopen
  73 #endif
  74
  75 #ifndef DEFAULT_GDB_EXTENSIONS
  76 #define DEFAULT_GDB_EXTENSIONS 1
  77 #endif
  78
  79 extern int rtx_equal_function_value_matters;
  80
  81 #if ! (defined (VMS) || defined (OS2))
  82 extern char **environ;
  83 #endif
  84 extern char *version_string, *language_string;
  85
  86 extern void init_lex ();
  87 extern void init_decl_processing ();
  88 extern void init_obstacks ();
  89 extern void init_tree_codes ();
  90 extern void init_rtl ();
  91 extern void init_optabs ();
  92 extern void init_stmt ();
  93 extern void init_reg_sets ();
  94 extern void dump_flow_info ();
  95 extern void dump_sched_info ();
  96 extern void dump_local_alloc ();
  97
  98 void rest_of_decl_compilation ();
  99 void error ();
 100 void error_with_file_and_line ();
 101 void fancy_abort ();
 102 #ifndef abort
 103 void abort ();
 104 #endif
 105 void set_target_switch ();
 106 static void print_switch_values ();
 107 static char *decl_name ();
 108
 109 /* Name of program invoked, sans directories.  */
 110
 111 char *progname;
 112
 113 /* Copy of arguments to main.  */
 114 int save_argc;
 115 char **save_argv;
 116 \f
 117 /* Name of current original source file (what was input to cpp).
 118    This comes from each #-command in the actual input.  */
 119
 120 char *input_filename;
 121
 122 /* Name of top-level original source file (what was input to cpp).
 123    This comes from the #-command at the beginning of the actual input.
 124    If there isn't any there, then this is the cc1 input file name.  */
 125
 126 char *main_input_filename;
 127
 128 /* Stream for reading from the input file.  */
 129
 130 FILE *finput;
 131
 132 /* Current line number in real source file.  */
 133
 134 int lineno;
 135
 136 /* Stack of currently pending input files.  */
 137
 138 struct file_stack *input_file_stack;
 139
 140 /* Incremented on each change to input_file_stack.  */
 141 int input_file_stack_tick;
 142
 143 /* FUNCTION_DECL for function now being parsed or compiled.  */
 144
 145 extern tree current_function_decl;
 146
 147 /* Name to use as base of names for dump output files.  */
 148
 149 char *dump_base_name;
 150
 151 /* Bit flags that specify the machine subtype we are compiling for.
 152    Bits are tested using macros TARGET_... defined in the tm.h file
 153    and set by `-m...' switches.  Must be defined in rtlanal.c.  */
 154
 155 extern int target_flags;
 156
 157 /* Flags saying which kinds of debugging dump have been requested.  */
 158
 159 int rtl_dump = 0;
 160 int rtl_dump_and_exit = 0;
 161 int jump_opt_dump = 0;
 162 int cse_dump = 0;
 163 int loop_dump = 0;
 164 int cse2_dump = 0;
 165 int flow_dump = 0;
 166 int combine_dump = 0;
 167 int sched_dump = 0;
 168 int local_reg_dump = 0;
 169 int global_reg_dump = 0;
 170 int sched2_dump = 0;
 171 int jump2_opt_dump = 0;
 172 int dbr_sched_dump = 0;
 173 int flag_print_asm_name = 0;
 174 int stack_reg_dump = 0;
 175
 176 /* Name for output file of assembly code, specified with -o.  */
 177
 178 char *asm_file_name;
 179
 180 /* Value of the -G xx switch, and whether it was passed or not.  */
 181 int g_switch_value;
 182 int g_switch_set;
 183
 184 /* Type(s) of debugging information we are producing (if any).
 185    See flags.h for the definitions of the different possible
 186    types of debugging information.  */
 187 enum debug_info_type write_symbols = NO_DEBUG;
 188
 189 /* Level of debugging information we are producing.  See flags.h
 190    for the definitions of the different possible levels.  */
 191 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
 192
 193 /* Nonzero means use GNU-only extensions in the generated symbolic
 194    debugging information.  */
 195 /* Currently, this only has an effect when write_symbols is set to
 196    DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG.  */
 197 int use_gnu_debug_info_extensions = 0;
 198
 199 /* Nonzero means do optimizations.  -O.
 200    Particular numeric values stand for particular amounts of optimization;
 201    thus, -O2 stores 2 here.  However, the optimizations beyond the basic
 202    ones are not controlled directly by this variable.  Instead, they are
 203    controlled by individual `flag_...' variables that are defaulted
 204    based on this variable.  */
 205
 206 int optimize = 0;
 207
 208 /* Number of error messages and warning messages so far.  */
 209
 210 int errorcount = 0;
 211 int warningcount = 0;
 212 int sorrycount = 0;
 213
 214 /* Pointer to function to compute the name to use to print a declaration.  */
 215
 216 char *(*decl_printable_name) ();
 217
 218 /* Pointer to function to compute rtl for a language-specific tree code.  */
 219
 220 struct rtx_def *(*lang_expand_expr) ();
 221
 222 /* Pointer to function to finish handling an incomplete decl at the
 223    end of compilation.  */
 224
 225 void (*incomplete_decl_finalize_hook) () = 0;
 226
 227 /* Nonzero if generating code to do profiling.  */
 228
 229 int profile_flag = 0;
 230
 231 /* Nonzero if generating code to do profiling on a line-by-line basis.  */
 232
 233 int profile_block_flag;
 234
 235 /* Nonzero for -pedantic switch: warn about anything
 236    that standard spec forbids.  */
 237
 238 int pedantic = 0;
 239
 240 /* Temporarily suppress certain warnings.
 241    This is set while reading code from a system header file.  */
 242
 243 int in_system_header = 0;
 244
 245 /* Nonzero means do stupid register allocation.
 246    Currently, this is 1 if `optimize' is 0.  */
 247
 248 int obey_regdecls = 0;
 249
 250 /* Don't print functions as they are compiled and don't print
 251    times taken by the various passes.  -quiet.  */
 252
 253 int quiet_flag = 0;
 254 \f
 255 /* -f flags.  */
 256
 257 /* Nonzero means `char' should be signed.  */
 258
 259 int flag_signed_char;
 260
 261 /* Nonzero means give an enum type only as many bytes as it needs.  */
 262
 263 int flag_short_enums;
 264
 265 /* Nonzero for -fcaller-saves: allocate values in regs that need to
 266    be saved across function calls, if that produces overall better code.
 267    Optional now, so people can test it.  */
 268
 269 #ifdef DEFAULT_CALLER_SAVES
 270 int flag_caller_saves = 1;
 271 #else
 272 int flag_caller_saves = 0;
 273 #endif
 274
 275 /* Nonzero if structures and unions should be returned in memory.
 276
 277    This should only be defined if compatibility with another compiler or
 278    with an ABI is needed, because it results in slower code.  */
 279
 280 #ifndef DEFAULT_PCC_STRUCT_RETURN
 281 #define DEFAULT_PCC_STRUCT_RETURN 1
 282 #endif
 283
 284 /* Nonzero for -fpcc-struct-return: return values the same way PCC does.  */
 285
 286 int flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
 287
 288 /* Nonzero for -fforce-mem: load memory value into a register
 289    before arithmetic on it.  This makes better cse but slower compilation.  */
 290
 291 int flag_force_mem = 0;
 292
 293 /* Nonzero for -fforce-addr: load memory address into a register before
 294    reference to memory.  This makes better cse but slower compilation.  */
 295
 296 int flag_force_addr = 0;
 297
 298 /* Nonzero for -fdefer-pop: don't pop args after each function call;
 299    instead save them up to pop many calls' args with one insns.  */
 300
 301 int flag_defer_pop = 0;
 302
 303 /* Nonzero for -ffloat-store: don't allocate floats and doubles
 304    in extended-precision registers.  */
 305
 306 int flag_float_store = 0;
 307
 308 /* Nonzero for -fcse-follow-jumps:
 309    have cse follow jumps to do a more extensive job.  */
 310
 311 int flag_cse_follow_jumps;
 312
 313 /* Nonzero for -fcse-skip-blocks:
 314    have cse follow a branch around a block.  */
 315 int flag_cse_skip_blocks;
 316
 317 /* Nonzero for -fexpensive-optimizations:
 318    perform miscellaneous relatively-expensive optimizations.  */
 319 int flag_expensive_optimizations;
 320
 321 /* Nonzero for -fthread-jumps:
 322    have jump optimize output of loop.  */
 323
 324 int flag_thread_jumps;
 325
 326 /* Nonzero enables strength-reduction in loop.c.  */
 327
 328 int flag_strength_reduce = 0;
 329
 330 /* Nonzero enables loop unrolling in unroll.c.  Only loops for which the
 331    number of iterations can be calculated at compile-time (UNROLL_COMPLETELY,
 332    UNROLL_MODULO) or at run-time (preconditioned to be UNROLL_MODULO) are
 333    unrolled.  */
 334
 335 int flag_unroll_loops;
 336
 337 /* Nonzero enables loop unrolling in unroll.c.  All loops are unrolled.
 338    This is generally not a win.  */
 339
 340 int flag_unroll_all_loops;
 341
 342 /* Nonzero for -fwritable-strings:
 343    store string constants in data segment and don't uniquize them.  */
 344
 345 int flag_writable_strings = 0;
 346
 347 /* Nonzero means don't put addresses of constant functions in registers.
 348    Used for compiling the Unix kernel, where strange substitutions are
 349    done on the assembly output.  */
 350
 351 int flag_no_function_cse = 0;
 352
 353 /* Nonzero for -fomit-frame-pointer:
 354    don't make a frame pointer in simple functions that don't require one.  */
 355
 356 int flag_omit_frame_pointer = 0;
 357
 358 /* Nonzero to inhibit use of define_optimization peephole opts.  */
 359
 360 int flag_no_peephole = 0;
 361
 362 /* Nonzero allows GCC to violate some IEEE or ANSI rules regarding math
 363    operations in the interest of optimization.  For example it allows
 364    GCC to assume arguments to sqrt are nonnegative numbers, allowing
 365    faster code for sqrt to be generated. */
 366
 367 int flag_fast_math = 0;
 368
 369 /* Nonzero means all references through pointers are volatile.  */
 370
 371 int flag_volatile;
 372
 373 /* Nonzero means treat all global and extern variables as global.  */
 374
 375 int flag_volatile_global;
 376
 377 /* Nonzero means just do syntax checking; don't output anything.  */
 378
 379 int flag_syntax_only = 0;
 380
 381 /* Nonzero means to rerun cse after loop optimization.  This increases
 382    compilation time about 20% and picks up a few more common expressions.  */
 383
 384 static int flag_rerun_cse_after_loop;
 385
 386 /* Nonzero for -finline-functions: ok to inline functions that look like
 387    good inline candidates.  */
 388
 389 int flag_inline_functions;
 390
 391 /* Nonzero for -fkeep-inline-functions: even if we make a function
 392    go inline everywhere, keep its definition around for debugging
 393    purposes.  */
 394
 395 int flag_keep_inline_functions;
 396
 397 /* Nonzero means that functions declared `inline' will be treated
 398    as `static'.  Prevents generation of zillions of copies of unused
 399    static inline functions; instead, `inlines' are written out
 400    only when actually used.  Used in conjunction with -g.  Also
 401    does the right thing with #pragma interface.  */
 402
 403 int flag_no_inline;
 404
 405 /* Nonzero means we should be saving declaration info into a .X file.  */
 406
 407 int flag_gen_aux_info = 0;
 408
 409 /* Specified name of aux-info file.  */
 410
 411 static char *aux_info_file_name;
 412
 413 /* Nonzero means make the text shared if supported.  */
 414
 415 int flag_shared_data;
 416
 417 /* Nonzero means schedule into delayed branch slots if supported.  */
 418
 419 int flag_delayed_branch;
 420
 421 /* Nonzero if we are compiling pure (sharable) code.
 422    Value is 1 if we are doing reasonable (i.e. simple
 423    offset into offset table) pic.  Value is 2 if we can
 424    only perform register offsets.  */
 425
 426 int flag_pic;
 427
 428 /* Nonzero means place uninitialized global data in the bss section. */
 429
 430 int flag_no_common;
 431
 432 /* Nonzero means pretend it is OK to examine bits of target floats,
 433    even if that isn't true.  The resulting code will have incorrect constants,
 434    but the same series of instructions that the native compiler would make.  */
 435
 436 int flag_pretend_float;
 437
 438 /* Nonzero means change certain warnings into errors.
 439    Usually these are warnings about failure to conform to some standard.  */
 440
 441 int flag_pedantic_errors = 0;
 442
 443 /* flag_schedule_insns means schedule insns within basic blocks (before
 444    local_alloc).
 445    flag_schedule_insns_after_reload means schedule insns after
 446    global_alloc.  */
 447
 448 int flag_schedule_insns = 0;
 449 int flag_schedule_insns_after_reload = 0;
 450
 451 /* -finhibit-size-directive inhibits output of .size for ELF.
 452    This is used only for compiling crtstuff.c,
 453    and it may be extended to other effects
 454    needed for crtstuff.c on other systems.  */
 455 int flag_inhibit_size_directive = 0;
 456
 457 /* -fverbose-asm causes extra commentary information to be produced in
 458    the generated assembly code (to make it more readable).  This option
 459    is generally only of use to those who actually need to read the
 460    generated assembly code (perhaps while debugging the compiler itself).  */
 461
 462 int flag_verbose_asm = 0;
 463
 464 /* -fgnu-linker specifies use of the GNU linker for initializations.
 465    (Or, more generally, a linker that handles initializations.)
 466    -fno-gnu-linker says that collect2 will be used.  */
 467 #ifdef USE_COLLECT2
 468 int flag_gnu_linker = 0;
 469 #else
 470 int flag_gnu_linker = 1;
 471 #endif
 472
 473 /* Table of language-independent -f options.
 474    STRING is the option name.  VARIABLE is the address of the variable.
 475    ON_VALUE is the value to store in VARIABLE
 476     if `-fSTRING' is seen as an option.
 477    (If `-fno-STRING' is seen as an option, the opposite value is stored.)  */
 478
 479 struct { char *string; int *variable; int on_value;} f_options[] =
 480 {
 481   {"float-store", &flag_float_store, 1},
 482   {"volatile", &flag_volatile, 1},
 483   {"volatile-global", &flag_volatile_global, 1},
 484   {"defer-pop", &flag_defer_pop, 1},
 485   {"omit-frame-pointer", &flag_omit_frame_pointer, 1},
 486   {"cse-follow-jumps", &flag_cse_follow_jumps, 1},
 487   {"cse-skip-blocks", &flag_cse_skip_blocks, 1},
 488   {"expensive-optimizations", &flag_expensive_optimizations, 1},
 489   {"thread-jumps", &flag_thread_jumps, 1},
 490   {"strength-reduce", &flag_strength_reduce, 1},
 491   {"unroll-loops", &flag_unroll_loops, 1},
 492   {"unroll-all-loops", &flag_unroll_all_loops, 1},
 493   {"writable-strings", &flag_writable_strings, 1},
 494   {"peephole", &flag_no_peephole, 0},
 495   {"force-mem", &flag_force_mem, 1},
 496   {"force-addr", &flag_force_addr, 1},
 497   {"function-cse", &flag_no_function_cse, 0},
 498   {"inline-functions", &flag_inline_functions, 1},
 499   {"keep-inline-functions", &flag_keep_inline_functions, 1},
 500   {"inline", &flag_no_inline, 0},
 501   {"syntax-only", &flag_syntax_only, 1},
 502   {"shared-data", &flag_shared_data, 1},
 503   {"caller-saves", &flag_caller_saves, 1},
 504   {"pcc-struct-return", &flag_pcc_struct_return, 1},
 505   {"reg-struct-return", &flag_pcc_struct_return, 0},
 506   {"delayed-branch", &flag_delayed_branch, 1},
 507   {"rerun-cse-after-loop", &flag_rerun_cse_after_loop, 1},
 508   {"pretend-float", &flag_pretend_float, 1},
 509   {"schedule-insns", &flag_schedule_insns, 1},
 510   {"schedule-insns2", &flag_schedule_insns_after_reload, 1},
 511   {"pic", &flag_pic, 1},
 512   {"PIC", &flag_pic, 2},
 513   {"fast-math", &flag_fast_math, 1},
 514   {"common", &flag_no_common, 0},
 515   {"inhibit-size-directive", &flag_inhibit_size_directive, 1},
 516   {"verbose-asm", &flag_verbose_asm, 1},
 517   {"gnu-linker", &flag_gnu_linker, 1}
 518 };
 519
 520 /* Table of language-specific options.  */
 521
 522 char *lang_options[] =
 523 {
 524   "-ftraditional",
 525   "-traditional",
 526   "-fnotraditional",
 527   "-fno-traditional",
 528   "-fsigned-char",
 529   "-funsigned-char",
 530   "-fno-signed-char",
 531   "-fno-unsigned-char",
 532   "-fsigned-bitfields",
 533   "-funsigned-bitfields",
 534   "-fno-signed-bitfields",
 535   "-fno-unsigned-bitfields",
 536   "-fshort-enums",
 537   "-fno-short-enums",
 538   "-fcond-mismatch",
 539   "-fno-cond-mismatch",
 540   "-fshort-double",
 541   "-fno-short-double",
 542   "-fasm",
 543   "-fno-asm",
 544   "-fbuiltin",
 545   "-fno-builtin",
 546   "-fno-ident",
 547   "-fident",
 548   "-ansi",
 549   "-Wimplicit",
 550   "-Wno-implicit",
 551   "-Wwrite-strings",
 552   "-Wno-write-strings",
 553   "-Wcast-qual",
 554   "-Wno-cast-qual",
 555   "-Wpointer-arith",
 556   "-Wno-pointer-arith",
 557   "-Wstrict-prototypes",
 558   "-Wno-strict-prototypes",
 559   "-Wmissing-prototypes",
 560   "-Wno-missing-prototypes",
 561   "-Wredundant-decls",
 562   "-Wno-redundant-decls",
 563   "-Wnested-externs",
 564   "-Wno-nested-externs",
 565   "-Wtraditional",
 566   "-Wno-traditional",
 567   "-Wformat",
 568   "-Wno-format",
 569   "-Wchar-subscripts",
 570   "-Wno-char-subscripts",
 571   "-Wconversion",
 572   "-Wno-conversion",
 573   "-Wparentheses",
 574   "-Wno-parentheses",
 575   "-Wcomment",
 576   "-Wno-comment",
 577   "-Wcomments",
 578   "-Wno-comments",
 579   "-Wtrigraphs",
 580   "-Wno-trigraphs",
 581   "-Wimport",
 582   "-Wno-import",
 583   "-Wmissing-braces",
 584   "-Wno-missing-braces",
 585   "-Wall",
 586
 587   /* These are for C++.  */
 588   "-+e0",                       /* gcc.c tacks the `-' on the front.  */
 589   "-+e1",
 590   "-+e2",
 591   "-fsave-memoized",
 592   "-fno-save-memoized",
 593   "-fcadillac",
 594   "-fno-cadillac",
 595   "-fgc",
 596   "-fno-gc",
 597   "-flabels-ok",
 598   "-fno-labels-ok",
 599   "-fstats",
 600   "-fno-stats",
 601   "-fthis-is-variable",
 602   "-fno-this-is-variable",
 603   "-fstrict-prototype",
 604   "-fno-strict-prototype",
 605   "-fall-virtual",
 606   "-fno-all-virtual",
 607   "-fmemoize-lookups",
 608   "-fno-memoize-lookups",
 609   "-felide-constructors",
 610   "-fno-elide-constructors",
 611   "-finline-debug",
 612   "-fno-inline-debug",
 613   "-fhandle-exceptions",
 614   "-fno-handle-exceptions",
 615   "-fansi-exceptions",
 616   "-fno-ansi-exceptions",
 617   "-fspring-exceptions",
 618   "-fno-spring-exceptions",
 619   "-fdefault-inline",
 620   "-fno-default-inline",
 621   "-fenum-int-equiv",
 622   "-fno-enum-int-equiv",
 623   "-fdossier",
 624   "-fno-dossier",
 625   "-fxref",
 626   "-fno-xref",
 627   "-fnonnull-objects",
 628   "-fno-nonnull-objects",
 629   "-fimplement-inlines",
 630   "-fno-implement-inlines",
 631
 632   "-Wreturn-type",
 633   "-Wno-return-type",
 634   "-Woverloaded-virtual",
 635   "-Wno-overloaded-virtual",
 636   "-Wenum-clash",
 637   "-Wno-enum-clash",
 638   "-Wtemplate-debugging",
 639   "-Wno-template-debugging",
 640
 641   /* these are for obj c */
 642   "-lang-objc",
 643   "-gen-decls",
 644   "-fgnu-runtime",
 645   "-fno-gnu-runtime",
 646   "-fnext-runtime",
 647   "-fno-next-runtime",
 648   "-Wselector",
 649   "-Wno-selector",
 650   "-Wprotocol",
 651   "-Wno-protocol",
 652   0
 653 };
 654 \f
 655 /* Options controlling warnings */
 656
 657 /* Don't print warning messages.  -w.  */
 658
 659 int inhibit_warnings = 0;
 660
 661 /* Print various extra warnings.  -W.  */
 662
 663 int extra_warnings = 0;
 664
 665 /* Treat warnings as errors.  -Werror.  */
 666
 667 int warnings_are_errors = 0;
 668
 669 /* Nonzero to warn about unused local variables.  */
 670
 671 int warn_unused;
 672
 673 /* Nonzero to warn about variables used before they are initialized.  */
 674
 675 int warn_uninitialized;
 676
 677 /* Nonzero means warn about all declarations which shadow others.   */
 678
 679 int warn_shadow;
 680
 681 /* Warn if a switch on an enum fails to have a case for every enum value.  */
 682
 683 int warn_switch;
 684
 685 /* Nonzero means warn about function definitions that default the return type
 686    or that use a null return and have a return-type other than void.  */
 687
 688 int warn_return_type;
 689
 690 /* Nonzero means warn about pointer casts that increase the required
 691    alignment of the target type (and might therefore lead to a crash
 692    due to a misaligned access).  */
 693
 694 int warn_cast_align;
 695
 696 /* Nonzero means warn about any identifiers that match in the first N
 697    characters.  The value N is in `id_clash_len'.  */
 698
 699 int warn_id_clash;
 700 int id_clash_len;
 701
 702 /* Nonzero means warn if inline function is too large.  */
 703
 704 int warn_inline;
 705
 706 /* Warn if a function returns an aggregate,
 707    since there are often incompatible calling conventions for doing this.  */
 708
 709 int warn_aggregate_return;
 710
 711 /* Likewise for -W.  */
 712
 713 struct { char *string; int *variable; int on_value;} W_options[] =
 714 {
 715   {"unused", &warn_unused, 1},
 716   {"error", &warnings_are_errors, 1},
 717   {"shadow", &warn_shadow, 1},
 718   {"switch", &warn_switch, 1},
 719   {"aggregate-return", &warn_aggregate_return, 1},
 720   {"cast-align", &warn_cast_align, 1},
 721   {"uninitialized", &warn_uninitialized, 1},
 722   {"inline", &warn_inline, 1}
 723 };
 724 \f
 725 /* Output files for assembler code (real compiler output)
 726    and debugging dumps.  */
 727
 728 FILE *asm_out_file;
 729 FILE *aux_info_file;
 730 FILE *rtl_dump_file;
 731 FILE *jump_opt_dump_file;
 732 FILE *cse_dump_file;
 733 FILE *loop_dump_file;
 734 FILE *cse2_dump_file;
 735 FILE *flow_dump_file;
 736 FILE *combine_dump_file;
 737 FILE *sched_dump_file;
 738 FILE *local_reg_dump_file;
 739 FILE *global_reg_dump_file;
 740 FILE *sched2_dump_file;
 741 FILE *jump2_opt_dump_file;
 742 FILE *dbr_sched_dump_file;
 743 FILE *stack_reg_dump_file;
 744
 745 /* Time accumulators, to count the total time spent in various passes.  */
 746
 747 int parse_time;
 748 int varconst_time;
 749 int integration_time;
 750 int jump_time;
 751 int cse_time;
 752 int loop_time;
 753 int cse2_time;
 754 int flow_time;
 755 int combine_time;
 756 int sched_time;
 757 int local_alloc_time;
 758 int global_alloc_time;
 759 int sched2_time;
 760 int dbr_sched_time;
 761 int shorten_branch_time;
 762 int stack_reg_time;
 763 int final_time;
 764 int symout_time;
 765 int dump_time;
 766 \f
 767 /* Return time used so far, in microseconds.  */
 768
 769 int
 770 get_run_time ()
 771 {
 772 #ifdef USG
 773   struct tms tms;
 774 #else
 775 #ifndef VMS
 776   struct rusage rusage;
 777 #else /* VMS */
 778   struct
 779     {
 780       int proc_user_time;
 781       int proc_system_time;
 782       int child_user_time;
 783       int child_system_time;
 784     } vms_times;
 785 #endif
 786 #endif
 787
 788   if (quiet_flag)
 789     return 0;
 790
 791 #ifdef USG
 792   times (&tms);
 793   return (tms.tms_utime + tms.tms_stime) * (1000000 / HZ);
 794 #else
 795 #ifndef VMS
 796   getrusage (0, &rusage);
 797   return (rusage.ru_utime.tv_sec * 1000000 + rusage.ru_utime.tv_usec
 798           + rusage.ru_stime.tv_sec * 1000000 + rusage.ru_stime.tv_usec);
 799 #else /* VMS */
 800   times (&vms_times);
 801   return (vms_times.proc_user_time + vms_times.proc_system_time) * 10000;
 802 #endif
 803 #endif
 804 }
 805
 806 #define TIMEVAR(VAR, BODY)    \
 807 do { int otime = get_run_time (); BODY; VAR += get_run_time () - otime; } while (0)
 808
 809 void
 810 print_time (str, total)
 811      char *str;
 812      int total;
 813 {
 814   fprintf (stderr,
 815            "time in %s: %d.%06d\n",
 816            str, total / 1000000, total % 1000000);
 817 }
 818
 819 /* Count an error or warning.  Return 1 if the message should be printed.  */
 820
 821 int
 822 count_error (warningp)
 823      int warningp;
 824 {
 825   if (warningp && inhibit_warnings)
 826     return 0;
 827
 828   if (warningp && !warnings_are_errors)
 829     warningcount++;
 830   else
 831     {
 832       static int warning_message = 0;
 833
 834       if (warningp && !warning_message)
 835         {
 836           fprintf (stderr, "%s: warnings being treated as errors\n", progname);
 837           warning_message = 1;
 838         }
 839       errorcount++;
 840     }
 841
 842   return 1;
 843 }
 844
 845 /* Print a fatal error message.  NAME is the text.
 846    Also include a system error message based on `errno'.  */
 847
 848 void
 849 pfatal_with_name (name)
 850      char *name;
 851 {
 852   fprintf (stderr, "%s: ", progname);
 853   perror (name);
 854   exit (35);
 855 }
 856
 857 void
 858 fatal_io_error (name)
 859      char *name;
 860 {
 861   fprintf (stderr, "%s: %s: I/O error\n", progname, name);
 862   exit (35);
 863 }
 864
 865 void
 866 fatal (s, v)
 867      char *s;
 868      int v;
 869 {
 870   error (s, v);
 871   exit (34);
 872 }
 873
 874 /* Called to give a better error message when we don't have an insn to match
 875    what we are looking for or if the insn's constraints aren't satisfied,
 876    rather than just calling abort().  */
 877
 878 void
 879 fatal_insn_not_found (insn)
 880      rtx insn;
 881 {
 882   if (INSN_CODE (insn) < 0)
 883     error ("internal error--unrecognizable insn:", 0);
 884   else
 885     error ("internal error--insn does not satisfy its constraints:", 0);
 886   debug_rtx (insn);
 887   if (asm_out_file)
 888     fflush (asm_out_file);
 889   if (aux_info_file)
 890     fflush (aux_info_file);
 891   if (rtl_dump_file)
 892     fflush (rtl_dump_file);
 893   if (jump_opt_dump_file)
 894     fflush (jump_opt_dump_file);
 895   if (cse_dump_file)
 896     fflush (cse_dump_file);
 897   if (loop_dump_file)
 898     fflush (loop_dump_file);
 899   if (cse2_dump_file)
 900     fflush (cse2_dump_file);
 901   if (flow_dump_file)
 902     fflush (flow_dump_file);
 903   if (combine_dump_file)
 904     fflush (combine_dump_file);
 905   if (sched_dump_file)
 906     fflush (sched_dump_file);
 907   if (local_reg_dump_file)
 908     fflush (local_reg_dump_file);
 909   if (global_reg_dump_file)
 910     fflush (global_reg_dump_file);
 911   if (sched2_dump_file)
 912     fflush (sched2_dump_file);
 913   if (jump2_opt_dump_file)
 914     fflush (jump2_opt_dump_file);
 915   if (dbr_sched_dump_file)
 916     fflush (dbr_sched_dump_file);
 917   if (stack_reg_dump_file)
 918     fflush (stack_reg_dump_file);
 919   abort ();
 920 }
 921
 922 /* This is the default decl_printable_name function.  */
 923
 924 static char *
 925 decl_name (decl, kind)
 926      tree decl;
 927      char **kind;
 928 {
 929   return IDENTIFIER_POINTER (DECL_NAME (decl));
 930 }
 931 \f
 932 static int need_error_newline;
 933
 934 /* Function of last error message;
 935    more generally, function such that if next error message is in it
 936    then we don't have to mention the function name.  */
 937 static tree last_error_function = NULL;
 938
 939 /* Used to detect when input_file_stack has changed since last described.  */
 940 static int last_error_tick;
 941
 942 /* Called when the start of a function definition is parsed,
 943    this function prints on stderr the name of the function.  */
 944
 945 void
 946 announce_function (decl)
 947      tree decl;
 948 {
 949   if (! quiet_flag)
 950     {
 951       char *junk;
 952       if (rtl_dump_and_exit)
 953         fprintf (stderr, "%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
 954       else
 955         fprintf (stderr, " %s", (*decl_printable_name) (decl, &junk));
 956       fflush (stderr);
 957       need_error_newline = 1;
 958       last_error_function = current_function_decl;
 959     }
 960 }
 961
 962 /* Prints out, if necessary, the name of the current function
 963    which caused an error.  Called from all error and warning functions.  */
 964
 965 void
 966 report_error_function (file)
 967      char *file;
 968 {
 969   struct file_stack *p;
 970
 971   if (need_error_newline)
 972     {
 973       fprintf (stderr, "\n");
 974       need_error_newline = 0;
 975     }
 976
 977   if (last_error_function != current_function_decl)
 978     {
 979       char *kind = "function";
 980       if (current_function_decl != 0
 981           && TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
 982         kind = "method";
 983
 984       if (file)
 985         fprintf (stderr, "%s: ", file);
 986
 987       if (current_function_decl == NULL)
 988         fprintf (stderr, "At top level:\n");
 989       else
 990         {
 991           char *name = (*decl_printable_name) (current_function_decl, &kind);
 992           fprintf (stderr, "In %s `%s':\n", kind, name);
 993         }
 994
 995       last_error_function = current_function_decl;
 996     }
 997   if (input_file_stack && input_file_stack->next != 0
 998       && input_file_stack_tick != last_error_tick)
 999     {
1000       fprintf (stderr, "In file included");
1001       for (p = input_file_stack->next; p; p = p->next)
1002         {
1003           fprintf (stderr, " from %s:%d", p->name, p->line);
1004           if (p->next)
1005             fprintf (stderr, ",\n                ");
1006         }
1007       fprintf (stderr, ":\n");
1008       last_error_tick = input_file_stack_tick;
1009     }
1010 }
1011
1012 /* Report an error at the current line number.
1013    S is a string and V and V2 are args for `printf'.  We use HOST_WIDE_INT
1014    as the type for these args assuming it is wide enough to hold a
1015    pointer.  This isn't terribly portable, but is the best we can do
1016    without vprintf universally available.  */
1017
1018 void
1019 error (s, v, v2)
1020      char *s;
1021      HOST_WIDE_INT v;           /* Also used as pointer */
1022      HOST_WIDE_INT v2;          /* Also used as pointer */
1023 {
1024   error_with_file_and_line (input_filename, lineno, s, v, v2);
1025 }
1026
1027 /* Report an error at line LINE of file FILE.
1028    S and V are a string and an arg for `printf'.  */
1029
1030 void
1031 error_with_file_and_line (file, line, s, v, v2)
1032      char *file;
1033      int line;
1034      char *s;
1035      HOST_WIDE_INT v;
1036      HOST_WIDE_INT v2;
1037 {
1038   count_error (0);
1039
1040   report_error_function (file);
1041
1042   if (file)
1043     fprintf (stderr, "%s:%d: ", file, line);
1044   else
1045     fprintf (stderr, "%s: ", progname);
1046   fprintf (stderr, s, v, v2);
1047   fprintf (stderr, "\n");
1048 }
1049
1050 /* Report an error at the declaration DECL.
1051    S and V are a string and an arg which uses %s to substitute
1052    the declaration name.  */
1053
1054 void
1055 error_with_decl (decl, s, v)
1056      tree decl;
1057      char *s;
1058      HOST_WIDE_INT v;
1059 {
1060   char *junk;
1061   count_error (0);
1062
1063   report_error_function (DECL_SOURCE_FILE (decl));
1064
1065   fprintf (stderr, "%s:%d: ",
1066            DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
1067
1068   if (DECL_NAME (decl))
1069     fprintf (stderr, s, (*decl_printable_name) (decl, &junk), v);
1070   else
1071     fprintf (stderr, s, "((anonymous))", v);
1072   fprintf (stderr, "\n");
1073 }
1074
1075 /* Report an error at the line number of the insn INSN.
1076    S and V are a string and an arg for `printf'.
1077    This is used only when INSN is an `asm' with operands,
1078    and each ASM_OPERANDS records its own source file and line.  */
1079
1080 void
1081 error_for_asm (insn, s, v, v2)
1082      rtx insn;
1083      char *s;
1084      HOST_WIDE_INT v;           /* Also used as pointer */
1085      HOST_WIDE_INT v2;          /* Also used as pointer */
1086 {
1087   char *filename;
1088   int line;
1089   rtx body = PATTERN (insn);
1090   rtx asmop;
1091
1092   /* Find the (or one of the) ASM_OPERANDS in the insn.  */
1093   if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
1094     asmop = SET_SRC (body);
1095   else if (GET_CODE (body) == ASM_OPERANDS)
1096     asmop = body;
1097   else if (GET_CODE (body) == PARALLEL
1098            && GET_CODE (XVECEXP (body, 0, 0)) == SET)
1099     asmop = SET_SRC (XVECEXP (body, 0, 0));
1100   else if (GET_CODE (body) == PARALLEL
1101            && GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
1102     asmop = XVECEXP (body, 0, 0);
1103
1104   filename = ASM_OPERANDS_SOURCE_FILE (asmop);
1105   line = ASM_OPERANDS_SOURCE_LINE (asmop);
1106
1107   error_with_file_and_line (filename, line, s, v, v2);
1108 }
1109
1110 /* Report a warning at line LINE.
1111    S and V are a string and an arg for `printf'.  */
1112
1113 void
1114 warning_with_file_and_line (file, line, s, v, v2, v3)
1115      char *file;
1116      int line;
1117      char *s;
1118      HOST_WIDE_INT v, v2, v3;
1119 {
1120   if (count_error (1) == 0)
1121     return;
1122
1123   report_error_function (file);
1124
1125   if (file)
1126     fprintf (stderr, "%s:%d: ", file, line);
1127   else
1128     fprintf (stderr, "%s: ", progname);
1129
1130   fprintf (stderr, "warning: ");
1131   fprintf (stderr, s, v, v2, v3);
1132   fprintf (stderr, "\n");
1133 }
1134
1135 /* Report a warning at the current line number.
1136    S and V are a string and an arg for `printf'.  */
1137
1138 void
1139 warning (s, v, v2, v3)
1140      char *s;
1141      HOST_WIDE_INT v, v2, v3;   /* Also used as pointer */
1142 {
1143   warning_with_file_and_line (input_filename, lineno, s, v, v2, v3);
1144 }
1145
1146 /* Report a warning at the declaration DECL.
1147    S is string which uses %s to substitute the declaration name.
1148    V is a second parameter that S can refer to.  */
1149
1150 void
1151 warning_with_decl (decl, s, v)
1152      tree decl;
1153      char *s;
1154      HOST_WIDE_INT v;
1155 {
1156   char *junk;
1157
1158   if (count_error (1) == 0)
1159     return;
1160
1161   report_error_function (DECL_SOURCE_FILE (decl));
1162
1163   fprintf (stderr, "%s:%d: ",
1164            DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
1165
1166   fprintf (stderr, "warning: ");
1167   if (DECL_NAME (decl))
1168     fprintf (stderr, s, (*decl_printable_name) (decl, &junk), v);
1169   else
1170     fprintf (stderr, s, "((anonymous))", v);
1171   fprintf (stderr, "\n");
1172 }
1173
1174 /* Report a warning at the line number of the insn INSN.
1175    S and V are a string and an arg for `printf'.
1176    This is used only when INSN is an `asm' with operands,
1177    and each ASM_OPERANDS records its own source file and line.  */
1178
1179 void
1180 warning_for_asm (insn, s, v, v2)
1181      rtx insn;
1182      char *s;
1183      HOST_WIDE_INT v;           /* Also used as pointer */
1184      HOST_WIDE_INT v2;          /* Also used as pointer */
1185 {
1186   char *filename;
1187   int line;
1188   rtx body = PATTERN (insn);
1189   rtx asmop;
1190
1191   /* Find the (or one of the) ASM_OPERANDS in the insn.  */
1192   if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
1193     asmop = SET_SRC (body);
1194   else if (GET_CODE (body) == ASM_OPERANDS)
1195     asmop = body;
1196   else if (GET_CODE (body) == PARALLEL
1197            && GET_CODE (XVECEXP (body, 0, 0)) == SET)
1198     asmop = SET_SRC (XVECEXP (body, 0, 0));
1199   else if (GET_CODE (body) == PARALLEL
1200            && GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
1201     asmop = XVECEXP (body, 0, 0);
1202
1203   filename = ASM_OPERANDS_SOURCE_FILE (asmop);
1204   line = ASM_OPERANDS_SOURCE_LINE (asmop);
1205
1206   warning_with_file_and_line (filename, line, s, v, v2);
1207 }
1208 \f
1209 /* These functions issue either warnings or errors depending on
1210    -pedantic-errors.  */
1211
1212 void
1213 pedwarn (s, v, v2)
1214      char *s;
1215      HOST_WIDE_INT v;           /* Also used as pointer */
1216      HOST_WIDE_INT v2;
1217 {
1218   if (flag_pedantic_errors)
1219     error (s, v, v2);
1220   else
1221     warning (s, v, v2);
1222 }
1223
1224 void
1225 pedwarn_with_decl (decl, s, v)
1226      tree decl;
1227      char *s;
1228      HOST_WIDE_INT v;
1229 {
1230   if (flag_pedantic_errors)
1231     error_with_decl (decl, s, v);
1232   else
1233     warning_with_decl (decl, s, v);
1234 }
1235
1236 void
1237 pedwarn_with_file_and_line (file, line, s, v, v2)
1238      char *file;
1239      int line;
1240      char *s;
1241      HOST_WIDE_INT v;
1242      HOST_WIDE_INT v2;
1243 {
1244   if (flag_pedantic_errors)
1245     error_with_file_and_line (file, line, s, v, v2);
1246   else
1247     warning_with_file_and_line (file, line, s, v, v2);
1248 }
1249
1250 /* Apologize for not implementing some feature.
1251    S, V, and V2 are a string and args for `printf'.  */
1252
1253 void
1254 sorry (s, v, v2)
1255      char *s;
1256      HOST_WIDE_INT v, v2;
1257 {
1258   sorrycount++;
1259   if (input_filename)
1260     fprintf (stderr, "%s:%d: ", input_filename, lineno);
1261   else
1262     fprintf (stderr, "%s: ", progname);
1263
1264   fprintf (stderr, "sorry, not implemented: ");
1265   fprintf (stderr, s, v, v2);
1266   fprintf (stderr, "\n");
1267 }
1268
1269 /* Apologize for not implementing some feature, then quit.
1270    S, V, and V2 are a string and args for `printf'.  */
1271
1272 void
1273 really_sorry (s, v, v2)
1274      char *s;
1275      HOST_WIDE_INT v, v2;
1276 {
1277   if (input_filename)
1278     fprintf (stderr, "%s:%d: ", input_filename, lineno);
1279   else
1280     fprintf (stderr, "%s: ", progname);
1281
1282   fprintf (stderr, "sorry, not implemented: ");
1283   fprintf (stderr, s, v, v2);
1284   fatal (" (fatal)\n");
1285 }
1286 \f
1287 /* More 'friendly' abort that prints the line and file.
1288    config.h can #define abort fancy_abort if you like that sort of thing.
1289
1290    I don't think this is actually a good idea.
1291    Other sorts of crashes will look a certain way.
1292    It is a good thing if crashes from calling abort look the same way.
1293      -- RMS  */
1294
1295 void
1296 fancy_abort ()
1297 {
1298   fatal ("internal gcc abort");
1299 }
1300
1301 /* This calls abort and is used to avoid problems when abort if a macro.
1302    It is used when we need to pass the address of abort.  */
1303
1304 void
1305 do_abort ()
1306 {
1307   abort ();
1308 }
1309
1310 /* When `malloc.c' is compiled with `rcheck' defined,
1311    it calls this function to report clobberage.  */
1312
1313 void
1314 botch (s)
1315 {
1316   abort ();
1317 }
1318
1319 /* Same as `malloc' but report error if no memory available.  */
1320
1321 char *
1322 xmalloc (size)
1323      unsigned size;
1324 {
1325   register char *value = (char *) malloc (size);
1326   if (value == 0)
1327     fatal ("virtual memory exhausted");
1328   return value;
1329 }
1330
1331 /* Same as `realloc' but report error if no memory available.  */
1332
1333 char *
1334 xrealloc (ptr, size)
1335      char *ptr;
1336      int size;
1337 {
1338   char *result = (char *) realloc (ptr, size);
1339   if (!result)
1340     fatal ("virtual memory exhausted");
1341   return result;
1342 }
1343 \f
1344 /* Return the logarithm of X, base 2, considering X unsigned,
1345    if X is a power of 2.  Otherwise, returns -1.
1346
1347    This should be used via the `exact_log2' macro.  */
1348
1349 int
1350 exact_log2_wide (x)
1351      register unsigned HOST_WIDE_INT x;
1352 {
1353   register int log = 0;
1354   /* Test for 0 or a power of 2.  */
1355   if (x == 0 || x != (x & -x))
1356     return -1;
1357   while ((x >>= 1) != 0)
1358     log++;
1359   return log;
1360 }
1361
1362 /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
1363    If X is 0, return -1.
1364
1365    This should be used via the floor_log2 macro.  */
1366
1367 int
1368 floor_log2_wide (x)
1369      register unsigned HOST_WIDE_INT x;
1370 {
1371   register int log = -1;
1372   while (x != 0)
1373     log++,
1374     x >>= 1;
1375   return log;
1376 }
1377
1378 int float_handled;
1379 jmp_buf float_handler;
1380
1381 /* Specify where to longjmp to when a floating arithmetic error happens.
1382    If HANDLER is 0, it means don't handle the errors any more.  */
1383
1384 void
1385 set_float_handler (handler)
1386      jmp_buf handler;
1387 {
1388   float_handled = (handler != 0);
1389   if (handler)
1390     bcopy (handler, float_handler, sizeof (float_handler));
1391 }
1392
1393 /* Specify, in HANDLER, where to longjmp to when a floating arithmetic
1394    error happens, pushing the previous specification into OLD_HANDLER.
1395    Return an indication of whether there was a previous handler in effect.  */
1396
1397 int
1398 push_float_handler (handler, old_handler)
1399      jmp_buf handler, old_handler;
1400 {
1401   int was_handled = float_handled;
1402
1403   float_handled = 1;
1404   if (was_handled)
1405     bcopy (float_handler, old_handler, sizeof (float_handler));
1406   bcopy (handler, float_handler, sizeof (float_handler));
1407   return was_handled;
1408 }
1409
1410 /* Restore the previous specification of whether and where to longjmp to
1411    when a floating arithmetic error happens.  */
1412
1413 void
1414 pop_float_handler (handled, handler)
1415      int handled;
1416      jmp_buf handler;
1417 {
1418   float_handled = handled;
1419   if (handled)
1420     bcopy (handler, float_handler, sizeof (float_handler));
1421 }
1422
1423 /* Signals actually come here.  */
1424
1425 static void
1426 float_signal (signo)
1427      /* If this is missing, some compilers complain.  */
1428      int signo;
1429 {
1430   if (float_handled == 0)
1431     abort ();
1432 #if defined (USG) || defined (hpux)
1433   signal (SIGFPE, float_signal);  /* re-enable the signal catcher */
1434 #endif
1435   float_handled = 0;
1436   signal (SIGFPE, float_signal);
1437   longjmp (float_handler, 1);
1438 }
1439
1440 /* Handler for SIGPIPE.  */
1441
1442 static void
1443 pipe_closed (signo)
1444      /* If this is missing, some compilers complain.  */
1445      int signo;
1446 {
1447   fatal ("output pipe has been closed");
1448 }
1449
1450 /* Strip off a legitimate source ending from the input string NAME of
1451    length LEN. */
1452
1453 void
1454 strip_off_ending (name, len)
1455      char *name;
1456      int len;
1457 {
1458   if (len > 2 && ! strcmp (".c", name + len - 2))
1459     name[len - 2] = 0;
1460   else if (len > 2 && ! strcmp (".m", name + len - 2))
1461     name[len - 2] = 0;
1462   else if (len > 2 && ! strcmp (".i", name + len - 2))
1463     name[len - 2] = 0;
1464   else if (len > 3 && ! strcmp (".ii", name + len - 3))
1465     name[len - 3] = 0;
1466   else if (len > 3 && ! strcmp (".co", name + len - 3))
1467     name[len - 3] = 0;
1468   else if (len > 3 && ! strcmp (".cc", name + len - 3))
1469     name[len - 3] = 0;
1470   else if (len > 2 && ! strcmp (".C", name + len - 2))
1471     name[len - 2] = 0;
1472   else if (len > 4 && ! strcmp (".cxx", name + len - 4))
1473     name[len - 4] = 0;
1474   else if (len > 2 && ! strcmp (".f", name + len - 2))
1475     name[len - 2] = 0;
1476   else if (len > 4 && ! strcmp (".ada", name + len - 4))
1477     name[len - 4] = 0;
1478   else if (len > 4 && ! strcmp (".atr", name + len - 4))
1479     name[len - 4] = 0;
1480 }
1481
1482 /* Output a file name in the form wanted by System V.  */
1483
1484 void
1485 output_file_directive (asm_file, input_name)
1486      FILE *asm_file;
1487      char *input_name;
1488 {
1489   int len = strlen (input_name);
1490   char *na = input_name + len;
1491
1492   /* NA gets INPUT_NAME sans directory names.  */
1493   while (na > input_name)
1494     {
1495       if (na[-1] == '/')
1496         break;
1497       na--;
1498     }
1499
1500 #ifdef ASM_OUTPUT_MAIN_SOURCE_FILENAME
1501   ASM_OUTPUT_MAIN_SOURCE_FILENAME (asm_file, na);
1502 #else
1503 #ifdef ASM_OUTPUT_SOURCE_FILENAME
1504   ASM_OUTPUT_SOURCE_FILENAME (asm_file, na);
1505 #else
1506   fprintf (asm_file, "\t.file\t\"%s\"\n", na);
1507 #endif
1508 #endif
1509 }
1510 \f
1511 /* Routine to build language identifier for object file. */
1512 static void
1513 output_lang_identify (asm_out_file)
1514      FILE *asm_out_file;
1515 {
1516   int len = strlen (lang_identify ()) + sizeof ("__gnu_compiled_") + 1;
1517   char *s = (char *) alloca (len);
1518   sprintf (s, "__gnu_compiled_%s", lang_identify ());
1519   ASM_OUTPUT_LABEL (asm_out_file, s);
1520 }
1521
1522 /* Compile an entire file of output from cpp, named NAME.
1523    Write a file of assembly output and various debugging dumps.  */
1524
1525 static void
1526 compile_file (name)
1527      char *name;
1528 {
1529   tree globals;
1530   int start_time;
1531   int dump_base_name_length;
1532
1533   int name_specified = name != 0;
1534
1535   if (dump_base_name == 0)
1536     dump_base_name = name ? name : "gccdump";
1537   dump_base_name_length = strlen (dump_base_name);
1538
1539   parse_time = 0;
1540   varconst_time = 0;
1541   integration_time = 0;
1542   jump_time = 0;
1543   cse_time = 0;
1544   loop_time = 0;
1545   cse2_time = 0;
1546   flow_time = 0;
1547   combine_time = 0;
1548   sched_time = 0;
1549   local_alloc_time = 0;
1550   global_alloc_time = 0;
1551   sched2_time = 0;
1552   dbr_sched_time = 0;
1553   shorten_branch_time = 0;
1554   stack_reg_time = 0;
1555   final_time = 0;
1556   symout_time = 0;
1557   dump_time = 0;
1558
1559   /* Open input file.  */
1560
1561   if (name == 0 || !strcmp (name, "-"))
1562     {
1563       finput = stdin;
1564       name = "stdin";
1565     }
1566   else
1567     finput = fopen (name, "r");
1568   if (finput == 0)
1569     pfatal_with_name (name);
1570
1571 #ifdef IO_BUFFER_SIZE
1572   setvbuf (finput, (char *) xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE);
1573 #endif
1574
1575   /* Initialize data in various passes.  */
1576
1577   init_obstacks ();
1578   init_tree_codes ();
1579   init_lex ();
1580   init_rtl ();
1581   init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL
1582                   || debug_info_level == DINFO_LEVEL_VERBOSE);
1583   init_decl_processing ();
1584   init_optabs ();
1585   init_stmt ();
1586   init_expmed ();
1587   init_expr_once ();
1588   init_loop ();
1589   init_reload ();
1590
1591   if (flag_caller_saves)
1592     init_caller_save ();
1593
1594   /* If auxiliary info generation is desired, open the output file.
1595      This goes in the same directory as the source file--unlike
1596      all the other output files.  */
1597   if (flag_gen_aux_info)
1598     {
1599       aux_info_file = fopen (aux_info_file_name, "w");
1600       if (aux_info_file == 0)
1601         pfatal_with_name (aux_info_file_name);
1602     }
1603
1604   /* If rtl dump desired, open the output file.  */
1605   if (rtl_dump)
1606     {
1607       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1608       strcpy (dumpname, dump_base_name);
1609       strcat (dumpname, ".rtl");
1610       rtl_dump_file = fopen (dumpname, "w");
1611       if (rtl_dump_file == 0)
1612         pfatal_with_name (dumpname);
1613     }
1614
1615   /* If jump_opt dump desired, open the output file.  */
1616   if (jump_opt_dump)
1617     {
1618       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1619       strcpy (dumpname, dump_base_name);
1620       strcat (dumpname, ".jump");
1621       jump_opt_dump_file = fopen (dumpname, "w");
1622       if (jump_opt_dump_file == 0)
1623         pfatal_with_name (dumpname);
1624     }
1625
1626   /* If cse dump desired, open the output file.  */
1627   if (cse_dump)
1628     {
1629       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1630       strcpy (dumpname, dump_base_name);
1631       strcat (dumpname, ".cse");
1632       cse_dump_file = fopen (dumpname, "w");
1633       if (cse_dump_file == 0)
1634         pfatal_with_name (dumpname);
1635     }
1636
1637   /* If loop dump desired, open the output file.  */
1638   if (loop_dump)
1639     {
1640       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1641       strcpy (dumpname, dump_base_name);
1642       strcat (dumpname, ".loop");
1643       loop_dump_file = fopen (dumpname, "w");
1644       if (loop_dump_file == 0)
1645         pfatal_with_name (dumpname);
1646     }
1647
1648   /* If cse2 dump desired, open the output file.  */
1649   if (cse2_dump)
1650     {
1651       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1652       strcpy (dumpname, dump_base_name);
1653       strcat (dumpname, ".cse2");
1654       cse2_dump_file = fopen (dumpname, "w");
1655       if (cse2_dump_file == 0)
1656         pfatal_with_name (dumpname);
1657     }
1658
1659   /* If flow dump desired, open the output file.  */
1660   if (flow_dump)
1661     {
1662       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1663       strcpy (dumpname, dump_base_name);
1664       strcat (dumpname, ".flow");
1665       flow_dump_file = fopen (dumpname, "w");
1666       if (flow_dump_file == 0)
1667         pfatal_with_name (dumpname);
1668     }
1669
1670   /* If combine dump desired, open the output file.  */
1671   if (combine_dump)
1672     {
1673       register char *dumpname = (char *) xmalloc (dump_base_name_length + 10);
1674       strcpy (dumpname, dump_base_name);
1675       strcat (dumpname, ".combine");
1676       combine_dump_file = fopen (dumpname, "w");
1677       if (combine_dump_file == 0)
1678         pfatal_with_name (dumpname);
1679     }
1680
1681   /* If scheduling dump desired, open the output file.  */
1682   if (sched_dump)
1683     {
1684       register char *dumpname = (char *) xmalloc (dump_base_name_length + 7);
1685       strcpy (dumpname, dump_base_name);
1686       strcat (dumpname, ".sched");
1687       sched_dump_file = fopen (dumpname, "w");
1688       if (sched_dump_file == 0)
1689         pfatal_with_name (dumpname);
1690     }
1691
1692   /* If local_reg dump desired, open the output file.  */
1693   if (local_reg_dump)
1694     {
1695       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1696       strcpy (dumpname, dump_base_name);
1697       strcat (dumpname, ".lreg");
1698       local_reg_dump_file = fopen (dumpname, "w");
1699       if (local_reg_dump_file == 0)
1700         pfatal_with_name (dumpname);
1701     }
1702
1703   /* If global_reg dump desired, open the output file.  */
1704   if (global_reg_dump)
1705     {
1706       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1707       strcpy (dumpname, dump_base_name);
1708       strcat (dumpname, ".greg");
1709       global_reg_dump_file = fopen (dumpname, "w");
1710       if (global_reg_dump_file == 0)
1711         pfatal_with_name (dumpname);
1712     }
1713
1714   /* If 2nd scheduling dump desired, open the output file.  */
1715   if (sched2_dump)
1716     {
1717       register char *dumpname = (char *) xmalloc (dump_base_name_length + 8);
1718       strcpy (dumpname, dump_base_name);
1719       strcat (dumpname, ".sched2");
1720       sched2_dump_file = fopen (dumpname, "w");
1721       if (sched2_dump_file == 0)
1722         pfatal_with_name (dumpname);
1723     }
1724
1725   /* If jump2_opt dump desired, open the output file.  */
1726   if (jump2_opt_dump)
1727     {
1728       register char *dumpname = (char *) xmalloc (dump_base_name_length + 7);
1729       strcpy (dumpname, dump_base_name);
1730       strcat (dumpname, ".jump2");
1731       jump2_opt_dump_file = fopen (dumpname, "w");
1732       if (jump2_opt_dump_file == 0)
1733         pfatal_with_name (dumpname);
1734     }
1735
1736   /* If dbr_sched dump desired, open the output file.  */
1737   if (dbr_sched_dump)
1738     {
1739       register char *dumpname = (char *) xmalloc (dump_base_name_length + 7);
1740       strcpy (dumpname, dump_base_name);
1741       strcat (dumpname, ".dbr");
1742       dbr_sched_dump_file = fopen (dumpname, "w");
1743       if (dbr_sched_dump_file == 0)
1744         pfatal_with_name (dumpname);
1745     }
1746
1747 #ifdef STACK_REGS
1748
1749   /* If stack_reg dump desired, open the output file.  */
1750   if (stack_reg_dump)
1751     {
1752       register char *dumpname = (char *) xmalloc (dump_base_name_length + 10);
1753       strcpy (dumpname, dump_base_name);
1754       strcat (dumpname, ".stack");
1755       stack_reg_dump_file = fopen (dumpname, "w");
1756       if (stack_reg_dump_file == 0)
1757         pfatal_with_name (dumpname);
1758     }
1759
1760 #endif
1761
1762   /* Open assembler code output file.  */
1763
1764   if (! name_specified && asm_file_name == 0)
1765     asm_out_file = stdout;
1766   else
1767     {
1768       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1769       int len = strlen (dump_base_name);
1770       strcpy (dumpname, dump_base_name);
1771       strip_off_ending (dumpname, len);
1772       strcat (dumpname, ".s");
1773       if (asm_file_name == 0)
1774         {
1775           asm_file_name = (char *) xmalloc (strlen (dumpname) + 1);
1776           strcpy (asm_file_name, dumpname);
1777         }
1778       if (!strcmp (asm_file_name, "-"))
1779         asm_out_file = stdout;
1780       else
1781         asm_out_file = fopen (asm_file_name, "w");
1782       if (asm_out_file == 0)
1783         pfatal_with_name (asm_file_name);
1784     }
1785
1786 #ifdef IO_BUFFER_SIZE
1787   setvbuf (asm_out_file, (char *) xmalloc (IO_BUFFER_SIZE),
1788            _IOFBF, IO_BUFFER_SIZE);
1789 #endif
1790
1791   input_filename = name;
1792
1793   /* Perform language-specific initialization.
1794      This may set main_input_filename.  */
1795   lang_init ();
1796
1797   /* If the input doesn't start with a #line, use the input name
1798      as the official input file name.  */
1799   if (main_input_filename == 0)
1800     main_input_filename = name;
1801
1802   /* Put an entry on the input file stack for the main input file.  */
1803   input_file_stack
1804     = (struct file_stack *) xmalloc (sizeof (struct file_stack));
1805   input_file_stack->next = 0;
1806   input_file_stack->name = input_filename;
1807
1808   ASM_FILE_START (asm_out_file);
1809
1810   /* Output something to inform GDB that this compilation was by GCC.  */
1811 #ifndef ASM_IDENTIFY_GCC
1812   fprintf (asm_out_file, "gcc2_compiled.:\n");
1813 #else
1814   ASM_IDENTIFY_GCC (asm_out_file);
1815 #endif
1816
1817   /* Output something to identify which front-end produced this file. */
1818 #ifdef ASM_IDENTIFY_LANGUAGE
1819   ASM_IDENTIFY_LANGUAGE (asm_out_file);
1820 #endif
1821
1822 /* ??? Note: There used to be a conditional here
1823    to call assemble_zeros without fail if DBX_DEBUGGING_INFO is defined.
1824    This was to guarantee separation between gcc_compiled. and
1825    the first function, for the sake of dbx on Suns.
1826    However, having the extra zero here confused the Emacs
1827    code for unexec, and might confuse other programs too.
1828    Therefore, I took out that change.
1829    In future versions we should find another way to solve
1830    that dbx problem.  -- rms, 23 May 93.  */
1831
1832   /* Don't let the first function fall at the same address
1833      as gcc_compiled., if profiling.  */
1834   if (profile_flag || profile_block_flag)
1835     assemble_zeros (UNITS_PER_WORD);
1836
1837   /* If dbx symbol table desired, initialize writing it
1838      and output the predefined types.  */
1839 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1840   if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
1841     TIMEVAR (symout_time, dbxout_init (asm_out_file, main_input_filename,
1842                                        getdecls ()));
1843 #endif
1844 #ifdef SDB_DEBUGGING_INFO
1845   if (write_symbols == SDB_DEBUG)
1846     TIMEVAR (symout_time, sdbout_init (asm_out_file, main_input_filename,
1847                                        getdecls ()));
1848 #endif
1849 #ifdef DWARF_DEBUGGING_INFO
1850   if (write_symbols == DWARF_DEBUG)
1851     TIMEVAR (symout_time, dwarfout_init (asm_out_file, main_input_filename));
1852 #endif
1853
1854   /* Initialize yet another pass.  */
1855
1856   init_final (main_input_filename);
1857
1858   start_time = get_run_time ();
1859
1860   /* Call the parser, which parses the entire file
1861      (calling rest_of_compilation for each function).  */
1862
1863   if (yyparse () != 0)
1864     if (errorcount == 0)
1865       fprintf (stderr, "Errors detected in input file (your bison.simple is out of date)");
1866
1867   /* Compilation is now finished except for writing
1868      what's left of the symbol table output.  */
1869
1870   parse_time += get_run_time () - start_time;
1871
1872   parse_time -= integration_time;
1873   parse_time -= varconst_time;
1874
1875   globals = getdecls ();
1876
1877   /* Really define vars that have had only a tentative definition.
1878      Really output inline functions that must actually be callable
1879      and have not been output so far.  */
1880
1881   {
1882     int len = list_length (globals);
1883     tree *vec = (tree *) alloca (sizeof (tree) * len);
1884     int i;
1885     tree decl;
1886
1887     /* Process the decls in reverse order--earliest first.
1888        Put them into VEC from back to front, then take out from front.  */
1889
1890     for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1891       vec[len - i - 1] = decl;
1892
1893     for (i = 0; i < len; i++)
1894       {
1895         decl = vec[i];
1896         if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0
1897             && incomplete_decl_finalize_hook != 0)
1898           (*incomplete_decl_finalize_hook) (decl);
1899
1900         if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
1901             && ! TREE_ASM_WRITTEN (decl))
1902           {
1903             /* Don't write out static consts, unless we used them.
1904                (This used to write them out only if the address was
1905                taken, but that was wrong; if the variable was simply
1906                referred to, it still needs to exist or else it will
1907                be undefined in the linker.)  */
1908             if (! TREE_READONLY (decl)
1909                 || TREE_PUBLIC (decl)
1910                 || TREE_USED (decl)
1911                 || TREE_ADDRESSABLE (decl)
1912                 || TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl)))
1913               rest_of_decl_compilation (decl, NULL_PTR, 1, 1);
1914             else
1915               /* Cancel the RTL for this decl so that, if debugging info
1916                  output for global variables is still to come,
1917                  this one will be omitted.  */
1918               DECL_RTL (decl) = NULL;
1919           }
1920
1921         if (TREE_CODE (decl) == FUNCTION_DECL
1922             && ! TREE_ASM_WRITTEN (decl)
1923             && DECL_INITIAL (decl) != 0
1924             && (TREE_ADDRESSABLE (decl)
1925                 || TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl)))
1926             && ! DECL_EXTERNAL (decl))
1927           output_inline_function (decl);
1928
1929         /* Warn about any function
1930            declared static but not defined.
1931            We don't warn about variables,
1932            because many programs have static variables
1933            that exist only to get some text into the object file.  */
1934         if ((warn_unused
1935              || TREE_USED (decl)
1936              || (DECL_NAME (decl) && TREE_USED (DECL_NAME (decl))))
1937             && TREE_CODE (decl) == FUNCTION_DECL
1938             && DECL_INITIAL (decl) == 0
1939             && DECL_EXTERNAL (decl)
1940             && ! TREE_PUBLIC (decl))
1941           {
1942             /* This should be a pedwarn, except that there is
1943                no easy way to prevent it from happening when the
1944                name is used only inside a sizeof.
1945                This at least avoids being incorrect.  */
1946             warning_with_decl (decl,
1947                                "`%s' declared `static' but never defined");
1948             /* This symbol is effectively an "extern" declaration now.  */
1949             TREE_PUBLIC (decl) = 1;
1950             assemble_external (decl);
1951
1952           }
1953         /* Warn about static fns or vars defined but not used,
1954            but not about inline functions
1955            since unused inline statics is normal practice.  */
1956         if (warn_unused
1957             && (TREE_CODE (decl) == FUNCTION_DECL
1958                 || TREE_CODE (decl) == VAR_DECL)
1959             && ! DECL_IN_SYSTEM_HEADER (decl)
1960             && ! DECL_EXTERNAL (decl)
1961             && ! TREE_PUBLIC (decl)
1962             && ! TREE_USED (decl)
1963             && ! DECL_INLINE (decl)
1964             && ! DECL_REGISTER (decl)
1965             /* The TREE_USED bit for file-scope decls
1966                is kept in the identifier, to handle multiple
1967                external decls in different scopes.  */
1968             && ! TREE_USED (DECL_NAME (decl)))
1969           warning_with_decl (decl, "`%s' defined but not used");
1970
1971 #ifdef SDB_DEBUGGING_INFO
1972         /* The COFF linker can move initialized global vars to the end.
1973            And that can screw up the symbol ordering.
1974            By putting the symbols in that order to begin with,
1975            we avoid a problem.  mcsun!unido!fauern!tumuc!pes@uunet.uu.net.  */
1976         if (write_symbols == SDB_DEBUG && TREE_CODE (decl) == VAR_DECL
1977             && TREE_PUBLIC (decl) && DECL_INITIAL (decl)
1978             && DECL_RTL (decl) != 0)
1979           TIMEVAR (symout_time, sdbout_symbol (decl, 0));
1980
1981         /* Output COFF information for non-global
1982            file-scope initialized variables. */
1983         if (write_symbols == SDB_DEBUG
1984             && TREE_CODE (decl) == VAR_DECL
1985             && DECL_INITIAL (decl)
1986             && DECL_RTL (decl) != 0
1987             && GET_CODE (DECL_RTL (decl)) == MEM)
1988           TIMEVAR (symout_time, sdbout_toplevel_data (decl));
1989 #endif /* SDB_DEBUGGING_INFO */
1990 #ifdef DWARF_DEBUGGING_INFO
1991         /* Output DWARF information for file-scope tentative data object
1992            declarations, file-scope (extern) function declarations (which
1993            had no corresponding body) and file-scope tagged type declarations
1994            and definitions which have not yet been forced out.  */
1995
1996         if (write_symbols == DWARF_DEBUG
1997             && (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl)))
1998           TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 1));
1999 #endif
2000       }
2001   }
2002
2003   /* Do dbx symbols */
2004 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2005   if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2006     TIMEVAR (symout_time,
2007              {
2008                dbxout_finish (asm_out_file, main_input_filename);
2009              });
2010 #endif
2011
2012 #ifdef DWARF_DEBUGGING_INFO
2013   if (write_symbols == DWARF_DEBUG)
2014     TIMEVAR (symout_time,
2015              {
2016                dwarfout_finish ();
2017              });
2018 #endif
2019
2020   /* Output some stuff at end of file if nec.  */
2021
2022   end_final (main_input_filename);
2023
2024 #ifdef ASM_FILE_END
2025   ASM_FILE_END (asm_out_file);
2026 #endif
2027
2028  after_finish_compilation:
2029
2030   /* Language-specific end of compilation actions.  */
2031
2032   lang_finish ();
2033
2034   /* Close the dump files.  */
2035
2036   if (flag_gen_aux_info)
2037     {
2038       fclose (aux_info_file);
2039       if (errorcount)
2040         unlink (aux_info_file_name);
2041     }
2042
2043   if (rtl_dump)
2044     fclose (rtl_dump_file);
2045
2046   if (jump_opt_dump)
2047     fclose (jump_opt_dump_file);
2048
2049   if (cse_dump)
2050     fclose (cse_dump_file);
2051
2052   if (loop_dump)
2053     fclose (loop_dump_file);
2054
2055   if (cse2_dump)
2056     fclose (cse2_dump_file);
2057
2058   if (flow_dump)
2059     fclose (flow_dump_file);
2060
2061   if (combine_dump)
2062     {
2063       dump_combine_total_stats (combine_dump_file);
2064       fclose (combine_dump_file);
2065     }
2066
2067   if (sched_dump)
2068     fclose (sched_dump_file);
2069
2070   if (local_reg_dump)
2071     fclose (local_reg_dump_file);
2072
2073   if (global_reg_dump)
2074     fclose (global_reg_dump_file);
2075
2076   if (sched2_dump)
2077     fclose (sched2_dump_file);
2078
2079   if (jump2_opt_dump)
2080     fclose (jump2_opt_dump_file);
2081
2082   if (dbr_sched_dump)
2083     fclose (dbr_sched_dump_file);
2084
2085 #ifdef STACK_REGS
2086   if (stack_reg_dump)
2087     fclose (stack_reg_dump_file);
2088 #endif
2089
2090   /* Close non-debugging input and output files.  Take special care to note
2091      whether fclose returns an error, since the pages might still be on the
2092      buffer chain while the file is open.  */
2093
2094   fclose (finput);
2095   if (ferror (asm_out_file) != 0 || fclose (asm_out_file) != 0)
2096     fatal_io_error (asm_file_name);
2097
2098   /* Print the times.  */
2099
2100   if (! quiet_flag)
2101     {
2102       fprintf (stderr,"\n");
2103       print_time ("parse", parse_time);
2104       print_time ("integration", integration_time);
2105       print_time ("jump", jump_time);
2106       print_time ("cse", cse_time);
2107       print_time ("loop", loop_time);
2108       print_time ("cse2", cse2_time);
2109       print_time ("flow", flow_time);
2110       print_time ("combine", combine_time);
2111       print_time ("sched", sched_time);
2112       print_time ("local-alloc", local_alloc_time);
2113       print_time ("global-alloc", global_alloc_time);
2114       print_time ("sched2", sched2_time);
2115       print_time ("dbranch", dbr_sched_time);
2116       print_time ("shorten-branch", shorten_branch_time);
2117       print_time ("stack-reg", stack_reg_time);
2118       print_time ("final", final_time);
2119       print_time ("varconst", varconst_time);
2120       print_time ("symout", symout_time);
2121       print_time ("dump", dump_time);
2122     }
2123 }
2124 \f
2125 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
2126    and TYPE_DECL nodes.
2127
2128    This does nothing for local (non-static) variables.
2129    Otherwise, it sets up the RTL and outputs any assembler code
2130    (label definition, storage allocation and initialization).
2131
2132    DECL is the declaration.  If ASMSPEC is nonzero, it specifies
2133    the assembler symbol name to be used.  TOP_LEVEL is nonzero
2134    if this declaration is not within a function.  */
2135
2136 void
2137 rest_of_decl_compilation (decl, asmspec, top_level, at_end)
2138      tree decl;
2139      char *asmspec;
2140      int top_level;
2141      int at_end;
2142 {
2143   /* Declarations of variables, and of functions defined elsewhere.  */
2144
2145   /* Forward declarations for nested functions are not "external",
2146      but we need to treat them as if they were.  */
2147   if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
2148       || TREE_CODE (decl) == FUNCTION_DECL)
2149     TIMEVAR (varconst_time,
2150              {
2151                make_decl_rtl (decl, asmspec, top_level);
2152                /* For a user-invisible decl that should be replaced
2153                   by its value when used, don't output anything.  */
2154                if (! (TREE_CODE (decl) == VAR_DECL
2155                       && DECL_IGNORED_P (decl) && TREE_READONLY (decl)
2156                       && DECL_INITIAL (decl) != 0))
2157                  /* Don't output anything
2158                     when a tentative file-scope definition is seen.
2159                     But at end of compilation, do output code for them.  */
2160                  if (! (! at_end && top_level
2161                         && (DECL_INITIAL (decl) == 0
2162                             || DECL_INITIAL (decl) == error_mark_node
2163                             || DECL_IGNORED_P (decl))))
2164                    assemble_variable (decl, top_level, at_end);
2165              });
2166   else if (DECL_REGISTER (decl) && asmspec != 0)
2167     {
2168       if (decode_reg_name (asmspec) >= 0)
2169         {
2170           DECL_RTL (decl) = 0;
2171           make_decl_rtl (decl, asmspec, top_level);
2172         }
2173       else
2174         error ("invalid register name `%s' for register variable", asmspec);
2175     }
2176 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2177   else if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2178            && TREE_CODE (decl) == TYPE_DECL)
2179     TIMEVAR (symout_time, dbxout_symbol (decl, 0));
2180 #endif
2181 #ifdef SDB_DEBUGGING_INFO
2182   else if (write_symbols == SDB_DEBUG && top_level
2183            && TREE_CODE (decl) == TYPE_DECL)
2184     TIMEVAR (symout_time, sdbout_symbol (decl, 0));
2185 #endif
2186 }
2187
2188 /* Called after finishing a record, union or enumeral type.  */
2189
2190 void
2191 rest_of_type_compilation (type, toplev)
2192      tree type;
2193      int toplev;
2194 {
2195 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2196   if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2197     TIMEVAR (symout_time, dbxout_symbol (TYPE_STUB_DECL (type), !toplev));
2198 #endif
2199 #ifdef SDB_DEBUGGING_INFO
2200   if (write_symbols == SDB_DEBUG)
2201     TIMEVAR (symout_time, sdbout_symbol (TYPE_STUB_DECL (type), !toplev));
2202 #endif
2203 }
2204
2205 /* This is called from finish_function (within yyparse)
2206    after each top-level definition is parsed.
2207    It is supposed to compile that function or variable
2208    and output the assembler code for it.
2209    After we return, the tree storage is freed.  */
2210
2211 void
2212 rest_of_compilation (decl)
2213      tree decl;
2214 {
2215   register rtx insns;
2216   int start_time = get_run_time ();
2217   int tem;
2218   /* Nonzero if we have saved the original DECL_INITIAL of the function,
2219      to be restored after we finish compiling the function
2220      (for use when compiling inline calls to this function).  */
2221   tree saved_block_tree = 0;
2222   /* Likewise, for DECL_ARGUMENTS.  */
2223   tree saved_arguments = 0;
2224   int failure = 0;
2225
2226   /* If we are reconsidering an inline function
2227      at the end of compilation, skip the stuff for making it inline.  */
2228
2229   if (DECL_SAVED_INSNS (decl) == 0)
2230     {
2231       int specd = DECL_INLINE (decl);
2232       char *lose;
2233
2234       /* If requested, consider whether to make this function inline.  */
2235       if (specd || flag_inline_functions)
2236         TIMEVAR (integration_time,
2237                  {
2238                    lose = function_cannot_inline_p (decl);
2239                    if (lose)
2240                      {
2241                        if (warn_inline && specd)
2242                          warning_with_decl (decl, lose);
2243                        DECL_INLINE (decl) = 0;
2244                      }
2245                    else
2246                      DECL_INLINE (decl) = 1;
2247                  });
2248
2249       insns = get_insns ();
2250
2251       /* Dump the rtl code if we are dumping rtl.  */
2252
2253       if (rtl_dump)
2254         TIMEVAR (dump_time,
2255                  {
2256                    fprintf (rtl_dump_file, "\n;; Function %s\n\n",
2257                             IDENTIFIER_POINTER (DECL_NAME (decl)));
2258                    if (DECL_SAVED_INSNS (decl))
2259                      fprintf (rtl_dump_file, ";; (integrable)\n\n");
2260                    print_rtl (rtl_dump_file, insns);
2261                    fflush (rtl_dump_file);
2262                  });
2263
2264       /* If function is inline, and we don't yet know whether to
2265          compile it by itself, defer decision till end of compilation.
2266          finish_compilation will call rest_of_compilation again
2267          for those functions that need to be output.  */
2268
2269       if (DECL_INLINE (decl)
2270           && ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
2271                && ! flag_keep_inline_functions)
2272               || DECL_EXTERNAL (decl)))
2273         {
2274 #ifdef DWARF_DEBUGGING_INFO
2275           /* Generate the DWARF info for the "abstract" instance
2276              of a function which we may later generate inlined and/or
2277              out-of-line instances of.  */
2278           if (write_symbols == DWARF_DEBUG)
2279             {
2280               set_decl_abstract_flags (decl, 1);
2281               TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 0));
2282               set_decl_abstract_flags (decl, 0);
2283             }
2284 #endif
2285           TIMEVAR (integration_time, save_for_inline_nocopy (decl));
2286           goto exit_rest_of_compilation;
2287         }
2288
2289       /* If we have to compile the function now, save its rtl and subdecls
2290          so that its compilation will not affect what others get.  */
2291       if (DECL_INLINE (decl))
2292         {
2293 #ifdef DWARF_DEBUGGING_INFO
2294           /* Generate the DWARF info for the "abstract" instance of
2295              a function which we will generate an out-of-line instance
2296              of almost immediately (and which we may also later generate
2297              various inlined instances of).  */
2298           if (write_symbols == DWARF_DEBUG)
2299             {
2300               set_decl_abstract_flags (decl, 1);
2301               TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 0));
2302               set_decl_abstract_flags (decl, 0);
2303             }
2304 #endif
2305           saved_block_tree = DECL_INITIAL (decl);
2306           saved_arguments = DECL_ARGUMENTS (decl);
2307           TIMEVAR (integration_time, save_for_inline_copying (decl));
2308         }
2309     }
2310
2311   TREE_ASM_WRITTEN (decl) = 1;
2312
2313   /* Now that integrate will no longer see our rtl, we need not distinguish
2314      between the return value of this function and the return value of called
2315      functions.  */
2316   rtx_equal_function_value_matters = 0;
2317
2318   /* Don't return yet if -Wreturn-type; we need to do jump_optimize.  */
2319   if ((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type)
2320     {
2321       goto exit_rest_of_compilation;
2322     }
2323
2324   /* From now on, allocate rtl in current_obstack, not in saveable_obstack.
2325      Note that that may have been done above, in save_for_inline_copying.
2326      The call to resume_temporary_allocation near the end of this function
2327      goes back to the usual state of affairs.  */
2328
2329   rtl_in_current_obstack ();
2330
2331 #ifdef FINALIZE_PIC
2332   /* If we are doing position-independent code generation, now
2333      is the time to output special prologues and epilogues.
2334      We do not want to do this earlier, because it just clutters
2335      up inline functions with meaningless insns.  */
2336   if (flag_pic)
2337     FINALIZE_PIC;
2338 #endif
2339
2340   insns = get_insns ();
2341
2342   /* Copy any shared structure that should not be shared.  */
2343
2344   unshare_all_rtl (insns);
2345
2346   /* Instantiate all virtual registers.  */
2347
2348   instantiate_virtual_regs (current_function_decl, get_insns ());
2349
2350   /* See if we have allocated stack slots that are not directly addressable.
2351      If so, scan all the insns and create explicit address computation
2352      for all references to such slots.  */
2353 /*   fixup_stack_slots (); */
2354
2355   /* Do jump optimization the first time, if -opt.
2356      Also do it if -W, but in that case it doesn't change the rtl code,
2357      it only computes whether control can drop off the end of the function.  */
2358
2359   if (optimize > 0 || extra_warnings || warn_return_type
2360       /* If function is `volatile', we should warn if it tries to return.  */
2361       || TREE_THIS_VOLATILE (decl))
2362     {
2363       TIMEVAR (jump_time, reg_scan (insns, max_reg_num (), 0));
2364       TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 1));
2365     }
2366
2367   /* Now is when we stop if -fsyntax-only and -Wreturn-type.  */
2368   if (rtl_dump_and_exit || flag_syntax_only)
2369     goto exit_rest_of_compilation;
2370
2371   /* Dump rtl code after jump, if we are doing that.  */
2372
2373   if (jump_opt_dump)
2374     TIMEVAR (dump_time,
2375              {
2376                fprintf (jump_opt_dump_file, "\n;; Function %s\n\n",
2377                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2378                print_rtl (jump_opt_dump_file, insns);
2379                fflush (jump_opt_dump_file);
2380              });
2381
2382   /* Perform common subexpression elimination.
2383      Nonzero value from `cse_main' means that jumps were simplified
2384      and some code may now be unreachable, so do
2385      jump optimization again.  */
2386
2387   if (cse_dump)
2388     TIMEVAR (dump_time,
2389              {
2390                fprintf (cse_dump_file, "\n;; Function %s\n\n",
2391                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2392              });
2393
2394   if (optimize > 0)
2395     {
2396       TIMEVAR (cse_time, reg_scan (insns, max_reg_num (), 1));
2397
2398       if (flag_thread_jumps)
2399         /* Hacks by tiemann & kenner.  */
2400         TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 0));
2401
2402       TIMEVAR (cse_time, tem = cse_main (insns, max_reg_num (),
2403                                          0, cse_dump_file));
2404       TIMEVAR (cse_time, delete_dead_from_cse (insns, max_reg_num ()));
2405
2406       if (tem)
2407         TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 0));
2408     }
2409
2410   /* Dump rtl code after cse, if we are doing that.  */
2411
2412   if (cse_dump)
2413     TIMEVAR (dump_time,
2414              {
2415                print_rtl (cse_dump_file, insns);
2416                fflush (cse_dump_file);
2417              });
2418
2419   if (loop_dump)
2420     TIMEVAR (dump_time,
2421              {
2422                fprintf (loop_dump_file, "\n;; Function %s\n\n",
2423                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2424              });
2425
2426   /* Move constant computations out of loops.  */
2427
2428   if (optimize > 0)
2429     {
2430       TIMEVAR (loop_time,
2431                {
2432                  loop_optimize (insns, loop_dump_file);
2433                });
2434     }
2435
2436   /* Dump rtl code after loop opt, if we are doing that.  */
2437
2438   if (loop_dump)
2439     TIMEVAR (dump_time,
2440              {
2441                print_rtl (loop_dump_file, insns);
2442                fflush (loop_dump_file);
2443              });
2444
2445   if (cse2_dump)
2446     TIMEVAR (dump_time,
2447              {
2448                fprintf (cse2_dump_file, "\n;; Function %s\n\n",
2449                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2450              });
2451
2452   if (optimize > 0 && flag_rerun_cse_after_loop)
2453     {
2454       TIMEVAR (cse2_time, reg_scan (insns, max_reg_num (), 0));
2455
2456       TIMEVAR (cse2_time, tem = cse_main (insns, max_reg_num (),
2457                                           1, cse2_dump_file));
2458       if (tem)
2459         TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 0));
2460     }
2461
2462   if (optimize > 0 && flag_thread_jumps)
2463     /* This pass of jump threading straightens out code
2464        that was kinked by loop optimization.  */
2465     TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 0));
2466
2467   /* Dump rtl code after cse, if we are doing that.  */
2468
2469   if (cse2_dump)
2470     TIMEVAR (dump_time,
2471              {
2472                print_rtl (cse2_dump_file, insns);
2473                fflush (cse2_dump_file);
2474              });
2475
2476   /* We are no longer anticipating cse in this function, at least.  */
2477
2478   cse_not_expected = 1;
2479
2480   /* Now we choose between stupid (pcc-like) register allocation
2481      (if we got the -noreg switch and not -opt)
2482      and smart register allocation.  */
2483
2484   if (optimize > 0)                     /* Stupid allocation probably won't work */
2485     obey_regdecls = 0;          /* if optimizations being done.  */
2486
2487   regclass_init ();
2488
2489   /* Print function header into flow dump now
2490      because doing the flow analysis makes some of the dump.  */
2491
2492   if (flow_dump)
2493     TIMEVAR (dump_time,
2494              {
2495                fprintf (flow_dump_file, "\n;; Function %s\n\n",
2496                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2497              });
2498
2499   if (obey_regdecls)
2500     {
2501       TIMEVAR (flow_time,
2502                {
2503                  regclass (insns, max_reg_num ());
2504                  stupid_life_analysis (insns, max_reg_num (),
2505                                        flow_dump_file);
2506                });
2507     }
2508   else
2509     {
2510       /* Do control and data flow analysis,
2511          and write some of the results to dump file.  */
2512
2513       TIMEVAR (flow_time, flow_analysis (insns, max_reg_num (),
2514                                          flow_dump_file));
2515       if (warn_uninitialized)
2516         {
2517           uninitialized_vars_warning (DECL_INITIAL (decl));
2518           setjmp_args_warning ();
2519         }
2520     }
2521
2522   /* Dump rtl after flow analysis.  */
2523
2524   if (flow_dump)
2525     TIMEVAR (dump_time,
2526              {
2527                print_rtl (flow_dump_file, insns);
2528                fflush (flow_dump_file);
2529              });
2530
2531   /* If -opt, try combining insns through substitution.  */
2532
2533   if (optimize > 0)
2534     TIMEVAR (combine_time, combine_instructions (insns, max_reg_num ()));
2535
2536   /* Dump rtl code after insn combination.  */
2537
2538   if (combine_dump)
2539     TIMEVAR (dump_time,
2540              {
2541                fprintf (combine_dump_file, "\n;; Function %s\n\n",
2542                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2543                dump_combine_stats (combine_dump_file);
2544                print_rtl (combine_dump_file, insns);
2545                fflush (combine_dump_file);
2546              });
2547
2548   /* Print function header into sched dump now
2549      because doing the sched analysis makes some of the dump.  */
2550
2551   if (sched_dump)
2552     TIMEVAR (dump_time,
2553              {
2554                fprintf (sched_dump_file, "\n;; Function %s\n\n",
2555                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2556              });
2557
2558   if (optimize > 0 && flag_schedule_insns)
2559     {
2560       /* Do control and data sched analysis,
2561          and write some of the results to dump file.  */
2562
2563       TIMEVAR (sched_time, schedule_insns (sched_dump_file));
2564     }
2565
2566   /* Dump rtl after instruction scheduling.  */
2567
2568   if (sched_dump)
2569     TIMEVAR (dump_time,
2570              {
2571                print_rtl (sched_dump_file, insns);
2572                fflush (sched_dump_file);
2573              });
2574
2575   /* Unless we did stupid register allocation,
2576      allocate pseudo-regs that are used only within 1 basic block.  */
2577
2578   if (!obey_regdecls)
2579     TIMEVAR (local_alloc_time,
2580              {
2581                regclass (insns, max_reg_num ());
2582                local_alloc ();
2583              });
2584
2585   /* Dump rtl code after allocating regs within basic blocks.  */
2586
2587   if (local_reg_dump)
2588     TIMEVAR (dump_time,
2589              {
2590                fprintf (local_reg_dump_file, "\n;; Function %s\n\n",
2591                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2592                dump_flow_info (local_reg_dump_file);
2593                dump_local_alloc (local_reg_dump_file);
2594                print_rtl (local_reg_dump_file, insns);
2595                fflush (local_reg_dump_file);
2596              });
2597
2598   if (global_reg_dump)
2599     TIMEVAR (dump_time,
2600              fprintf (global_reg_dump_file, "\n;; Function %s\n\n",
2601                       IDENTIFIER_POINTER (DECL_NAME (decl))));
2602
2603   /* Unless we did stupid register allocation,
2604      allocate remaining pseudo-regs, then do the reload pass
2605      fixing up any insns that are invalid.  */
2606
2607   TIMEVAR (global_alloc_time,
2608            {
2609              if (!obey_regdecls)
2610                failure = global_alloc (global_reg_dump_file);
2611              else
2612                failure = reload (insns, 0, global_reg_dump_file);
2613            });
2614
2615   if (global_reg_dump)
2616     TIMEVAR (dump_time,
2617              {
2618                dump_global_regs (global_reg_dump_file);
2619                print_rtl (global_reg_dump_file, insns);
2620                fflush (global_reg_dump_file);
2621              });
2622
2623   if (failure)
2624     goto exit_rest_of_compilation;
2625
2626   reload_completed = 1;
2627
2628   /* On some machines, the prologue and epilogue code, or parts thereof,
2629      can be represented as RTL.  Doing so lets us schedule insns between
2630      it and the rest of the code and also allows delayed branch
2631      scheduling to operate in the epilogue.  */
2632
2633   thread_prologue_and_epilogue_insns (insns);
2634
2635   if (optimize > 0 && flag_schedule_insns_after_reload)
2636     {
2637       if (sched2_dump)
2638         TIMEVAR (dump_time,
2639                  {
2640                    fprintf (sched2_dump_file, "\n;; Function %s\n\n",
2641                             IDENTIFIER_POINTER (DECL_NAME (decl)));
2642                  });
2643
2644       /* Do control and data sched analysis again,
2645          and write some more of the results to dump file.  */
2646
2647       TIMEVAR (sched2_time, schedule_insns (sched2_dump_file));
2648
2649       /* Dump rtl after post-reorder instruction scheduling.  */
2650
2651       if (sched2_dump)
2652         TIMEVAR (dump_time,
2653                  {
2654                    print_rtl (sched2_dump_file, insns);
2655                    fflush (sched2_dump_file);
2656                  });
2657     }
2658
2659 #ifdef LEAF_REGISTERS
2660   leaf_function = 0;
2661   if (optimize > 0 && only_leaf_regs_used () && leaf_function_p ())
2662     leaf_function = 1;
2663 #endif
2664
2665   /* One more attempt to remove jumps to .+1
2666      left by dead-store-elimination.
2667      Also do cross-jumping this time
2668      and delete no-op move insns.  */
2669
2670   if (optimize > 0)
2671     {
2672       TIMEVAR (jump_time, jump_optimize (insns, 1, 1, 0));
2673     }
2674
2675   /* Dump rtl code after jump, if we are doing that.  */
2676
2677   if (jump2_opt_dump)
2678     TIMEVAR (dump_time,
2679              {
2680                fprintf (jump2_opt_dump_file, "\n;; Function %s\n\n",
2681                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2682                print_rtl (jump2_opt_dump_file, insns);
2683                fflush (jump2_opt_dump_file);
2684              });
2685
2686   /* If a scheduling pass for delayed branches is to be done,
2687      call the scheduling code. */
2688
2689 #ifdef DELAY_SLOTS
2690   if (optimize > 0 && flag_delayed_branch)
2691     {
2692       TIMEVAR (dbr_sched_time, dbr_schedule (insns, dbr_sched_dump_file));
2693       if (dbr_sched_dump)
2694         {
2695           TIMEVAR (dump_time,
2696                  {
2697                    fprintf (dbr_sched_dump_file, "\n;; Function %s\n\n",
2698                             IDENTIFIER_POINTER (DECL_NAME (decl)));
2699                    print_rtl (dbr_sched_dump_file, insns);
2700                    fflush (dbr_sched_dump_file);
2701                  });
2702         }
2703     }
2704 #endif
2705
2706   if (optimize > 0)
2707     /* Shorten branches.  */
2708     TIMEVAR (shorten_branch_time,
2709              {
2710                shorten_branches (get_insns ());
2711              });
2712
2713 #ifdef STACK_REGS
2714   TIMEVAR (stack_reg_time, reg_to_stack (insns, stack_reg_dump_file));
2715   if (stack_reg_dump)
2716     {
2717       TIMEVAR (dump_time,
2718                {
2719                  fprintf (stack_reg_dump_file, "\n;; Function %s\n\n",
2720                           IDENTIFIER_POINTER (DECL_NAME (decl)));
2721                  print_rtl (stack_reg_dump_file, insns);
2722                  fflush (stack_reg_dump_file);
2723                });
2724     }
2725 #endif
2726
2727   /* Now turn the rtl into assembler code.  */
2728
2729   TIMEVAR (final_time,
2730            {
2731              rtx x;
2732              char *fnname;
2733
2734              /* Get the function's name, as described by its RTL.
2735                 This may be different from the DECL_NAME name used
2736                 in the source file.  */
2737
2738              x = DECL_RTL (decl);
2739              if (GET_CODE (x) != MEM)
2740                abort ();
2741              x = XEXP (x, 0);
2742              if (GET_CODE (x) != SYMBOL_REF)
2743                abort ();
2744              fnname = XSTR (x, 0);
2745
2746              assemble_start_function (decl, fnname);
2747              final_start_function (insns, asm_out_file, optimize);
2748              final (insns, asm_out_file, optimize, 0);
2749              final_end_function (insns, asm_out_file, optimize);
2750              assemble_end_function (decl, fnname);
2751              fflush (asm_out_file);
2752            });
2753
2754   /* Write DBX symbols if requested */
2755
2756   /* Note that for those inline functions where we don't initially
2757      know for certain that we will be generating an out-of-line copy,
2758      the first invocation of this routine (rest_of_compilation) will
2759      skip over this code by doing a `goto exit_rest_of_compilation;'.
2760      Later on, finish_compilation will call rest_of_compilation again
2761      for those inline functions that need to have out-of-line copies
2762      generated.  During that call, we *will* be routed past here.  */
2763
2764 #ifdef DBX_DEBUGGING_INFO
2765   if (write_symbols == DBX_DEBUG)
2766     TIMEVAR (symout_time, dbxout_function (decl));
2767 #endif
2768
2769 #ifdef DWARF_DEBUGGING_INFO
2770   if (write_symbols == DWARF_DEBUG)
2771     TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 0));
2772 #endif
2773
2774  exit_rest_of_compilation:
2775
2776   /* In case the function was not output,
2777      don't leave any temporary anonymous types
2778      queued up for sdb output.  */
2779 #ifdef SDB_DEBUGGING_INFO
2780   if (write_symbols == SDB_DEBUG)
2781     sdbout_types (NULL_TREE);
2782 #endif
2783
2784   /* Put back the tree of subblocks and list of arguments
2785      from before we copied them.
2786      Code generation and the output of debugging info may have modified
2787      the copy, but the original is unchanged.  */
2788
2789   if (saved_block_tree != 0)
2790     DECL_INITIAL (decl) = saved_block_tree;
2791   if (saved_arguments != 0)
2792     DECL_ARGUMENTS (decl) = saved_arguments;
2793
2794   reload_completed = 0;
2795
2796   /* Clear out the real_constant_chain before some of the rtx's
2797      it runs through become garbage.  */
2798
2799   clear_const_double_mem ();
2800
2801   /* Cancel the effect of rtl_in_current_obstack.  */
2802
2803   resume_temporary_allocation ();
2804
2805   /* The parsing time is all the time spent in yyparse
2806      *except* what is spent in this function.  */
2807
2808   parse_time -= get_run_time () - start_time;
2809 }
2810 \f
2811 /* Entry point of cc1/c++.  Decode command args, then call compile_file.
2812    Exit code is 35 if can't open files, 34 if fatal error,
2813    33 if had nonfatal errors, else success.  */
2814
2815 int
2816 main (argc, argv, envp)
2817      int argc;
2818      char **argv;
2819      char **envp;
2820 {
2821   register int i;
2822   char *filename = 0;
2823   int flag_print_mem = 0;
2824   int version_flag = 0;
2825   char *p;
2826
2827   /* save in case md file wants to emit args as a comment.  */
2828   save_argc = argc;
2829   save_argv = argv;
2830
2831   p = argv[0] + strlen (argv[0]);
2832   while (p != argv[0] && p[-1] != '/') --p;
2833   progname = p;
2834
2835 #ifdef RLIMIT_STACK
2836   /* Get rid of any avoidable limit on stack size.  */
2837   {
2838     struct rlimit rlim;
2839
2840     /* Set the stack limit huge so that alloca does not fail. */
2841     getrlimit (RLIMIT_STACK, &rlim);
2842     rlim.rlim_cur = rlim.rlim_max;
2843     setrlimit (RLIMIT_STACK, &rlim);
2844   }
2845 #endif /* RLIMIT_STACK */
2846
2847   signal (SIGFPE, float_signal);
2848
2849 #ifdef SIGPIPE
2850   signal (SIGPIPE, pipe_closed);
2851 #endif
2852
2853   decl_printable_name = decl_name;
2854   lang_expand_expr = (struct rtx_def *(*)()) do_abort;
2855
2856   /* Initialize whether `char' is signed.  */
2857   flag_signed_char = DEFAULT_SIGNED_CHAR;
2858 #ifdef DEFAULT_SHORT_ENUMS
2859   /* Initialize how much space enums occupy, by default.  */
2860   flag_short_enums = DEFAULT_SHORT_ENUMS;
2861 #endif
2862
2863   /* Scan to see what optimization level has been specified.  That will
2864      determine the default value of many flags.  */
2865   for (i = 1; i < argc; i++)
2866     {
2867       if (!strcmp (argv[i], "-O"))
2868         {
2869           optimize = 1;
2870         }
2871       else if (argv[i][0] == '-' && argv[i][1] == 'O')
2872         {
2873           /* Handle -O2, -O3, -O69, ...  */
2874           char *p = &argv[i][2];
2875           int c;
2876
2877           while (c = *p++)
2878             if (! (c >= '0' && c <= '9'))
2879               break;
2880           if (c == 0)
2881             optimize = atoi (&argv[i][2]);
2882         }
2883     }
2884
2885   obey_regdecls = (optimize == 0);
2886   if (optimize == 0)
2887     {
2888       flag_no_inline = 1;
2889       warn_inline = 0;
2890     }
2891
2892   if (optimize >= 1)
2893     {
2894       flag_defer_pop = 1;
2895       flag_thread_jumps = 1;
2896 #ifdef DELAY_SLOTS
2897       flag_delayed_branch = 1;
2898 #endif
2899     }
2900
2901   if (optimize >= 2)
2902     {
2903       flag_cse_follow_jumps = 1;
2904       flag_cse_skip_blocks = 1;
2905       flag_expensive_optimizations = 1;
2906       flag_strength_reduce = 1;
2907       flag_rerun_cse_after_loop = 1;
2908       flag_caller_saves = 1;
2909 #ifdef INSN_SCHEDULING
2910       flag_schedule_insns = 1;
2911       flag_schedule_insns_after_reload = 1;
2912 #endif
2913     }
2914
2915 #ifdef OPTIMIZATION_OPTIONS
2916   /* Allow default optimizations to be specified on a per-machine basis.  */
2917   OPTIMIZATION_OPTIONS (optimize);
2918 #endif
2919
2920   /* Initialize register usage now so switches may override.  */
2921   init_reg_sets ();
2922
2923   target_flags = 0;
2924   set_target_switch ("");
2925
2926   for (i = 1; i < argc; i++)
2927     {
2928       int j;
2929       /* If this is a language-specific option,
2930          decode it in a language-specific way.  */
2931       for (j = 0; lang_options[j] != 0; j++)
2932         if (!strncmp (argv[i], lang_options[j],
2933                       strlen (lang_options[j])))
2934           break;
2935       if (lang_options[j] != 0)
2936         /* If the option is valid for *some* language,
2937            treat it as valid even if this language doesn't understand it.  */
2938         lang_decode_option (argv[i]);
2939       else if (argv[i][0] == '-' && argv[i][1] != 0)
2940         {
2941           register char *str = argv[i] + 1;
2942           if (str[0] == 'Y')
2943             str++;
2944
2945           if (str[0] == 'm')
2946             set_target_switch (&str[1]);
2947           else if (!strcmp (str, "dumpbase"))
2948             {
2949               dump_base_name = argv[++i];
2950             }
2951           else if (str[0] == 'd')
2952             {
2953               register char *p = &str[1];
2954               while (*p)
2955                 switch (*p++)
2956                   {
2957                   case 'a':
2958                     combine_dump = 1;
2959                     dbr_sched_dump = 1;
2960                     flow_dump = 1;
2961                     global_reg_dump = 1;
2962                     jump_opt_dump = 1;
2963                     jump2_opt_dump = 1;
2964                     local_reg_dump = 1;
2965                     loop_dump = 1;
2966                     rtl_dump = 1;
2967                     cse_dump = 1, cse2_dump = 1;
2968                     sched_dump = 1;
2969                     sched2_dump = 1;
2970                     stack_reg_dump = 1;
2971                     break;
2972                   case 'k':
2973                     stack_reg_dump = 1;
2974                     break;
2975                   case 'c':
2976                     combine_dump = 1;
2977                     break;
2978                   case 'd':
2979                     dbr_sched_dump = 1;
2980                     break;
2981                   case 'f':
2982                     flow_dump = 1;
2983                     break;
2984                   case 'g':
2985                     global_reg_dump = 1;
2986                     break;
2987                   case 'j':
2988                     jump_opt_dump = 1;
2989                     break;
2990                   case 'J':
2991                     jump2_opt_dump = 1;
2992                     break;
2993                   case 'l':
2994                     local_reg_dump = 1;
2995                     break;
2996                   case 'L':
2997                     loop_dump = 1;
2998                     break;
2999                   case 'm':
3000                     flag_print_mem = 1;
3001                     break;
3002                   case 'p':
3003                     flag_print_asm_name = 1;
3004                     break;
3005                   case 'r':
3006                     rtl_dump = 1;
3007                     break;
3008                   case 's':
3009                     cse_dump = 1;
3010                     break;
3011                   case 't':
3012                     cse2_dump = 1;
3013                     break;
3014                   case 'S':
3015                     sched_dump = 1;
3016                     break;
3017                   case 'R':
3018                     sched2_dump = 1;
3019                     break;
3020                   case 'y':
3021                     set_yydebug (1);
3022                     break;
3023
3024                   case 'x':
3025                     rtl_dump_and_exit = 1;
3026                     break;
3027                   }
3028             }
3029           else if (str[0] == 'f')
3030             {
3031               register char *p = &str[1];
3032               int found = 0;
3033
3034               /* Some kind of -f option.
3035                  P's value is the option sans `-f'.
3036                  Search for it in the table of options.  */
3037
3038               for (j = 0;
3039                    !found && j < sizeof (f_options) / sizeof (f_options[0]);
3040                    j++)
3041                 {
3042                   if (!strcmp (p, f_options[j].string))
3043                     {
3044                       *f_options[j].variable = f_options[j].on_value;
3045                       /* A goto here would be cleaner,
3046                          but breaks the vax pcc.  */
3047                       found = 1;
3048                     }
3049                   if (p[0] == 'n' && p[1] == 'o' && p[2] == '-'
3050                       && ! strcmp (p+3, f_options[j].string))
3051                     {
3052                       *f_options[j].variable = ! f_options[j].on_value;
3053                       found = 1;
3054                     }
3055                 }
3056
3057               if (found)
3058                 ;
3059               else if (!strncmp (p, "fixed-", 6))
3060                 fix_register (&p[6], 1, 1);
3061               else if (!strncmp (p, "call-used-", 10))
3062                 fix_register (&p[10], 0, 1);
3063               else if (!strncmp (p, "call-saved-", 11))
3064                 fix_register (&p[11], 0, 0);
3065               else
3066                 error ("Invalid option `%s'", argv[i]);
3067             }
3068           else if (str[0] == 'O')
3069             {
3070               register char *p = str+1;
3071               while (*p && *p >= '0' && *p <= '9')
3072                 p++;
3073               if (*p == '\0')
3074                 ;
3075               else
3076                 error ("Invalid option `%s'", argv[i]);
3077             }
3078           else if (!strcmp (str, "pedantic"))
3079             pedantic = 1;
3080           else if (!strcmp (str, "pedantic-errors"))
3081             flag_pedantic_errors = pedantic = 1;
3082           else if (!strcmp (str, "quiet"))
3083             quiet_flag = 1;
3084           else if (!strcmp (str, "version"))
3085             version_flag = 1;
3086           else if (!strcmp (str, "w"))
3087             inhibit_warnings = 1;
3088           else if (!strcmp (str, "W"))
3089             {
3090               extra_warnings = 1;
3091               warn_uninitialized = 1;
3092             }
3093           else if (str[0] == 'W')
3094             {
3095               register char *p = &str[1];
3096               int found = 0;
3097
3098               /* Some kind of -W option.
3099                  P's value is the option sans `-W'.
3100                  Search for it in the table of options.  */
3101
3102               for (j = 0;
3103                    !found && j < sizeof (W_options) / sizeof (W_options[0]);
3104                    j++)
3105                 {
3106                   if (!strcmp (p, W_options[j].string))
3107                     {
3108                       *W_options[j].variable = W_options[j].on_value;
3109                       /* A goto here would be cleaner,
3110                          but breaks the vax pcc.  */
3111                       found = 1;
3112                     }
3113                   if (p[0] == 'n' && p[1] == 'o' && p[2] == '-'
3114                       && ! strcmp (p+3, W_options[j].string))
3115                     {
3116                       *W_options[j].variable = ! W_options[j].on_value;
3117                       found = 1;
3118                     }
3119                 }
3120
3121               if (found)
3122                 ;
3123               else if (!strncmp (p, "id-clash-", 9))
3124                 {
3125                   char *endp = p + 9;
3126
3127                   while (*endp)
3128                     {
3129                       if (*endp >= '0' && *endp <= '9')
3130                         endp++;
3131                       else
3132                         {
3133                           error ("Invalid option `%s'", argv[i]);
3134                           goto id_clash_lose;
3135                         }
3136                     }
3137                   warn_id_clash = 1;
3138                   id_clash_len = atoi (str + 10);
3139                 id_clash_lose: ;
3140                 }
3141               else
3142                 error ("Invalid option `%s'", argv[i]);
3143             }
3144           else if (!strcmp (str, "p"))
3145             profile_flag = 1;
3146           else if (!strcmp (str, "a"))
3147             {
3148 #if !defined (BLOCK_PROFILER) || !defined (FUNCTION_BLOCK_PROFILER)
3149               warning ("`-a' option (basic block profile) not supported");
3150 #else
3151               profile_block_flag = 1;
3152 #endif
3153             }
3154           else if (str[0] == 'g')
3155             {
3156               char *p = str + 1;
3157               char *q;
3158               unsigned len;
3159               unsigned level;
3160
3161               while (*p && (*p < '0' || *p > '9'))
3162                 p++;
3163               len = p - str;
3164               q = p;
3165               while (*q && (*q >= '0' && *q <= '9'))
3166                 q++;
3167               if (*p)
3168                 level = atoi (p);
3169               else
3170                 level = 2;      /* default debugging info level */
3171               if (*q || level > 3)
3172                 {
3173                   warning ("invalid debug level specification in option: `-%s'",
3174                            str);
3175                   warning ("no debugging information will be generated");
3176                   level = 0;
3177                 }
3178
3179               /* If more than one debugging type is supported,
3180                  you must define PREFERRED_DEBUGGING_TYPE
3181                  to choose a format in a system-dependent way.  */
3182               /* This is one long line cause VAXC can't handle a \-newline.  */
3183 #if 1 < (defined (DBX_DEBUGGING_INFO) + defined (SDB_DEBUGGING_INFO) + defined (DWARF_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO))
3184 #ifdef PREFERRED_DEBUGGING_TYPE
3185               if (!strncmp (str, "ggdb", len))
3186                 write_symbols = PREFERRED_DEBUGGING_TYPE;
3187 #else /* no PREFERRED_DEBUGGING_TYPE */
3188 You Lose!  You must define PREFERRED_DEBUGGING_TYPE!
3189 #endif /* no PREFERRED_DEBUGGING_TYPE */
3190 #endif /* More than one debugger format enabled.  */
3191 #ifdef DBX_DEBUGGING_INFO
3192               if (write_symbols != NO_DEBUG)
3193                 ;
3194               else if (!strncmp (str, "ggdb", len))
3195                 write_symbols = DBX_DEBUG;
3196               else if (!strncmp (str, "gstabs", len))
3197                 write_symbols = DBX_DEBUG;
3198               else if (!strncmp (str, "gstabs+", len))
3199                 write_symbols = DBX_DEBUG;
3200
3201               /* Always enable extensions for -ggdb or -gstabs+,
3202                  always disable for -gstabs.
3203                  For plain -g, use system-specific default.  */
3204               if (write_symbols == DBX_DEBUG && !strncmp (str, "ggdb", len)
3205                   && len >= 2)
3206                 use_gnu_debug_info_extensions = 1;
3207               else if (write_symbols == DBX_DEBUG && !strncmp (str, "gstabs+", len)
3208                        && len >= 7)
3209                 use_gnu_debug_info_extensions = 1;
3210               else if (write_symbols == DBX_DEBUG
3211                        && !strncmp (str, "gstabs", len) && len >= 2)
3212                 use_gnu_debug_info_extensions = 0;
3213               else
3214                 use_gnu_debug_info_extensions = DEFAULT_GDB_EXTENSIONS;
3215 #endif /* DBX_DEBUGGING_INFO */
3216 #ifdef DWARF_DEBUGGING_INFO
3217               if (write_symbols != NO_DEBUG)
3218                 ;
3219               else if (!strncmp (str, "g", len))
3220                 write_symbols = DWARF_DEBUG;
3221               else if (!strncmp (str, "ggdb", len))
3222                 write_symbols = DWARF_DEBUG;
3223               else if (!strncmp (str, "gdwarf", len))
3224                 write_symbols = DWARF_DEBUG;
3225
3226               /* Always enable extensions for -ggdb or -gdwarf+,
3227                  always disable for -gdwarf.
3228                  For plain -g, use system-specific default.  */
3229               if (write_symbols == DWARF_DEBUG && !strncmp (str, "ggdb", len)
3230                   && len >= 2)
3231                 use_gnu_debug_info_extensions = 1;
3232               else if (write_symbols == DWARF_DEBUG && !strcmp (str, "gdwarf+"))
3233                 use_gnu_debug_info_extensions = 1;
3234               else if (write_symbols == DWARF_DEBUG
3235                        && !strncmp (str, "gdwarf", len) && len >= 2)
3236                 use_gnu_debug_info_extensions = 0;
3237               else
3238                 use_gnu_debug_info_extensions = DEFAULT_GDB_EXTENSIONS;
3239 #endif
3240 #ifdef SDB_DEBUGGING_INFO
3241               if (write_symbols != NO_DEBUG)
3242                 ;
3243               else if (!strncmp (str, "g", len))
3244                 write_symbols = SDB_DEBUG;
3245               else if (!strncmp (str, "gdb", len))
3246                 write_symbols = SDB_DEBUG;
3247               else if (!strncmp (str, "gcoff", len))
3248                 write_symbols = SDB_DEBUG;
3249 #endif /* SDB_DEBUGGING_INFO */
3250 #ifdef XCOFF_DEBUGGING_INFO
3251               if (write_symbols != NO_DEBUG)
3252                 ;
3253               else if (!strncmp (str, "g", len))
3254                 write_symbols = XCOFF_DEBUG;
3255               else if (!strncmp (str, "ggdb", len))
3256                 write_symbols = XCOFF_DEBUG;
3257               else if (!strncmp (str, "gxcoff", len))
3258                 write_symbols = XCOFF_DEBUG;
3259
3260               /* Always enable extensions for -ggdb or -gxcoff+,
3261                  always disable for -gxcoff.
3262                  For plain -g, use system-specific default.  */
3263               if (write_symbols == XCOFF_DEBUG && !strncmp (str, "ggdb", len)
3264                   && len >= 2)
3265                 use_gnu_debug_info_extensions = 1;
3266               else if (write_symbols == XCOFF_DEBUG && !strcmp (str, "gxcoff+"))
3267                 use_gnu_debug_info_extensions = 1;
3268               else if (write_symbols == XCOFF_DEBUG
3269                        && !strncmp (str, "gxcoff", len) && len >= 2)
3270                 use_gnu_debug_info_extensions = 0;
3271               else
3272                 use_gnu_debug_info_extensions = DEFAULT_GDB_EXTENSIONS;
3273 #endif
3274               if (write_symbols == NO_DEBUG)
3275                 warning ("`-%s' option not supported on this version of GCC", str);
3276               else if (level == 0)
3277                 write_symbols = NO_DEBUG;
3278               else
3279                 debug_info_level = (enum debug_info_level) level;
3280             }
3281           else if (!strcmp (str, "o"))
3282             {
3283               asm_file_name = argv[++i];
3284             }
3285           else if (str[0] == 'G')
3286             {
3287               g_switch_set = TRUE;
3288               g_switch_value = atoi ((str[1] != '\0') ? str+1 : argv[++i]);
3289             }
3290           else if (!strncmp (str, "aux-info", 8))
3291             {
3292               flag_gen_aux_info = 1;
3293               aux_info_file_name = (str[8] != '\0' ? str+8 : argv[++i]);
3294             }
3295           else
3296             error ("Invalid option `%s'", argv[i]);
3297         }
3298       else if (argv[i][0] == '+')
3299         error ("Invalid option `%s'", argv[i]);
3300       else
3301         filename = argv[i];
3302     }
3303
3304   if (optimize == 0)
3305     {
3306       /* Inlining does not work if not optimizing,
3307          so force it not to be done.  */
3308       flag_no_inline = 1;
3309       warn_inline = 0;
3310
3311       /* The c_decode_option and lang_decode_option functions set
3312          this to `2' if -Wall is used, so we can avoid giving out
3313          lots of errors for people who don't realize what -Wall does.  */
3314       if (warn_uninitialized == 1)
3315         warning ("-Wuninitialized is not supported without -O");
3316     }
3317
3318 #if defined(DWARF_DEBUGGING_INFO)
3319   if (write_symbols == DWARF_DEBUG
3320       && strcmp (language_string, "GNU C++") == 0)
3321     {
3322       warning ("-g option not supported for C++ on SVR4 systems");
3323       write_symbols = NO_DEBUG;
3324     }
3325 #endif /* defined(DWARF_DEBUGGING_INFO) */
3326
3327 #ifdef OVERRIDE_OPTIONS
3328   /* Some machines may reject certain combinations of options.  */
3329   OVERRIDE_OPTIONS;
3330 #endif
3331
3332   /* Unrolling all loops implies that standard loop unrolling must also
3333      be done.  */
3334   if (flag_unroll_all_loops)
3335     flag_unroll_loops = 1;
3336   /* Loop unrolling requires that strength_reduction be on also.  Silently
3337      turn on strength reduction here if it isn't already on.  Also, the loop
3338      unrolling code assumes that cse will be run after loop, so that must
3339      be turned on also.  */
3340   if (flag_unroll_loops)
3341     {
3342       flag_strength_reduce = 1;
3343       flag_rerun_cse_after_loop = 1;
3344     }
3345
3346   /* Warn about options that are not supported on this machine.  */
3347 #ifndef INSN_SCHEDULING
3348   if (flag_schedule_insns || flag_schedule_insns_after_reload)
3349     warning ("instruction scheduling not supported on this target machine");
3350 #endif
3351 #ifndef DELAY_SLOTS
3352   if (flag_delayed_branch)
3353     warning ("this target machine does not have delayed branches");
3354 #endif
3355
3356   /* If we are in verbose mode, write out the version and maybe all the
3357      option flags in use.  */
3358   if (version_flag)
3359     {
3360       fprintf (stderr, "%s version %s", language_string, version_string);
3361 #ifdef TARGET_VERSION
3362       TARGET_VERSION;
3363 #endif
3364 #ifdef __GNUC__
3365 #ifndef __VERSION__
3366 #define __VERSION__ "[unknown]"
3367 #endif
3368       fprintf (stderr, " compiled by GNU C version %s.\n", __VERSION__);
3369 #else
3370       fprintf (stderr, " compiled by CC.\n");
3371 #endif
3372       if (! quiet_flag)
3373         print_switch_values ();
3374     }
3375
3376   /* Now that register usage is specified, convert it to HARD_REG_SETs.  */
3377   init_reg_sets_1 ();
3378
3379   compile_file (filename);
3380
3381 #ifndef OS2
3382 #ifndef VMS
3383   if (flag_print_mem)
3384     {
3385       char *lim = (char *) sbrk (0);
3386
3387       fprintf (stderr, "Data size %d.\n",
3388                lim - (char *) &environ);
3389       fflush (stderr);
3390
3391 #ifdef USG
3392       system ("ps -l 1>&2");
3393 #else /* not USG */
3394       system ("ps v");
3395 #endif /* not USG */
3396     }
3397 #endif /* not VMS */
3398 #endif /* not OS2 */
3399
3400   if (errorcount)
3401     exit (FATAL_EXIT_CODE);
3402   if (sorrycount)
3403     exit (FATAL_EXIT_CODE);
3404   exit (SUCCESS_EXIT_CODE);
3405   return 34;
3406 }
3407 \f
3408 /* Decode -m switches.  */
3409
3410 /* Here is a table, controlled by the tm.h file, listing each -m switch
3411    and which bits in `target_switches' it should set or clear.
3412    If VALUE is positive, it is bits to set.
3413    If VALUE is negative, -VALUE is bits to clear.
3414    (The sign bit is not used so there is no confusion.)  */
3415
3416 struct {char *name; int value;} target_switches []
3417   = TARGET_SWITCHES;
3418
3419 /* This table is similar, but allows the switch to have a value.  */
3420
3421 #ifdef TARGET_OPTIONS
3422 struct {char *prefix; char ** variable;} target_options []
3423   = TARGET_OPTIONS;
3424 #endif
3425
3426 /* Decode the switch -mNAME.  */
3427
3428 void
3429 set_target_switch (name)
3430      char *name;
3431 {
3432   register int j;
3433   int valid = 0;
3434
3435   for (j = 0; j < sizeof target_switches / sizeof target_switches[0]; j++)
3436     if (!strcmp (target_switches[j].name, name))
3437       {
3438         if (target_switches[j].value < 0)
3439           target_flags &= ~-target_switches[j].value;
3440         else
3441           target_flags |= target_switches[j].value;
3442         valid = 1;
3443       }
3444
3445 #ifdef TARGET_OPTIONS
3446   if (!valid)
3447     for (j = 0; j < sizeof target_options / sizeof target_options[0]; j++)
3448       {
3449         int len = strlen (target_options[j].prefix);
3450         if (!strncmp (target_options[j].prefix, name, len))
3451           {
3452             *target_options[j].variable = name + len;
3453             valid = 1;
3454           }
3455       }
3456 #endif
3457
3458   if (!valid)
3459     error ("Invalid option `%s'", name);
3460 }
3461 \f
3462 /* Variable used for communication between the following two routines.  */
3463
3464 static int line_position;
3465
3466 /* Print an option value and adjust the position in the line.  */
3467
3468 static void
3469 print_single_switch (type, name)
3470      char *type, *name;
3471 {
3472   fprintf (stderr, " %s%s", type, name);
3473
3474   line_position += strlen (type) + strlen (name) + 1;
3475
3476   if (line_position > 65)
3477     {
3478       fprintf (stderr, "\n\t");
3479       line_position = 8;
3480     }
3481 }
3482
3483 /* Print default target switches for -version.  */
3484
3485 static void
3486 print_switch_values ()
3487 {
3488   register int j;
3489
3490   fprintf (stderr, "enabled:");
3491   line_position = 8;
3492
3493   for (j = 0; j < sizeof f_options / sizeof f_options[0]; j++)
3494     if (*f_options[j].variable == f_options[j].on_value)
3495       print_single_switch ("-f", f_options[j].string);
3496
3497   for (j = 0; j < sizeof W_options / sizeof W_options[0]; j++)
3498     if (*W_options[j].variable == W_options[j].on_value)
3499       print_single_switch ("-W", W_options[j].string);
3500
3501   for (j = 0; j < sizeof target_switches / sizeof target_switches[0]; j++)
3502     if (target_switches[j].name[0] != '\0'
3503         && target_switches[j].value > 0
3504         && ((target_switches[j].value & target_flags)
3505             == target_switches[j].value))
3506       print_single_switch ("-m", target_switches[j].name);
3507
3508   fprintf (stderr, "\n");
3509 }