/* Top level of GCC compilers (cc1, cc1plus, etc.)
|
/* Top level of GCC compilers (cc1, cc1plus, etc.)
|
Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
|
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
GCC is free software; you can redistribute it and/or modify it under
|
the terms of the GNU General Public License as published by the Free
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
/* This is the top level of cc1/c++.
|
/* This is the top level of cc1/c++.
|
It parses command args, opens files, invokes the various passes
|
It parses command args, opens files, invokes the various passes
|
in the proper order, and counts the time used by each.
|
in the proper order, and counts the time used by each.
|
Error messages and low-level interface to malloc also handled here. */
|
Error messages and low-level interface to malloc also handled here. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#undef FLOAT /* This is for hpux. They should change hpux. */
|
#undef FLOAT /* This is for hpux. They should change hpux. */
|
#undef FFS /* Some systems define this in param.h. */
|
#undef FFS /* Some systems define this in param.h. */
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include <signal.h>
|
#include <signal.h>
|
|
|
#ifdef HAVE_SYS_RESOURCE_H
|
#ifdef HAVE_SYS_RESOURCE_H
|
# include <sys/resource.h>
|
# include <sys/resource.h>
|
#endif
|
#endif
|
|
|
#ifdef HAVE_SYS_TIMES_H
|
#ifdef HAVE_SYS_TIMES_H
|
# include <sys/times.h>
|
# include <sys/times.h>
|
#endif
|
#endif
|
|
|
#include "line-map.h"
|
#include "line-map.h"
|
#include "input.h"
|
#include "input.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "version.h"
|
#include "version.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "insn-attr.h"
|
#include "insn-attr.h"
|
#include "insn-config.h"
|
#include "insn-config.h"
|
#include "insn-flags.h"
|
#include "insn-flags.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "recog.h"
|
#include "recog.h"
|
#include "output.h"
|
#include "output.h"
|
#include "except.h"
|
#include "except.h"
|
#include "function.h"
|
#include "function.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "intl.h"
|
#include "intl.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "graph.h"
|
#include "graph.h"
|
#include "regs.h"
|
#include "regs.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "params.h"
|
#include "params.h"
|
#include "reload.h"
|
#include "reload.h"
|
#include "dwarf2asm.h"
|
#include "dwarf2asm.h"
|
#include "integrate.h"
|
#include "integrate.h"
|
#include "real.h"
|
#include "real.h"
|
#include "debug.h"
|
#include "debug.h"
|
#include "target.h"
|
#include "target.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "cfglayout.h"
|
#include "cfglayout.h"
|
#include "cfgloop.h"
|
#include "cfgloop.h"
|
#include "hosthooks.h"
|
#include "hosthooks.h"
|
#include "cgraph.h"
|
#include "cgraph.h"
|
#include "opts.h"
|
#include "opts.h"
|
#include "coverage.h"
|
#include "coverage.h"
|
#include "value-prof.h"
|
#include "value-prof.h"
|
#include "alloc-pool.h"
|
#include "alloc-pool.h"
|
#include "tree-mudflap.h"
|
#include "tree-mudflap.h"
|
|
|
#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
|
#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
|
#include "dwarf2out.h"
|
#include "dwarf2out.h"
|
#endif
|
#endif
|
|
|
#if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
|
#if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
|
#include "dbxout.h"
|
#include "dbxout.h"
|
#endif
|
#endif
|
|
|
#ifdef SDB_DEBUGGING_INFO
|
#ifdef SDB_DEBUGGING_INFO
|
#include "sdbout.h"
|
#include "sdbout.h"
|
#endif
|
#endif
|
|
|
#ifdef XCOFF_DEBUGGING_INFO
|
#ifdef XCOFF_DEBUGGING_INFO
|
#include "xcoffout.h" /* Needed for external data
|
#include "xcoffout.h" /* Needed for external data
|
declarations for e.g. AIX 4.x. */
|
declarations for e.g. AIX 4.x. */
|
#endif
|
#endif
|
|
|
static void general_init (const char *);
|
static void general_init (const char *);
|
static void do_compile (void);
|
static void do_compile (void);
|
static void process_options (void);
|
static void process_options (void);
|
static void backend_init (void);
|
static void backend_init (void);
|
static int lang_dependent_init (const char *);
|
static int lang_dependent_init (const char *);
|
static void init_asm_output (const char *);
|
static void init_asm_output (const char *);
|
static void finalize (void);
|
static void finalize (void);
|
|
|
static void crash_signal (int) ATTRIBUTE_NORETURN;
|
static void crash_signal (int) ATTRIBUTE_NORETURN;
|
static void setup_core_dumping (void);
|
static void setup_core_dumping (void);
|
static void compile_file (void);
|
static void compile_file (void);
|
|
|
static int print_single_switch (FILE *, int, int, const char *,
|
static int print_single_switch (FILE *, int, int, const char *,
|
const char *, const char *,
|
const char *, const char *,
|
const char *, const char *);
|
const char *, const char *);
|
static void print_switch_values (FILE *, int, int, const char *,
|
static void print_switch_values (FILE *, int, int, const char *,
|
const char *, const char *);
|
const char *, const char *);
|
|
|
/* Nonzero to dump debug info whilst parsing (-dy option). */
|
/* Nonzero to dump debug info whilst parsing (-dy option). */
|
static int set_yydebug;
|
static int set_yydebug;
|
|
|
/* True if we don't need a backend (e.g. preprocessing only). */
|
/* True if we don't need a backend (e.g. preprocessing only). */
|
static bool no_backend;
|
static bool no_backend;
|
|
|
/* Length of line when printing switch values. */
|
/* Length of line when printing switch values. */
|
#define MAX_LINE 75
|
#define MAX_LINE 75
|
|
|
/* Name of program invoked, sans directories. */
|
/* Name of program invoked, sans directories. */
|
|
|
const char *progname;
|
const char *progname;
|
|
|
/* Copy of argument vector to toplev_main. */
|
/* Copy of argument vector to toplev_main. */
|
static const char **save_argv;
|
static const char **save_argv;
|
|
|
/* Name of top-level original source file (what was input to cpp).
|
/* Name of top-level original source file (what was input to cpp).
|
This comes from the #-command at the beginning of the actual input.
|
This comes from the #-command at the beginning of the actual input.
|
If there isn't any there, then this is the cc1 input file name. */
|
If there isn't any there, then this is the cc1 input file name. */
|
|
|
const char *main_input_filename;
|
const char *main_input_filename;
|
|
|
#ifndef USE_MAPPED_LOCATION
|
#ifndef USE_MAPPED_LOCATION
|
location_t unknown_location = { NULL, 0 };
|
location_t unknown_location = { NULL, 0 };
|
#endif
|
#endif
|
|
|
/* Used to enable -fvar-tracking, -fweb and -frename-registers according
|
/* Used to enable -fvar-tracking, -fweb and -frename-registers according
|
to optimize and default_debug_hooks in process_options (). */
|
to optimize and default_debug_hooks in process_options (). */
|
#define AUTODETECT_VALUE 2
|
#define AUTODETECT_VALUE 2
|
|
|
/* Current position in real source file. */
|
/* Current position in real source file. */
|
|
|
location_t input_location;
|
location_t input_location;
|
|
|
struct line_maps line_table;
|
struct line_maps line_table;
|
|
|
/* Nonzero if it is unsafe to create any new pseudo registers. */
|
/* Nonzero if it is unsafe to create any new pseudo registers. */
|
int no_new_pseudos;
|
int no_new_pseudos;
|
|
|
/* Stack of currently pending input files. */
|
/* Stack of currently pending input files. */
|
|
|
struct file_stack *input_file_stack;
|
struct file_stack *input_file_stack;
|
|
|
/* Incremented on each change to input_file_stack. */
|
/* Incremented on each change to input_file_stack. */
|
int input_file_stack_tick;
|
int input_file_stack_tick;
|
|
|
/* Record of input_file_stack at each tick. */
|
/* Record of input_file_stack at each tick. */
|
typedef struct file_stack *fs_p;
|
typedef struct file_stack *fs_p;
|
DEF_VEC_P(fs_p);
|
DEF_VEC_P(fs_p);
|
DEF_VEC_ALLOC_P(fs_p,heap);
|
DEF_VEC_ALLOC_P(fs_p,heap);
|
static VEC(fs_p,heap) *input_file_stack_history;
|
static VEC(fs_p,heap) *input_file_stack_history;
|
|
|
/* Whether input_file_stack has been restored to a previous state (in
|
/* Whether input_file_stack has been restored to a previous state (in
|
which case there should be no more pushing). */
|
which case there should be no more pushing). */
|
static bool input_file_stack_restored;
|
static bool input_file_stack_restored;
|
|
|
/* Name to use as base of names for dump output files. */
|
/* Name to use as base of names for dump output files. */
|
|
|
const char *dump_base_name;
|
const char *dump_base_name;
|
|
|
/* Name to use as a base for auxiliary output files. */
|
/* Name to use as a base for auxiliary output files. */
|
|
|
const char *aux_base_name;
|
const char *aux_base_name;
|
|
|
/* Bit flags that specify the machine subtype we are compiling for.
|
/* Bit flags that specify the machine subtype we are compiling for.
|
Bits are tested using macros TARGET_... defined in the tm.h file
|
Bits are tested using macros TARGET_... defined in the tm.h file
|
and set by `-m...' switches. Must be defined in rtlanal.c. */
|
and set by `-m...' switches. Must be defined in rtlanal.c. */
|
|
|
extern int target_flags;
|
extern int target_flags;
|
|
|
/* A mask of target_flags that includes bit X if X was set or cleared
|
/* A mask of target_flags that includes bit X if X was set or cleared
|
on the command line. */
|
on the command line. */
|
|
|
int target_flags_explicit;
|
int target_flags_explicit;
|
|
|
/* Debug hooks - dependent upon command line options. */
|
/* Debug hooks - dependent upon command line options. */
|
|
|
const struct gcc_debug_hooks *debug_hooks;
|
const struct gcc_debug_hooks *debug_hooks;
|
|
|
/* Debug hooks - target default. */
|
/* Debug hooks - target default. */
|
|
|
static const struct gcc_debug_hooks *default_debug_hooks;
|
static const struct gcc_debug_hooks *default_debug_hooks;
|
|
|
/* Other flags saying which kinds of debugging dump have been requested. */
|
/* Other flags saying which kinds of debugging dump have been requested. */
|
|
|
int rtl_dump_and_exit;
|
int rtl_dump_and_exit;
|
int flag_print_asm_name;
|
int flag_print_asm_name;
|
enum graph_dump_types graph_dump_format;
|
enum graph_dump_types graph_dump_format;
|
|
|
/* Name for output file of assembly code, specified with -o. */
|
/* Name for output file of assembly code, specified with -o. */
|
|
|
const char *asm_file_name;
|
const char *asm_file_name;
|
|
|
/* Nonzero means do optimizations. -O.
|
/* Nonzero means do optimizations. -O.
|
Particular numeric values stand for particular amounts of optimization;
|
Particular numeric values stand for particular amounts of optimization;
|
thus, -O2 stores 2 here. However, the optimizations beyond the basic
|
thus, -O2 stores 2 here. However, the optimizations beyond the basic
|
ones are not controlled directly by this variable. Instead, they are
|
ones are not controlled directly by this variable. Instead, they are
|
controlled by individual `flag_...' variables that are defaulted
|
controlled by individual `flag_...' variables that are defaulted
|
based on this variable. */
|
based on this variable. */
|
|
|
int optimize = 0;
|
int optimize = 0;
|
|
|
/* Nonzero means optimize for size. -Os.
|
/* Nonzero means optimize for size. -Os.
|
The only valid values are zero and nonzero. When optimize_size is
|
The only valid values are zero and nonzero. When optimize_size is
|
nonzero, optimize defaults to 2, but certain individual code
|
nonzero, optimize defaults to 2, but certain individual code
|
bloating optimizations are disabled. */
|
bloating optimizations are disabled. */
|
|
|
int optimize_size = 0;
|
int optimize_size = 0;
|
|
|
/* The FUNCTION_DECL for the function currently being compiled,
|
/* The FUNCTION_DECL for the function currently being compiled,
|
or 0 if between functions. */
|
or 0 if between functions. */
|
tree current_function_decl;
|
tree current_function_decl;
|
|
|
/* Set to the FUNC_BEGIN label of the current function, or NULL
|
/* Set to the FUNC_BEGIN label of the current function, or NULL
|
if none. */
|
if none. */
|
const char * current_function_func_begin_label;
|
const char * current_function_func_begin_label;
|
|
|
/* Temporarily suppress certain warnings.
|
/* Temporarily suppress certain warnings.
|
This is set while reading code from a system header file. */
|
This is set while reading code from a system header file. */
|
|
|
int in_system_header = 0;
|
int in_system_header = 0;
|
|
|
/* Nonzero means to collect statistics which might be expensive
|
/* Nonzero means to collect statistics which might be expensive
|
and to print them when we are done. */
|
and to print them when we are done. */
|
int flag_detailed_statistics = 0;
|
int flag_detailed_statistics = 0;
|
|
|
/* A random sequence of characters, unless overridden by user. */
|
/* A random sequence of characters, unless overridden by user. */
|
const char *flag_random_seed;
|
const char *flag_random_seed;
|
|
|
/* A local time stamp derived from the time of compilation. It will be
|
/* A local time stamp derived from the time of compilation. It will be
|
zero if the system cannot provide a time. It will be -1u, if the
|
zero if the system cannot provide a time. It will be -1u, if the
|
user has specified a particular random seed. */
|
user has specified a particular random seed. */
|
unsigned local_tick;
|
unsigned local_tick;
|
|
|
/* -f flags. */
|
/* -f flags. */
|
|
|
/* Nonzero means `char' should be signed. */
|
/* Nonzero means `char' should be signed. */
|
|
|
int flag_signed_char;
|
int flag_signed_char;
|
|
|
/* Nonzero means give an enum type only as many bytes as it needs. A value
|
/* Nonzero means give an enum type only as many bytes as it needs. A value
|
of 2 means it has not yet been initialized. */
|
of 2 means it has not yet been initialized. */
|
|
|
int flag_short_enums;
|
int flag_short_enums;
|
|
|
/* Nonzero if structures and unions should be returned in memory.
|
/* Nonzero if structures and unions should be returned in memory.
|
|
|
This should only be defined if compatibility with another compiler or
|
This should only be defined if compatibility with another compiler or
|
with an ABI is needed, because it results in slower code. */
|
with an ABI is needed, because it results in slower code. */
|
|
|
#ifndef DEFAULT_PCC_STRUCT_RETURN
|
#ifndef DEFAULT_PCC_STRUCT_RETURN
|
#define DEFAULT_PCC_STRUCT_RETURN 1
|
#define DEFAULT_PCC_STRUCT_RETURN 1
|
#endif
|
#endif
|
|
|
/* Nonzero for -fpcc-struct-return: return values the same way PCC does. */
|
/* Nonzero for -fpcc-struct-return: return values the same way PCC does. */
|
|
|
int flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
|
int flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
|
|
|
/* 0 means straightforward implementation of complex divide acceptable.
|
/* 0 means straightforward implementation of complex divide acceptable.
|
1 means wide ranges of inputs must work for complex divide.
|
1 means wide ranges of inputs must work for complex divide.
|
2 means C99-like requirements for complex multiply and divide. */
|
2 means C99-like requirements for complex multiply and divide. */
|
|
|
int flag_complex_method = 1;
|
int flag_complex_method = 1;
|
|
|
/* Nonzero means that we don't want inlining by virtue of -fno-inline,
|
/* Nonzero means that we don't want inlining by virtue of -fno-inline,
|
not just because the tree inliner turned us off. */
|
not just because the tree inliner turned us off. */
|
|
|
int flag_really_no_inline = 2;
|
int flag_really_no_inline = 2;
|
|
|
/* Nonzero means we should be saving declaration info into a .X file. */
|
/* Nonzero means we should be saving declaration info into a .X file. */
|
|
|
int flag_gen_aux_info = 0;
|
int flag_gen_aux_info = 0;
|
|
|
/* Specified name of aux-info file. */
|
/* Specified name of aux-info file. */
|
|
|
const char *aux_info_file_name;
|
const char *aux_info_file_name;
|
|
|
/* Nonzero if we are compiling code for a shared library, zero for
|
/* Nonzero if we are compiling code for a shared library, zero for
|
executable. */
|
executable. */
|
|
|
int flag_shlib;
|
int flag_shlib;
|
|
|
/* Generate code for GNU or NeXT Objective-C runtime environment. */
|
/* Generate code for GNU or NeXT Objective-C runtime environment. */
|
|
|
#ifdef NEXT_OBJC_RUNTIME
|
#ifdef NEXT_OBJC_RUNTIME
|
int flag_next_runtime = 1;
|
int flag_next_runtime = 1;
|
#else
|
#else
|
int flag_next_runtime = 0;
|
int flag_next_runtime = 0;
|
#endif
|
#endif
|
|
|
/* Set to the default thread-local storage (tls) model to use. */
|
/* Set to the default thread-local storage (tls) model to use. */
|
|
|
enum tls_model flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
|
enum tls_model flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
|
|
|
/* Nonzero means change certain warnings into errors.
|
/* Nonzero means change certain warnings into errors.
|
Usually these are warnings about failure to conform to some standard. */
|
Usually these are warnings about failure to conform to some standard. */
|
|
|
int flag_pedantic_errors = 0;
|
int flag_pedantic_errors = 0;
|
|
|
/* -dA causes debug commentary information to be produced in
|
/* -dA causes debug commentary information to be produced in
|
the generated assembly code (to make it more readable). This option
|
the generated assembly code (to make it more readable). This option
|
is generally only of use to those who actually need to read the
|
is generally only of use to those who actually need to read the
|
generated assembly code (perhaps while debugging the compiler itself).
|
generated assembly code (perhaps while debugging the compiler itself).
|
Currently, this switch is only used by dwarfout.c; however, it is intended
|
Currently, this switch is only used by dwarfout.c; however, it is intended
|
to be a catchall for printing debug information in the assembler file. */
|
to be a catchall for printing debug information in the assembler file. */
|
|
|
int flag_debug_asm = 0;
|
int flag_debug_asm = 0;
|
|
|
/* -dP causes the rtl to be emitted as a comment in assembly. */
|
/* -dP causes the rtl to be emitted as a comment in assembly. */
|
|
|
int flag_dump_rtl_in_asm = 0;
|
int flag_dump_rtl_in_asm = 0;
|
|
|
/* When non-NULL, indicates that whenever space is allocated on the
|
/* When non-NULL, indicates that whenever space is allocated on the
|
stack, the resulting stack pointer must not pass this
|
stack, the resulting stack pointer must not pass this
|
address---that is, for stacks that grow downward, the stack pointer
|
address---that is, for stacks that grow downward, the stack pointer
|
must always be greater than or equal to this address; for stacks
|
must always be greater than or equal to this address; for stacks
|
that grow upward, the stack pointer must be less than this address.
|
that grow upward, the stack pointer must be less than this address.
|
At present, the rtx may be either a REG or a SYMBOL_REF, although
|
At present, the rtx may be either a REG or a SYMBOL_REF, although
|
the support provided depends on the backend. */
|
the support provided depends on the backend. */
|
rtx stack_limit_rtx;
|
rtx stack_limit_rtx;
|
|
|
/* If one, renumber instruction UIDs to reduce the number of
|
/* If one, renumber instruction UIDs to reduce the number of
|
unused UIDs if there are a lot of instructions. If greater than
|
unused UIDs if there are a lot of instructions. If greater than
|
one, unconditionally renumber instruction UIDs. */
|
one, unconditionally renumber instruction UIDs. */
|
int flag_renumber_insns = 1;
|
int flag_renumber_insns = 1;
|
|
|
/* Nonzero if we should track variables. When
|
/* Nonzero if we should track variables. When
|
flag_var_tracking == AUTODETECT_VALUE it will be set according
|
flag_var_tracking == AUTODETECT_VALUE it will be set according
|
to optimize, debug_info_level and debug_hooks in process_options (). */
|
to optimize, debug_info_level and debug_hooks in process_options (). */
|
int flag_var_tracking = AUTODETECT_VALUE;
|
int flag_var_tracking = AUTODETECT_VALUE;
|
|
|
/* True if the user has tagged the function with the 'section'
|
/* True if the user has tagged the function with the 'section'
|
attribute. */
|
attribute. */
|
|
|
bool user_defined_section_attribute = false;
|
bool user_defined_section_attribute = false;
|
|
|
/* Values of the -falign-* flags: how much to align labels in code.
|
/* Values of the -falign-* flags: how much to align labels in code.
|
0 means `use default', 1 means `don't align'.
|
0 means `use default', 1 means `don't align'.
|
For each variable, there is an _log variant which is the power
|
For each variable, there is an _log variant which is the power
|
of two not less than the variable, for .align output. */
|
of two not less than the variable, for .align output. */
|
|
|
int align_loops_log;
|
int align_loops_log;
|
int align_loops_max_skip;
|
int align_loops_max_skip;
|
int align_jumps_log;
|
int align_jumps_log;
|
int align_jumps_max_skip;
|
int align_jumps_max_skip;
|
int align_labels_log;
|
int align_labels_log;
|
int align_labels_max_skip;
|
int align_labels_max_skip;
|
int align_functions_log;
|
int align_functions_log;
|
|
|
/* Like align_functions_log above, but used by front-ends to force the
|
/* Like align_functions_log above, but used by front-ends to force the
|
minimum function alignment. Zero means no alignment is forced. */
|
minimum function alignment. Zero means no alignment is forced. */
|
int force_align_functions_log;
|
int force_align_functions_log;
|
|
|
typedef struct
|
typedef struct
|
{
|
{
|
const char *const string;
|
const char *const string;
|
int *const variable;
|
int *const variable;
|
const int on_value;
|
const int on_value;
|
}
|
}
|
lang_independent_options;
|
lang_independent_options;
|
|
|
/* Nonzero if subexpressions must be evaluated from left-to-right. */
|
/* Nonzero if subexpressions must be evaluated from left-to-right. */
|
int flag_evaluation_order = 0;
|
int flag_evaluation_order = 0;
|
|
|
/* The user symbol prefix after having resolved same. */
|
/* The user symbol prefix after having resolved same. */
|
const char *user_label_prefix;
|
const char *user_label_prefix;
|
|
|
static const param_info lang_independent_params[] = {
|
static const param_info lang_independent_params[] = {
|
#define DEFPARAM(ENUM, OPTION, HELP, DEFAULT, MIN, MAX) \
|
#define DEFPARAM(ENUM, OPTION, HELP, DEFAULT, MIN, MAX) \
|
{ OPTION, DEFAULT, MIN, MAX, HELP },
|
{ OPTION, DEFAULT, MIN, MAX, HELP },
|
#include "params.def"
|
#include "params.def"
|
#undef DEFPARAM
|
#undef DEFPARAM
|
{ NULL, 0, 0, 0, NULL }
|
{ NULL, 0, 0, 0, NULL }
|
};
|
};
|
|
|
/* Output files for assembler code (real compiler output)
|
/* Output files for assembler code (real compiler output)
|
and debugging dumps. */
|
and debugging dumps. */
|
|
|
FILE *asm_out_file;
|
FILE *asm_out_file;
|
FILE *aux_info_file;
|
FILE *aux_info_file;
|
FILE *dump_file = NULL;
|
FILE *dump_file = NULL;
|
const char *dump_file_name;
|
const char *dump_file_name;
|
|
|
/* The current working directory of a translation. It's generally the
|
/* The current working directory of a translation. It's generally the
|
directory from which compilation was initiated, but a preprocessed
|
directory from which compilation was initiated, but a preprocessed
|
file may specify the original directory in which it was
|
file may specify the original directory in which it was
|
created. */
|
created. */
|
|
|
static const char *src_pwd;
|
static const char *src_pwd;
|
|
|
/* Initialize src_pwd with the given string, and return true. If it
|
/* Initialize src_pwd with the given string, and return true. If it
|
was already initialized, return false. As a special case, it may
|
was already initialized, return false. As a special case, it may
|
be called with a NULL argument to test whether src_pwd has NOT been
|
be called with a NULL argument to test whether src_pwd has NOT been
|
initialized yet. */
|
initialized yet. */
|
|
|
bool
|
bool
|
set_src_pwd (const char *pwd)
|
set_src_pwd (const char *pwd)
|
{
|
{
|
if (src_pwd)
|
if (src_pwd)
|
{
|
{
|
if (strcmp (src_pwd, pwd) == 0)
|
if (strcmp (src_pwd, pwd) == 0)
|
return true;
|
return true;
|
else
|
else
|
return false;
|
return false;
|
}
|
}
|
|
|
src_pwd = xstrdup (pwd);
|
src_pwd = xstrdup (pwd);
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Return the directory from which the translation unit was initiated,
|
/* Return the directory from which the translation unit was initiated,
|
in case set_src_pwd() was not called before to assign it a
|
in case set_src_pwd() was not called before to assign it a
|
different value. */
|
different value. */
|
|
|
const char *
|
const char *
|
get_src_pwd (void)
|
get_src_pwd (void)
|
{
|
{
|
if (! src_pwd)
|
if (! src_pwd)
|
{
|
{
|
src_pwd = getpwd ();
|
src_pwd = getpwd ();
|
if (!src_pwd)
|
if (!src_pwd)
|
src_pwd = ".";
|
src_pwd = ".";
|
}
|
}
|
|
|
return src_pwd;
|
return src_pwd;
|
}
|
}
|
|
|
/* Called when the start of a function definition is parsed,
|
/* Called when the start of a function definition is parsed,
|
this function prints on stderr the name of the function. */
|
this function prints on stderr the name of the function. */
|
void
|
void
|
announce_function (tree decl)
|
announce_function (tree decl)
|
{
|
{
|
if (!quiet_flag)
|
if (!quiet_flag)
|
{
|
{
|
if (rtl_dump_and_exit)
|
if (rtl_dump_and_exit)
|
fprintf (stderr, "%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
|
fprintf (stderr, "%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
|
else
|
else
|
fprintf (stderr, " %s", lang_hooks.decl_printable_name (decl, 2));
|
fprintf (stderr, " %s", lang_hooks.decl_printable_name (decl, 2));
|
fflush (stderr);
|
fflush (stderr);
|
pp_needs_newline (global_dc->printer) = true;
|
pp_needs_newline (global_dc->printer) = true;
|
diagnostic_set_last_function (global_dc);
|
diagnostic_set_last_function (global_dc);
|
}
|
}
|
}
|
}
|
|
|
/* Set up a default flag_random_seed and local_tick, unless the user
|
/* Set up a default flag_random_seed and local_tick, unless the user
|
already specified one. */
|
already specified one. */
|
|
|
static void
|
static void
|
randomize (void)
|
randomize (void)
|
{
|
{
|
if (!flag_random_seed)
|
if (!flag_random_seed)
|
{
|
{
|
unsigned HOST_WIDE_INT value;
|
unsigned HOST_WIDE_INT value;
|
static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
|
static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
|
|
|
/* Get some more or less random data. */
|
/* Get some more or less random data. */
|
#ifdef HAVE_GETTIMEOFDAY
|
#ifdef HAVE_GETTIMEOFDAY
|
{
|
{
|
struct timeval tv;
|
struct timeval tv;
|
|
|
gettimeofday (&tv, NULL);
|
gettimeofday (&tv, NULL);
|
local_tick = tv.tv_sec * 1000 + tv.tv_usec / 1000;
|
local_tick = tv.tv_sec * 1000 + tv.tv_usec / 1000;
|
}
|
}
|
#else
|
#else
|
{
|
{
|
time_t now = time (NULL);
|
time_t now = time (NULL);
|
|
|
if (now != (time_t)-1)
|
if (now != (time_t)-1)
|
local_tick = (unsigned) now;
|
local_tick = (unsigned) now;
|
}
|
}
|
#endif
|
#endif
|
value = local_tick ^ getpid ();
|
value = local_tick ^ getpid ();
|
|
|
sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
|
sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
|
flag_random_seed = random_seed;
|
flag_random_seed = random_seed;
|
}
|
}
|
else if (!local_tick)
|
else if (!local_tick)
|
local_tick = -1;
|
local_tick = -1;
|
}
|
}
|
|
|
|
|
/* Decode the string P as an integral parameter.
|
/* Decode the string P as an integral parameter.
|
If the string is indeed an integer return its numeric value else
|
If the string is indeed an integer return its numeric value else
|
issue an Invalid Option error for the option PNAME and return DEFVAL.
|
issue an Invalid Option error for the option PNAME and return DEFVAL.
|
If PNAME is zero just return DEFVAL, do not call error. */
|
If PNAME is zero just return DEFVAL, do not call error. */
|
|
|
int
|
int
|
read_integral_parameter (const char *p, const char *pname, const int defval)
|
read_integral_parameter (const char *p, const char *pname, const int defval)
|
{
|
{
|
const char *endp = p;
|
const char *endp = p;
|
|
|
while (*endp)
|
while (*endp)
|
{
|
{
|
if (ISDIGIT (*endp))
|
if (ISDIGIT (*endp))
|
endp++;
|
endp++;
|
else
|
else
|
break;
|
break;
|
}
|
}
|
|
|
if (*endp != 0)
|
if (*endp != 0)
|
{
|
{
|
if (pname != 0)
|
if (pname != 0)
|
error ("invalid option argument %qs", pname);
|
error ("invalid option argument %qs", pname);
|
return defval;
|
return defval;
|
}
|
}
|
|
|
return atoi (p);
|
return atoi (p);
|
}
|
}
|
|
|
/* When compiling with a recent enough GCC, we use the GNU C "extern inline"
|
/* When compiling with a recent enough GCC, we use the GNU C "extern inline"
|
for floor_log2 and exact_log2; see toplev.h. That construct, however,
|
for floor_log2 and exact_log2; see toplev.h. That construct, however,
|
conflicts with the ISO C++ One Definition Rule. */
|
conflicts with the ISO C++ One Definition Rule. */
|
|
|
#if GCC_VERSION < 3004 || !defined (__cplusplus)
|
#if GCC_VERSION < 3004 || !defined (__cplusplus)
|
|
|
/* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
|
/* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
|
If X is 0, return -1. */
|
If X is 0, return -1. */
|
|
|
int
|
int
|
floor_log2 (unsigned HOST_WIDE_INT x)
|
floor_log2 (unsigned HOST_WIDE_INT x)
|
{
|
{
|
int t = 0;
|
int t = 0;
|
|
|
if (x == 0)
|
if (x == 0)
|
return -1;
|
return -1;
|
|
|
#ifdef CLZ_HWI
|
#ifdef CLZ_HWI
|
t = HOST_BITS_PER_WIDE_INT - 1 - (int) CLZ_HWI (x);
|
t = HOST_BITS_PER_WIDE_INT - 1 - (int) CLZ_HWI (x);
|
#else
|
#else
|
if (HOST_BITS_PER_WIDE_INT > 64)
|
if (HOST_BITS_PER_WIDE_INT > 64)
|
if (x >= (unsigned HOST_WIDE_INT) 1 << (t + 64))
|
if (x >= (unsigned HOST_WIDE_INT) 1 << (t + 64))
|
t += 64;
|
t += 64;
|
if (HOST_BITS_PER_WIDE_INT > 32)
|
if (HOST_BITS_PER_WIDE_INT > 32)
|
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 32))
|
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 32))
|
t += 32;
|
t += 32;
|
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 16))
|
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 16))
|
t += 16;
|
t += 16;
|
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 8))
|
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 8))
|
t += 8;
|
t += 8;
|
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 4))
|
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 4))
|
t += 4;
|
t += 4;
|
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 2))
|
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 2))
|
t += 2;
|
t += 2;
|
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 1))
|
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 1))
|
t += 1;
|
t += 1;
|
#endif
|
#endif
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Return the logarithm of X, base 2, considering X unsigned,
|
/* Return the logarithm of X, base 2, considering X unsigned,
|
if X is a power of 2. Otherwise, returns -1. */
|
if X is a power of 2. Otherwise, returns -1. */
|
|
|
int
|
int
|
exact_log2 (unsigned HOST_WIDE_INT x)
|
exact_log2 (unsigned HOST_WIDE_INT x)
|
{
|
{
|
if (x != (x & -x))
|
if (x != (x & -x))
|
return -1;
|
return -1;
|
#ifdef CTZ_HWI
|
#ifdef CTZ_HWI
|
return x ? CTZ_HWI (x) : -1;
|
return x ? CTZ_HWI (x) : -1;
|
#else
|
#else
|
return floor_log2 (x);
|
return floor_log2 (x);
|
#endif
|
#endif
|
}
|
}
|
|
|
#endif /* GCC_VERSION < 3004 || !defined (__cplusplus) */
|
#endif /* GCC_VERSION < 3004 || !defined (__cplusplus) */
|
|
|
/* Handler for fatal signals, such as SIGSEGV. These are transformed
|
/* Handler for fatal signals, such as SIGSEGV. These are transformed
|
into ICE messages, which is much more user friendly. In case the
|
into ICE messages, which is much more user friendly. In case the
|
error printer crashes, reset the signal to prevent infinite recursion. */
|
error printer crashes, reset the signal to prevent infinite recursion. */
|
|
|
static void
|
static void
|
crash_signal (int signo)
|
crash_signal (int signo)
|
{
|
{
|
signal (signo, SIG_DFL);
|
signal (signo, SIG_DFL);
|
|
|
/* If we crashed while processing an ASM statement, then be a little more
|
/* If we crashed while processing an ASM statement, then be a little more
|
graceful. It's most likely the user's fault. */
|
graceful. It's most likely the user's fault. */
|
if (this_is_asm_operands)
|
if (this_is_asm_operands)
|
{
|
{
|
output_operand_lossage ("unrecoverable error");
|
output_operand_lossage ("unrecoverable error");
|
exit (FATAL_EXIT_CODE);
|
exit (FATAL_EXIT_CODE);
|
}
|
}
|
|
|
internal_error ("%s", strsignal (signo));
|
internal_error ("%s", strsignal (signo));
|
}
|
}
|
|
|
/* Arrange to dump core on error. (The regular error message is still
|
/* Arrange to dump core on error. (The regular error message is still
|
printed first, except in the case of abort().) */
|
printed first, except in the case of abort().) */
|
|
|
static void
|
static void
|
setup_core_dumping (void)
|
setup_core_dumping (void)
|
{
|
{
|
#ifdef SIGABRT
|
#ifdef SIGABRT
|
signal (SIGABRT, SIG_DFL);
|
signal (SIGABRT, SIG_DFL);
|
#endif
|
#endif
|
#if defined(HAVE_SETRLIMIT)
|
#if defined(HAVE_SETRLIMIT)
|
{
|
{
|
struct rlimit rlim;
|
struct rlimit rlim;
|
if (getrlimit (RLIMIT_CORE, &rlim) != 0)
|
if (getrlimit (RLIMIT_CORE, &rlim) != 0)
|
fatal_error ("getting core file size maximum limit: %m");
|
fatal_error ("getting core file size maximum limit: %m");
|
rlim.rlim_cur = rlim.rlim_max;
|
rlim.rlim_cur = rlim.rlim_max;
|
if (setrlimit (RLIMIT_CORE, &rlim) != 0)
|
if (setrlimit (RLIMIT_CORE, &rlim) != 0)
|
fatal_error ("setting core file size limit to maximum: %m");
|
fatal_error ("setting core file size limit to maximum: %m");
|
}
|
}
|
#endif
|
#endif
|
diagnostic_abort_on_error (global_dc);
|
diagnostic_abort_on_error (global_dc);
|
}
|
}
|
|
|
|
|
/* Strip off a legitimate source ending from the input string NAME of
|
/* Strip off a legitimate source ending from the input string NAME of
|
length LEN. Rather than having to know the names used by all of
|
length LEN. Rather than having to know the names used by all of
|
our front ends, we strip off an ending of a period followed by
|
our front ends, we strip off an ending of a period followed by
|
up to five characters. (Java uses ".class".) */
|
up to five characters. (Java uses ".class".) */
|
|
|
void
|
void
|
strip_off_ending (char *name, int len)
|
strip_off_ending (char *name, int len)
|
{
|
{
|
int i;
|
int i;
|
for (i = 2; i < 6 && len > i; i++)
|
for (i = 2; i < 6 && len > i; i++)
|
{
|
{
|
if (name[len - i] == '.')
|
if (name[len - i] == '.')
|
{
|
{
|
name[len - i] = '\0';
|
name[len - i] = '\0';
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Output a quoted string. */
|
/* Output a quoted string. */
|
|
|
void
|
void
|
output_quoted_string (FILE *asm_file, const char *string)
|
output_quoted_string (FILE *asm_file, const char *string)
|
{
|
{
|
#ifdef OUTPUT_QUOTED_STRING
|
#ifdef OUTPUT_QUOTED_STRING
|
OUTPUT_QUOTED_STRING (asm_file, string);
|
OUTPUT_QUOTED_STRING (asm_file, string);
|
#else
|
#else
|
char c;
|
char c;
|
|
|
putc ('\"', asm_file);
|
putc ('\"', asm_file);
|
while ((c = *string++) != 0)
|
while ((c = *string++) != 0)
|
{
|
{
|
if (ISPRINT (c))
|
if (ISPRINT (c))
|
{
|
{
|
if (c == '\"' || c == '\\')
|
if (c == '\"' || c == '\\')
|
putc ('\\', asm_file);
|
putc ('\\', asm_file);
|
putc (c, asm_file);
|
putc (c, asm_file);
|
}
|
}
|
else
|
else
|
fprintf (asm_file, "\\%03o", (unsigned char) c);
|
fprintf (asm_file, "\\%03o", (unsigned char) c);
|
}
|
}
|
putc ('\"', asm_file);
|
putc ('\"', asm_file);
|
#endif
|
#endif
|
}
|
}
|
|
|
/* Output a file name in the form wanted by System V. */
|
/* Output a file name in the form wanted by System V. */
|
|
|
void
|
void
|
output_file_directive (FILE *asm_file, const char *input_name)
|
output_file_directive (FILE *asm_file, const char *input_name)
|
{
|
{
|
int len;
|
int len;
|
const char *na;
|
const char *na;
|
|
|
if (input_name == NULL)
|
if (input_name == NULL)
|
input_name = "<stdin>";
|
input_name = "<stdin>";
|
|
|
len = strlen (input_name);
|
len = strlen (input_name);
|
na = input_name + len;
|
na = input_name + len;
|
|
|
/* NA gets INPUT_NAME sans directory names. */
|
/* NA gets INPUT_NAME sans directory names. */
|
while (na > input_name)
|
while (na > input_name)
|
{
|
{
|
if (IS_DIR_SEPARATOR (na[-1]))
|
if (IS_DIR_SEPARATOR (na[-1]))
|
break;
|
break;
|
na--;
|
na--;
|
}
|
}
|
|
|
#ifdef ASM_OUTPUT_SOURCE_FILENAME
|
#ifdef ASM_OUTPUT_SOURCE_FILENAME
|
ASM_OUTPUT_SOURCE_FILENAME (asm_file, na);
|
ASM_OUTPUT_SOURCE_FILENAME (asm_file, na);
|
#else
|
#else
|
fprintf (asm_file, "\t.file\t");
|
fprintf (asm_file, "\t.file\t");
|
output_quoted_string (asm_file, na);
|
output_quoted_string (asm_file, na);
|
fputc ('\n', asm_file);
|
fputc ('\n', asm_file);
|
#endif
|
#endif
|
}
|
}
|
|
|
/* A subroutine of wrapup_global_declarations. We've come to the end of
|
/* A subroutine of wrapup_global_declarations. We've come to the end of
|
the compilation unit. All deferred variables should be undeferred,
|
the compilation unit. All deferred variables should be undeferred,
|
and all incomplete decls should be finalized. */
|
and all incomplete decls should be finalized. */
|
|
|
void
|
void
|
wrapup_global_declaration_1 (tree decl)
|
wrapup_global_declaration_1 (tree decl)
|
{
|
{
|
/* We're not deferring this any longer. Assignment is conditional to
|
/* We're not deferring this any longer. Assignment is conditional to
|
avoid needlessly dirtying PCH pages. */
|
avoid needlessly dirtying PCH pages. */
|
if (CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_WITH_VIS)
|
if (CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_WITH_VIS)
|
&& DECL_DEFER_OUTPUT (decl) != 0)
|
&& DECL_DEFER_OUTPUT (decl) != 0)
|
DECL_DEFER_OUTPUT (decl) = 0;
|
DECL_DEFER_OUTPUT (decl) = 0;
|
|
|
if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0)
|
if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0)
|
lang_hooks.finish_incomplete_decl (decl);
|
lang_hooks.finish_incomplete_decl (decl);
|
}
|
}
|
|
|
/* A subroutine of wrapup_global_declarations. Decide whether or not DECL
|
/* A subroutine of wrapup_global_declarations. Decide whether or not DECL
|
needs to be output. Return true if it is output. */
|
needs to be output. Return true if it is output. */
|
|
|
bool
|
bool
|
wrapup_global_declaration_2 (tree decl)
|
wrapup_global_declaration_2 (tree decl)
|
{
|
{
|
if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl))
|
if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl))
|
return false;
|
return false;
|
|
|
/* Don't write out static consts, unless we still need them.
|
/* Don't write out static consts, unless we still need them.
|
|
|
We also keep static consts if not optimizing (for debugging),
|
We also keep static consts if not optimizing (for debugging),
|
unless the user specified -fno-keep-static-consts.
|
unless the user specified -fno-keep-static-consts.
|
??? They might be better written into the debug information.
|
??? They might be better written into the debug information.
|
This is possible when using DWARF.
|
This is possible when using DWARF.
|
|
|
A language processor that wants static constants to be always
|
A language processor that wants static constants to be always
|
written out (even if it is not used) is responsible for
|
written out (even if it is not used) is responsible for
|
calling rest_of_decl_compilation itself. E.g. the C front-end
|
calling rest_of_decl_compilation itself. E.g. the C front-end
|
calls rest_of_decl_compilation from finish_decl.
|
calls rest_of_decl_compilation from finish_decl.
|
One motivation for this is that is conventional in some
|
One motivation for this is that is conventional in some
|
environments to write things like:
|
environments to write things like:
|
static const char rcsid[] = "... version string ...";
|
static const char rcsid[] = "... version string ...";
|
intending to force the string to be in the executable.
|
intending to force the string to be in the executable.
|
|
|
A language processor that would prefer to have unneeded
|
A language processor that would prefer to have unneeded
|
static constants "optimized away" would just defer writing
|
static constants "optimized away" would just defer writing
|
them out until here. E.g. C++ does this, because static
|
them out until here. E.g. C++ does this, because static
|
constants are often defined in header files.
|
constants are often defined in header files.
|
|
|
??? A tempting alternative (for both C and C++) would be
|
??? A tempting alternative (for both C and C++) would be
|
to force a constant to be written if and only if it is
|
to force a constant to be written if and only if it is
|
defined in a main file, as opposed to an include file. */
|
defined in a main file, as opposed to an include file. */
|
|
|
if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
|
if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
|
{
|
{
|
struct cgraph_varpool_node *node;
|
struct cgraph_varpool_node *node;
|
bool needed = true;
|
bool needed = true;
|
node = cgraph_varpool_node (decl);
|
node = cgraph_varpool_node (decl);
|
|
|
if (node->finalized)
|
if (node->finalized)
|
needed = false;
|
needed = false;
|
else if (node->alias)
|
else if (node->alias)
|
needed = false;
|
needed = false;
|
else if (!cgraph_global_info_ready
|
else if (!cgraph_global_info_ready
|
&& (TREE_USED (decl)
|
&& (TREE_USED (decl)
|
|| TREE_USED (DECL_ASSEMBLER_NAME (decl))))
|
|| TREE_USED (DECL_ASSEMBLER_NAME (decl))))
|
/* needed */;
|
/* needed */;
|
else if (node->needed)
|
else if (node->needed)
|
/* needed */;
|
/* needed */;
|
else if (DECL_COMDAT (decl))
|
else if (DECL_COMDAT (decl))
|
needed = false;
|
needed = false;
|
else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl)
|
else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl)
|
&& (optimize || !flag_keep_static_consts
|
&& (optimize || !flag_keep_static_consts
|
|| DECL_ARTIFICIAL (decl)))
|
|| DECL_ARTIFICIAL (decl)))
|
needed = false;
|
needed = false;
|
|
|
if (needed)
|
if (needed)
|
{
|
{
|
rest_of_decl_compilation (decl, 1, 1);
|
rest_of_decl_compilation (decl, 1, 1);
|
return true;
|
return true;
|
}
|
}
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Do any final processing required for the declarations in VEC, of
|
/* Do any final processing required for the declarations in VEC, of
|
which there are LEN. We write out inline functions and variables
|
which there are LEN. We write out inline functions and variables
|
that have been deferred until this point, but which are required.
|
that have been deferred until this point, but which are required.
|
Returns nonzero if anything was put out. */
|
Returns nonzero if anything was put out. */
|
|
|
bool
|
bool
|
wrapup_global_declarations (tree *vec, int len)
|
wrapup_global_declarations (tree *vec, int len)
|
{
|
{
|
bool reconsider, output_something = false;
|
bool reconsider, output_something = false;
|
int i;
|
int i;
|
|
|
for (i = 0; i < len; i++)
|
for (i = 0; i < len; i++)
|
wrapup_global_declaration_1 (vec[i]);
|
wrapup_global_declaration_1 (vec[i]);
|
|
|
/* Now emit any global variables or functions that we have been
|
/* Now emit any global variables or functions that we have been
|
putting off. We need to loop in case one of the things emitted
|
putting off. We need to loop in case one of the things emitted
|
here references another one which comes earlier in the list. */
|
here references another one which comes earlier in the list. */
|
do
|
do
|
{
|
{
|
reconsider = false;
|
reconsider = false;
|
for (i = 0; i < len; i++)
|
for (i = 0; i < len; i++)
|
reconsider |= wrapup_global_declaration_2 (vec[i]);
|
reconsider |= wrapup_global_declaration_2 (vec[i]);
|
if (reconsider)
|
if (reconsider)
|
output_something = true;
|
output_something = true;
|
}
|
}
|
while (reconsider);
|
while (reconsider);
|
|
|
return output_something;
|
return output_something;
|
}
|
}
|
|
|
/* A subroutine of check_global_declarations. Issue appropriate warnings
|
/* A subroutine of check_global_declarations. Issue appropriate warnings
|
for the global declaration DECL. */
|
for the global declaration DECL. */
|
|
|
void
|
void
|
check_global_declaration_1 (tree decl)
|
check_global_declaration_1 (tree decl)
|
{
|
{
|
/* Warn about any function declared static but not defined. We don't
|
/* Warn about any function declared static but not defined. We don't
|
warn about variables, because many programs have static variables
|
warn about variables, because many programs have static variables
|
that exist only to get some text into the object file. */
|
that exist only to get some text into the object file. */
|
if (TREE_CODE (decl) == FUNCTION_DECL
|
if (TREE_CODE (decl) == FUNCTION_DECL
|
&& DECL_INITIAL (decl) == 0
|
&& DECL_INITIAL (decl) == 0
|
&& DECL_EXTERNAL (decl)
|
&& DECL_EXTERNAL (decl)
|
&& ! DECL_ARTIFICIAL (decl)
|
&& ! DECL_ARTIFICIAL (decl)
|
&& ! TREE_NO_WARNING (decl)
|
&& ! TREE_NO_WARNING (decl)
|
&& ! TREE_PUBLIC (decl)
|
&& ! TREE_PUBLIC (decl)
|
&& (warn_unused_function
|
&& (warn_unused_function
|
|| TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
|
|| TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
|
{
|
{
|
if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
|
if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
|
pedwarn ("%q+F used but never defined", decl);
|
pedwarn ("%q+F used but never defined", decl);
|
else
|
else
|
warning (0, "%q+F declared %<static%> but never defined", decl);
|
warning (0, "%q+F declared %<static%> but never defined", decl);
|
/* This symbol is effectively an "extern" declaration now. */
|
/* This symbol is effectively an "extern" declaration now. */
|
TREE_PUBLIC (decl) = 1;
|
TREE_PUBLIC (decl) = 1;
|
assemble_external (decl);
|
assemble_external (decl);
|
}
|
}
|
|
|
/* Warn about static fns or vars defined but not used. */
|
/* Warn about static fns or vars defined but not used. */
|
if (((warn_unused_function && TREE_CODE (decl) == FUNCTION_DECL)
|
if (((warn_unused_function && TREE_CODE (decl) == FUNCTION_DECL)
|
/* We don't warn about "static const" variables because the
|
/* We don't warn about "static const" variables because the
|
"rcs_id" idiom uses that construction. */
|
"rcs_id" idiom uses that construction. */
|
|| (warn_unused_variable
|
|| (warn_unused_variable
|
&& TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
|
&& TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
|
&& ! DECL_IN_SYSTEM_HEADER (decl)
|
&& ! DECL_IN_SYSTEM_HEADER (decl)
|
&& ! TREE_USED (decl)
|
&& ! TREE_USED (decl)
|
/* The TREE_USED bit for file-scope decls is kept in the identifier,
|
/* The TREE_USED bit for file-scope decls is kept in the identifier,
|
to handle multiple external decls in different scopes. */
|
to handle multiple external decls in different scopes. */
|
&& ! (DECL_NAME (decl) && TREE_USED (DECL_NAME (decl)))
|
&& ! (DECL_NAME (decl) && TREE_USED (DECL_NAME (decl)))
|
&& ! DECL_EXTERNAL (decl)
|
&& ! DECL_EXTERNAL (decl)
|
&& ! TREE_PUBLIC (decl)
|
&& ! TREE_PUBLIC (decl)
|
/* A volatile variable might be used in some non-obvious way. */
|
/* A volatile variable might be used in some non-obvious way. */
|
&& ! TREE_THIS_VOLATILE (decl)
|
&& ! TREE_THIS_VOLATILE (decl)
|
/* Global register variables must be declared to reserve them. */
|
/* Global register variables must be declared to reserve them. */
|
&& ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
|
&& ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
|
/* Otherwise, ask the language. */
|
/* Otherwise, ask the language. */
|
&& lang_hooks.decls.warn_unused_global (decl))
|
&& lang_hooks.decls.warn_unused_global (decl))
|
warning (0, "%q+D defined but not used", decl);
|
warning (0, "%q+D defined but not used", decl);
|
}
|
}
|
|
|
/* Issue appropriate warnings for the global declarations in VEC (of
|
/* Issue appropriate warnings for the global declarations in VEC (of
|
which there are LEN). */
|
which there are LEN). */
|
|
|
void
|
void
|
check_global_declarations (tree *vec, int len)
|
check_global_declarations (tree *vec, int len)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < len; i++)
|
for (i = 0; i < len; i++)
|
check_global_declaration_1 (vec[i]);
|
check_global_declaration_1 (vec[i]);
|
}
|
}
|
|
|
/* Emit debugging information for all global declarations in VEC. */
|
/* Emit debugging information for all global declarations in VEC. */
|
|
|
void
|
void
|
emit_debug_global_declarations (tree *vec, int len)
|
emit_debug_global_declarations (tree *vec, int len)
|
{
|
{
|
int i;
|
int i;
|
|
|
/* Avoid confusing the debug information machinery when there are errors. */
|
/* Avoid confusing the debug information machinery when there are errors. */
|
if (errorcount != 0 || sorrycount != 0)
|
if (errorcount != 0 || sorrycount != 0)
|
return;
|
return;
|
|
|
timevar_push (TV_SYMOUT);
|
timevar_push (TV_SYMOUT);
|
for (i = 0; i < len; i++)
|
for (i = 0; i < len; i++)
|
debug_hooks->global_decl (vec[i]);
|
debug_hooks->global_decl (vec[i]);
|
timevar_pop (TV_SYMOUT);
|
timevar_pop (TV_SYMOUT);
|
}
|
}
|
|
|
/* Warn about a use of an identifier which was marked deprecated. */
|
/* Warn about a use of an identifier which was marked deprecated. */
|
void
|
void
|
warn_deprecated_use (tree node)
|
warn_deprecated_use (tree node)
|
{
|
{
|
if (node == 0 || !warn_deprecated_decl)
|
if (node == 0 || !warn_deprecated_decl)
|
return;
|
return;
|
|
|
if (DECL_P (node))
|
if (DECL_P (node))
|
{
|
{
|
expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (node));
|
expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (node));
|
warning (OPT_Wdeprecated_declarations,
|
warning (OPT_Wdeprecated_declarations,
|
"%qs is deprecated (declared at %s:%d)",
|
"%qs is deprecated (declared at %s:%d)",
|
IDENTIFIER_POINTER (DECL_NAME (node)),
|
IDENTIFIER_POINTER (DECL_NAME (node)),
|
xloc.file, xloc.line);
|
xloc.file, xloc.line);
|
}
|
}
|
else if (TYPE_P (node))
|
else if (TYPE_P (node))
|
{
|
{
|
const char *what = NULL;
|
const char *what = NULL;
|
tree decl = TYPE_STUB_DECL (node);
|
tree decl = TYPE_STUB_DECL (node);
|
|
|
if (TYPE_NAME (node))
|
if (TYPE_NAME (node))
|
{
|
{
|
if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
|
if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
|
what = IDENTIFIER_POINTER (TYPE_NAME (node));
|
what = IDENTIFIER_POINTER (TYPE_NAME (node));
|
else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
|
else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
|
&& DECL_NAME (TYPE_NAME (node)))
|
&& DECL_NAME (TYPE_NAME (node)))
|
what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)));
|
what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)));
|
}
|
}
|
|
|
if (decl)
|
if (decl)
|
{
|
{
|
expanded_location xloc
|
expanded_location xloc
|
= expand_location (DECL_SOURCE_LOCATION (decl));
|
= expand_location (DECL_SOURCE_LOCATION (decl));
|
if (what)
|
if (what)
|
warning (OPT_Wdeprecated_declarations,
|
warning (OPT_Wdeprecated_declarations,
|
"%qs is deprecated (declared at %s:%d)", what,
|
"%qs is deprecated (declared at %s:%d)", what,
|
xloc.file, xloc.line);
|
xloc.file, xloc.line);
|
else
|
else
|
warning (OPT_Wdeprecated_declarations,
|
warning (OPT_Wdeprecated_declarations,
|
"type is deprecated (declared at %s:%d)",
|
"type is deprecated (declared at %s:%d)",
|
xloc.file, xloc.line);
|
xloc.file, xloc.line);
|
}
|
}
|
else
|
else
|
{
|
{
|
if (what)
|
if (what)
|
warning (OPT_Wdeprecated_declarations, "%qs is deprecated", what);
|
warning (OPT_Wdeprecated_declarations, "%qs is deprecated", what);
|
else
|
else
|
warning (OPT_Wdeprecated_declarations, "type is deprecated");
|
warning (OPT_Wdeprecated_declarations, "type is deprecated");
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Save the current INPUT_LOCATION on the top entry in the
|
/* Save the current INPUT_LOCATION on the top entry in the
|
INPUT_FILE_STACK. Push a new entry for FILE and LINE, and set the
|
INPUT_FILE_STACK. Push a new entry for FILE and LINE, and set the
|
INPUT_LOCATION accordingly. */
|
INPUT_LOCATION accordingly. */
|
|
|
void
|
void
|
#ifdef USE_MAPPED_LOCATION
|
#ifdef USE_MAPPED_LOCATION
|
push_srcloc (location_t fline)
|
push_srcloc (location_t fline)
|
#else
|
#else
|
push_srcloc (const char *file, int line)
|
push_srcloc (const char *file, int line)
|
#endif
|
#endif
|
{
|
{
|
struct file_stack *fs;
|
struct file_stack *fs;
|
|
|
gcc_assert (!input_file_stack_restored);
|
gcc_assert (!input_file_stack_restored);
|
if (input_file_stack_tick == (int) ((1U << INPUT_FILE_STACK_BITS) - 1))
|
if (input_file_stack_tick == (int) ((1U << INPUT_FILE_STACK_BITS) - 1))
|
sorry ("GCC supports only %d input file changes", input_file_stack_tick);
|
sorry ("GCC supports only %d input file changes", input_file_stack_tick);
|
|
|
fs = XNEW (struct file_stack);
|
fs = XNEW (struct file_stack);
|
fs->location = input_location;
|
fs->location = input_location;
|
fs->next = input_file_stack;
|
fs->next = input_file_stack;
|
#ifdef USE_MAPPED_LOCATION
|
#ifdef USE_MAPPED_LOCATION
|
input_location = fline;
|
input_location = fline;
|
#else
|
#else
|
input_filename = file;
|
input_filename = file;
|
input_line = line;
|
input_line = line;
|
#endif
|
#endif
|
input_file_stack = fs;
|
input_file_stack = fs;
|
input_file_stack_tick++;
|
input_file_stack_tick++;
|
VEC_safe_push (fs_p, heap, input_file_stack_history, input_file_stack);
|
VEC_safe_push (fs_p, heap, input_file_stack_history, input_file_stack);
|
}
|
}
|
|
|
/* Pop the top entry off the stack of presently open source files.
|
/* Pop the top entry off the stack of presently open source files.
|
Restore the INPUT_LOCATION from the new topmost entry on the
|
Restore the INPUT_LOCATION from the new topmost entry on the
|
stack. */
|
stack. */
|
|
|
void
|
void
|
pop_srcloc (void)
|
pop_srcloc (void)
|
{
|
{
|
struct file_stack *fs;
|
struct file_stack *fs;
|
|
|
gcc_assert (!input_file_stack_restored);
|
gcc_assert (!input_file_stack_restored);
|
if (input_file_stack_tick == (int) ((1U << INPUT_FILE_STACK_BITS) - 1))
|
if (input_file_stack_tick == (int) ((1U << INPUT_FILE_STACK_BITS) - 1))
|
sorry ("GCC supports only %d input file changes", input_file_stack_tick);
|
sorry ("GCC supports only %d input file changes", input_file_stack_tick);
|
|
|
fs = input_file_stack;
|
fs = input_file_stack;
|
input_location = fs->location;
|
input_location = fs->location;
|
input_file_stack = fs->next;
|
input_file_stack = fs->next;
|
input_file_stack_tick++;
|
input_file_stack_tick++;
|
VEC_safe_push (fs_p, heap, input_file_stack_history, input_file_stack);
|
VEC_safe_push (fs_p, heap, input_file_stack_history, input_file_stack);
|
}
|
}
|
|
|
/* Restore the input file stack to its state as of TICK, for the sake
|
/* Restore the input file stack to its state as of TICK, for the sake
|
of diagnostics after processing the whole input. Once this has
|
of diagnostics after processing the whole input. Once this has
|
been called, push_srcloc and pop_srcloc may no longer be
|
been called, push_srcloc and pop_srcloc may no longer be
|
called. */
|
called. */
|
void
|
void
|
restore_input_file_stack (int tick)
|
restore_input_file_stack (int tick)
|
{
|
{
|
if (tick == 0)
|
if (tick == 0)
|
input_file_stack = NULL;
|
input_file_stack = NULL;
|
else
|
else
|
input_file_stack = VEC_index (fs_p, input_file_stack_history, tick - 1);
|
input_file_stack = VEC_index (fs_p, input_file_stack_history, tick - 1);
|
input_file_stack_tick = tick;
|
input_file_stack_tick = tick;
|
input_file_stack_restored = true;
|
input_file_stack_restored = true;
|
}
|
}
|
|
|
/* Compile an entire translation unit. Write a file of assembly
|
/* Compile an entire translation unit. Write a file of assembly
|
output and various debugging dumps. */
|
output and various debugging dumps. */
|
|
|
static void
|
static void
|
compile_file (void)
|
compile_file (void)
|
{
|
{
|
/* Initialize yet another pass. */
|
/* Initialize yet another pass. */
|
|
|
init_cgraph ();
|
init_cgraph ();
|
init_final (main_input_filename);
|
init_final (main_input_filename);
|
coverage_init (aux_base_name);
|
coverage_init (aux_base_name);
|
|
|
timevar_push (TV_PARSE);
|
timevar_push (TV_PARSE);
|
|
|
/* Call the parser, which parses the entire file (calling
|
/* Call the parser, which parses the entire file (calling
|
rest_of_compilation for each function). */
|
rest_of_compilation for each function). */
|
lang_hooks.parse_file (set_yydebug);
|
lang_hooks.parse_file (set_yydebug);
|
|
|
/* In case there were missing block closers,
|
/* In case there were missing block closers,
|
get us back to the global binding level. */
|
get us back to the global binding level. */
|
lang_hooks.clear_binding_stack ();
|
lang_hooks.clear_binding_stack ();
|
|
|
/* Compilation is now finished except for writing
|
/* Compilation is now finished except for writing
|
what's left of the symbol table output. */
|
what's left of the symbol table output. */
|
timevar_pop (TV_PARSE);
|
timevar_pop (TV_PARSE);
|
|
|
if (flag_syntax_only || errorcount || sorrycount)
|
if (flag_syntax_only || errorcount || sorrycount)
|
return;
|
return;
|
|
|
lang_hooks.decls.final_write_globals ();
|
lang_hooks.decls.final_write_globals ();
|
cgraph_varpool_assemble_pending_decls ();
|
cgraph_varpool_assemble_pending_decls ();
|
finish_aliases_2 ();
|
finish_aliases_2 ();
|
|
|
/* This must occur after the loop to output deferred functions.
|
/* This must occur after the loop to output deferred functions.
|
Else the coverage initializer would not be emitted if all the
|
Else the coverage initializer would not be emitted if all the
|
functions in this compilation unit were deferred. */
|
functions in this compilation unit were deferred. */
|
coverage_finish ();
|
coverage_finish ();
|
|
|
/* Likewise for mudflap static object registrations. */
|
/* Likewise for mudflap static object registrations. */
|
if (flag_mudflap)
|
if (flag_mudflap)
|
mudflap_finish_file ();
|
mudflap_finish_file ();
|
|
|
output_shared_constant_pool ();
|
output_shared_constant_pool ();
|
output_object_blocks ();
|
output_object_blocks ();
|
|
|
/* Write out any pending weak symbol declarations. */
|
/* Write out any pending weak symbol declarations. */
|
|
|
weak_finish ();
|
weak_finish ();
|
|
|
/* Do dbx symbols. */
|
/* Do dbx symbols. */
|
timevar_push (TV_SYMOUT);
|
timevar_push (TV_SYMOUT);
|
|
|
#if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
|
#if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
|
if (dwarf2out_do_frame ())
|
if (dwarf2out_do_frame ())
|
dwarf2out_frame_finish ();
|
dwarf2out_frame_finish ();
|
#endif
|
#endif
|
|
|
(*debug_hooks->finish) (main_input_filename);
|
(*debug_hooks->finish) (main_input_filename);
|
timevar_pop (TV_SYMOUT);
|
timevar_pop (TV_SYMOUT);
|
|
|
/* Output some stuff at end of file if nec. */
|
/* Output some stuff at end of file if nec. */
|
|
|
dw2_output_indirect_constants ();
|
dw2_output_indirect_constants ();
|
|
|
/* Flush any pending external directives. cgraph did this for
|
/* Flush any pending external directives. cgraph did this for
|
assemble_external calls from the front end, but the RTL
|
assemble_external calls from the front end, but the RTL
|
expander can also generate them. */
|
expander can also generate them. */
|
process_pending_assemble_externals ();
|
process_pending_assemble_externals ();
|
|
|
/* Attach a special .ident directive to the end of the file to identify
|
/* Attach a special .ident directive to the end of the file to identify
|
the version of GCC which compiled this code. The format of the .ident
|
the version of GCC which compiled this code. The format of the .ident
|
string is patterned after the ones produced by native SVR4 compilers. */
|
string is patterned after the ones produced by native SVR4 compilers. */
|
#ifdef IDENT_ASM_OP
|
#ifdef IDENT_ASM_OP
|
if (!flag_no_ident)
|
if (!flag_no_ident)
|
fprintf (asm_out_file, "%s\"GCC: (GNU) %s\"\n",
|
fprintf (asm_out_file, "%s\"GCC: (GNU) %s\"\n",
|
IDENT_ASM_OP, version_string);
|
IDENT_ASM_OP, version_string);
|
#endif
|
#endif
|
|
|
/* This must be at the end. Some target ports emit end of file directives
|
/* This must be at the end. Some target ports emit end of file directives
|
into the assembly file here, and hence we can not output anything to the
|
into the assembly file here, and hence we can not output anything to the
|
assembly file after this point. */
|
assembly file after this point. */
|
targetm.asm_out.file_end ();
|
targetm.asm_out.file_end ();
|
}
|
}
|
|
|
/* Parse a -d... command line switch. */
|
/* Parse a -d... command line switch. */
|
|
|
void
|
void
|
decode_d_option (const char *arg)
|
decode_d_option (const char *arg)
|
{
|
{
|
int c;
|
int c;
|
|
|
while (*arg)
|
while (*arg)
|
switch (c = *arg++)
|
switch (c = *arg++)
|
{
|
{
|
case 'A':
|
case 'A':
|
flag_debug_asm = 1;
|
flag_debug_asm = 1;
|
break;
|
break;
|
case 'p':
|
case 'p':
|
flag_print_asm_name = 1;
|
flag_print_asm_name = 1;
|
break;
|
break;
|
case 'P':
|
case 'P':
|
flag_dump_rtl_in_asm = 1;
|
flag_dump_rtl_in_asm = 1;
|
flag_print_asm_name = 1;
|
flag_print_asm_name = 1;
|
break;
|
break;
|
case 'v':
|
case 'v':
|
graph_dump_format = vcg;
|
graph_dump_format = vcg;
|
break;
|
break;
|
case 'x':
|
case 'x':
|
rtl_dump_and_exit = 1;
|
rtl_dump_and_exit = 1;
|
break;
|
break;
|
case 'y':
|
case 'y':
|
set_yydebug = 1;
|
set_yydebug = 1;
|
break;
|
break;
|
case 'D': /* These are handled by the preprocessor. */
|
case 'D': /* These are handled by the preprocessor. */
|
case 'I':
|
case 'I':
|
break;
|
break;
|
case 'H':
|
case 'H':
|
setup_core_dumping();
|
setup_core_dumping();
|
break;
|
break;
|
|
|
case 'a':
|
case 'a':
|
default:
|
default:
|
if (!enable_rtl_dump_file (c))
|
if (!enable_rtl_dump_file (c))
|
warning (0, "unrecognized gcc debugging option: %c", c);
|
warning (0, "unrecognized gcc debugging option: %c", c);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* Indexed by enum debug_info_type. */
|
/* Indexed by enum debug_info_type. */
|
const char *const debug_type_names[] =
|
const char *const debug_type_names[] =
|
{
|
{
|
"none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
|
"none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
|
};
|
};
|
|
|
/* Print version information to FILE.
|
/* Print version information to FILE.
|
Each line begins with INDENT (for the case where FILE is the
|
Each line begins with INDENT (for the case where FILE is the
|
assembler output file). */
|
assembler output file). */
|
|
|
void
|
void
|
print_version (FILE *file, const char *indent)
|
print_version (FILE *file, const char *indent)
|
{
|
{
|
static const char fmt1[] =
|
static const char fmt1[] =
|
#ifdef __GNUC__
|
#ifdef __GNUC__
|
N_("%s%s%s version %s (%s)\n%s\tcompiled by GNU C version %s.\n")
|
N_("%s%s%s version %s (%s)\n%s\tcompiled by GNU C version %s.\n")
|
#else
|
#else
|
N_("%s%s%s version %s (%s) compiled by CC.\n")
|
N_("%s%s%s version %s (%s) compiled by CC.\n")
|
#endif
|
#endif
|
;
|
;
|
static const char fmt2[] =
|
static const char fmt2[] =
|
N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n");
|
N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n");
|
#ifndef __VERSION__
|
#ifndef __VERSION__
|
#define __VERSION__ "[?]"
|
#define __VERSION__ "[?]"
|
#endif
|
#endif
|
fprintf (file,
|
fprintf (file,
|
file == stderr ? _(fmt1) : fmt1,
|
file == stderr ? _(fmt1) : fmt1,
|
indent, *indent != 0 ? " " : "",
|
indent, *indent != 0 ? " " : "",
|
lang_hooks.name, version_string, TARGET_NAME,
|
lang_hooks.name, version_string, TARGET_NAME,
|
indent, __VERSION__);
|
indent, __VERSION__);
|
fprintf (file,
|
fprintf (file,
|
file == stderr ? _(fmt2) : fmt2,
|
file == stderr ? _(fmt2) : fmt2,
|
indent, *indent != 0 ? " " : "",
|
indent, *indent != 0 ? " " : "",
|
PARAM_VALUE (GGC_MIN_EXPAND), PARAM_VALUE (GGC_MIN_HEAPSIZE));
|
PARAM_VALUE (GGC_MIN_EXPAND), PARAM_VALUE (GGC_MIN_HEAPSIZE));
|
}
|
}
|
|
|
/* Print an option value and return the adjusted position in the line.
|
/* Print an option value and return the adjusted position in the line.
|
??? We don't handle error returns from fprintf (disk full); presumably
|
??? We don't handle error returns from fprintf (disk full); presumably
|
other code will catch a disk full though. */
|
other code will catch a disk full though. */
|
|
|
static int
|
static int
|
print_single_switch (FILE *file, int pos, int max,
|
print_single_switch (FILE *file, int pos, int max,
|
const char *indent, const char *sep, const char *term,
|
const char *indent, const char *sep, const char *term,
|
const char *type, const char *name)
|
const char *type, const char *name)
|
{
|
{
|
/* The ultrix fprintf returns 0 on success, so compute the result we want
|
/* The ultrix fprintf returns 0 on success, so compute the result we want
|
here since we need it for the following test. */
|
here since we need it for the following test. */
|
int len = strlen (sep) + strlen (type) + strlen (name);
|
int len = strlen (sep) + strlen (type) + strlen (name);
|
|
|
if (pos != 0
|
if (pos != 0
|
&& pos + len > max)
|
&& pos + len > max)
|
{
|
{
|
fprintf (file, "%s", term);
|
fprintf (file, "%s", term);
|
pos = 0;
|
pos = 0;
|
}
|
}
|
if (pos == 0)
|
if (pos == 0)
|
{
|
{
|
fprintf (file, "%s", indent);
|
fprintf (file, "%s", indent);
|
pos = strlen (indent);
|
pos = strlen (indent);
|
}
|
}
|
fprintf (file, "%s%s%s", sep, type, name);
|
fprintf (file, "%s%s%s", sep, type, name);
|
pos += len;
|
pos += len;
|
return pos;
|
return pos;
|
}
|
}
|
|
|
/* Print active target switches to FILE.
|
/* Print active target switches to FILE.
|
POS is the current cursor position and MAX is the size of a "line".
|
POS is the current cursor position and MAX is the size of a "line".
|
Each line begins with INDENT and ends with TERM.
|
Each line begins with INDENT and ends with TERM.
|
Each switch is separated from the next by SEP. */
|
Each switch is separated from the next by SEP. */
|
|
|
static void
|
static void
|
print_switch_values (FILE *file, int pos, int max,
|
print_switch_values (FILE *file, int pos, int max,
|
const char *indent, const char *sep, const char *term)
|
const char *indent, const char *sep, const char *term)
|
{
|
{
|
size_t j;
|
size_t j;
|
const char **p;
|
const char **p;
|
|
|
/* Fill in the -frandom-seed option, if the user didn't pass it, so
|
/* Fill in the -frandom-seed option, if the user didn't pass it, so
|
that it can be printed below. This helps reproducibility. */
|
that it can be printed below. This helps reproducibility. */
|
randomize ();
|
randomize ();
|
|
|
/* Print the options as passed. */
|
/* Print the options as passed. */
|
pos = print_single_switch (file, pos, max, indent, *indent ? " " : "", term,
|
pos = print_single_switch (file, pos, max, indent, *indent ? " " : "", term,
|
_("options passed: "), "");
|
_("options passed: "), "");
|
|
|
for (p = &save_argv[1]; *p != NULL; p++)
|
for (p = &save_argv[1]; *p != NULL; p++)
|
if (**p == '-')
|
if (**p == '-')
|
{
|
{
|
/* Ignore these. */
|
/* Ignore these. */
|
if (strcmp (*p, "-o") == 0)
|
if (strcmp (*p, "-o") == 0)
|
{
|
{
|
if (p[1] != NULL)
|
if (p[1] != NULL)
|
p++;
|
p++;
|
continue;
|
continue;
|
}
|
}
|
if (strcmp (*p, "-quiet") == 0)
|
if (strcmp (*p, "-quiet") == 0)
|
continue;
|
continue;
|
if (strcmp (*p, "-version") == 0)
|
if (strcmp (*p, "-version") == 0)
|
continue;
|
continue;
|
if ((*p)[1] == 'd')
|
if ((*p)[1] == 'd')
|
continue;
|
continue;
|
|
|
pos = print_single_switch (file, pos, max, indent, sep, term, *p, "");
|
pos = print_single_switch (file, pos, max, indent, sep, term, *p, "");
|
}
|
}
|
if (pos > 0)
|
if (pos > 0)
|
fprintf (file, "%s", term);
|
fprintf (file, "%s", term);
|
|
|
/* Print the -f and -m options that have been enabled.
|
/* Print the -f and -m options that have been enabled.
|
We don't handle language specific options but printing argv
|
We don't handle language specific options but printing argv
|
should suffice. */
|
should suffice. */
|
|
|
pos = print_single_switch (file, 0, max, indent, *indent ? " " : "", term,
|
pos = print_single_switch (file, 0, max, indent, *indent ? " " : "", term,
|
_("options enabled: "), "");
|
_("options enabled: "), "");
|
|
|
for (j = 0; j < cl_options_count; j++)
|
for (j = 0; j < cl_options_count; j++)
|
if ((cl_options[j].flags & CL_REPORT)
|
if ((cl_options[j].flags & CL_REPORT)
|
&& option_enabled (j) > 0)
|
&& option_enabled (j) > 0)
|
pos = print_single_switch (file, pos, max, indent, sep, term,
|
pos = print_single_switch (file, pos, max, indent, sep, term,
|
"", cl_options[j].opt_text);
|
"", cl_options[j].opt_text);
|
|
|
fprintf (file, "%s", term);
|
fprintf (file, "%s", term);
|
}
|
}
|
|
|
/* Open assembly code output file. Do this even if -fsyntax-only is
|
/* Open assembly code output file. Do this even if -fsyntax-only is
|
on, because then the driver will have provided the name of a
|
on, because then the driver will have provided the name of a
|
temporary file or bit bucket for us. NAME is the file specified on
|
temporary file or bit bucket for us. NAME is the file specified on
|
the command line, possibly NULL. */
|
the command line, possibly NULL. */
|
static void
|
static void
|
init_asm_output (const char *name)
|
init_asm_output (const char *name)
|
{
|
{
|
if (name == NULL && asm_file_name == 0)
|
if (name == NULL && asm_file_name == 0)
|
asm_out_file = stdout;
|
asm_out_file = stdout;
|
else
|
else
|
{
|
{
|
if (asm_file_name == 0)
|
if (asm_file_name == 0)
|
{
|
{
|
int len = strlen (dump_base_name);
|
int len = strlen (dump_base_name);
|
char *dumpname = XNEWVEC (char, len + 6);
|
char *dumpname = XNEWVEC (char, len + 6);
|
memcpy (dumpname, dump_base_name, len + 1);
|
memcpy (dumpname, dump_base_name, len + 1);
|
strip_off_ending (dumpname, len);
|
strip_off_ending (dumpname, len);
|
strcat (dumpname, ".s");
|
strcat (dumpname, ".s");
|
asm_file_name = dumpname;
|
asm_file_name = dumpname;
|
}
|
}
|
if (!strcmp (asm_file_name, "-"))
|
if (!strcmp (asm_file_name, "-"))
|
asm_out_file = stdout;
|
asm_out_file = stdout;
|
else
|
else
|
asm_out_file = fopen (asm_file_name, "w+b");
|
asm_out_file = fopen (asm_file_name, "w+b");
|
if (asm_out_file == 0)
|
if (asm_out_file == 0)
|
fatal_error ("can%'t open %s for writing: %m", asm_file_name);
|
fatal_error ("can%'t open %s for writing: %m", asm_file_name);
|
}
|
}
|
|
|
if (!flag_syntax_only)
|
if (!flag_syntax_only)
|
{
|
{
|
targetm.asm_out.file_start ();
|
targetm.asm_out.file_start ();
|
|
|
#ifdef ASM_COMMENT_START
|
#ifdef ASM_COMMENT_START
|
if (flag_verbose_asm)
|
if (flag_verbose_asm)
|
{
|
{
|
/* Print the list of options in effect. */
|
/* Print the list of options in effect. */
|
print_version (asm_out_file, ASM_COMMENT_START);
|
print_version (asm_out_file, ASM_COMMENT_START);
|
print_switch_values (asm_out_file, 0, MAX_LINE,
|
print_switch_values (asm_out_file, 0, MAX_LINE,
|
ASM_COMMENT_START, " ", "\n");
|
ASM_COMMENT_START, " ", "\n");
|
/* Add a blank line here so it appears in assembler output but not
|
/* Add a blank line here so it appears in assembler output but not
|
screen output. */
|
screen output. */
|
fprintf (asm_out_file, "\n");
|
fprintf (asm_out_file, "\n");
|
}
|
}
|
#endif
|
#endif
|
}
|
}
|
}
|
}
|
|
|
/* Return true if the state of option OPTION should be stored in PCH files
|
/* Return true if the state of option OPTION should be stored in PCH files
|
and checked by default_pch_valid_p. Store the option's current state
|
and checked by default_pch_valid_p. Store the option's current state
|
in STATE if so. */
|
in STATE if so. */
|
|
|
static inline bool
|
static inline bool
|
option_affects_pch_p (int option, struct cl_option_state *state)
|
option_affects_pch_p (int option, struct cl_option_state *state)
|
{
|
{
|
if ((cl_options[option].flags & CL_TARGET) == 0)
|
if ((cl_options[option].flags & CL_TARGET) == 0)
|
return false;
|
return false;
|
if (cl_options[option].flag_var == &target_flags)
|
if (cl_options[option].flag_var == &target_flags)
|
if (targetm.check_pch_target_flags)
|
if (targetm.check_pch_target_flags)
|
return false;
|
return false;
|
return get_option_state (option, state);
|
return get_option_state (option, state);
|
}
|
}
|
|
|
/* Default version of get_pch_validity.
|
/* Default version of get_pch_validity.
|
By default, every flag difference is fatal; that will be mostly right for
|
By default, every flag difference is fatal; that will be mostly right for
|
most targets, but completely right for very few. */
|
most targets, but completely right for very few. */
|
|
|
void *
|
void *
|
default_get_pch_validity (size_t *len)
|
default_get_pch_validity (size_t *len)
|
{
|
{
|
struct cl_option_state state;
|
struct cl_option_state state;
|
size_t i;
|
size_t i;
|
char *result, *r;
|
char *result, *r;
|
|
|
*len = 2;
|
*len = 2;
|
if (targetm.check_pch_target_flags)
|
if (targetm.check_pch_target_flags)
|
*len += sizeof (target_flags);
|
*len += sizeof (target_flags);
|
for (i = 0; i < cl_options_count; i++)
|
for (i = 0; i < cl_options_count; i++)
|
if (option_affects_pch_p (i, &state))
|
if (option_affects_pch_p (i, &state))
|
*len += state.size;
|
*len += state.size;
|
|
|
result = r = XNEWVEC (char, *len);
|
result = r = XNEWVEC (char, *len);
|
r[0] = flag_pic;
|
r[0] = flag_pic;
|
r[1] = flag_pie;
|
r[1] = flag_pie;
|
r += 2;
|
r += 2;
|
if (targetm.check_pch_target_flags)
|
if (targetm.check_pch_target_flags)
|
{
|
{
|
memcpy (r, &target_flags, sizeof (target_flags));
|
memcpy (r, &target_flags, sizeof (target_flags));
|
r += sizeof (target_flags);
|
r += sizeof (target_flags);
|
}
|
}
|
|
|
for (i = 0; i < cl_options_count; i++)
|
for (i = 0; i < cl_options_count; i++)
|
if (option_affects_pch_p (i, &state))
|
if (option_affects_pch_p (i, &state))
|
{
|
{
|
memcpy (r, state.data, state.size);
|
memcpy (r, state.data, state.size);
|
r += state.size;
|
r += state.size;
|
}
|
}
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Return a message which says that a PCH file was created with a different
|
/* Return a message which says that a PCH file was created with a different
|
setting of OPTION. */
|
setting of OPTION. */
|
|
|
static const char *
|
static const char *
|
pch_option_mismatch (const char *option)
|
pch_option_mismatch (const char *option)
|
{
|
{
|
char *r;
|
char *r;
|
|
|
asprintf (&r, _("created and used with differing settings of '%s'"), option);
|
asprintf (&r, _("created and used with differing settings of '%s'"), option);
|
if (r == NULL)
|
if (r == NULL)
|
return _("out of memory");
|
return _("out of memory");
|
return r;
|
return r;
|
}
|
}
|
|
|
/* Default version of pch_valid_p. */
|
/* Default version of pch_valid_p. */
|
|
|
const char *
|
const char *
|
default_pch_valid_p (const void *data_p, size_t len)
|
default_pch_valid_p (const void *data_p, size_t len)
|
{
|
{
|
struct cl_option_state state;
|
struct cl_option_state state;
|
const char *data = (const char *)data_p;
|
const char *data = (const char *)data_p;
|
size_t i;
|
size_t i;
|
|
|
/* -fpic and -fpie also usually make a PCH invalid. */
|
/* -fpic and -fpie also usually make a PCH invalid. */
|
if (data[0] != flag_pic)
|
if (data[0] != flag_pic)
|
return _("created and used with different settings of -fpic");
|
return _("created and used with different settings of -fpic");
|
if (data[1] != flag_pie)
|
if (data[1] != flag_pie)
|
return _("created and used with different settings of -fpie");
|
return _("created and used with different settings of -fpie");
|
data += 2;
|
data += 2;
|
|
|
/* Check target_flags. */
|
/* Check target_flags. */
|
if (targetm.check_pch_target_flags)
|
if (targetm.check_pch_target_flags)
|
{
|
{
|
int tf;
|
int tf;
|
const char *r;
|
const char *r;
|
|
|
memcpy (&tf, data, sizeof (target_flags));
|
memcpy (&tf, data, sizeof (target_flags));
|
data += sizeof (target_flags);
|
data += sizeof (target_flags);
|
len -= sizeof (target_flags);
|
len -= sizeof (target_flags);
|
r = targetm.check_pch_target_flags (tf);
|
r = targetm.check_pch_target_flags (tf);
|
if (r != NULL)
|
if (r != NULL)
|
return r;
|
return r;
|
}
|
}
|
|
|
for (i = 0; i < cl_options_count; i++)
|
for (i = 0; i < cl_options_count; i++)
|
if (option_affects_pch_p (i, &state))
|
if (option_affects_pch_p (i, &state))
|
{
|
{
|
if (memcmp (data, state.data, state.size) != 0)
|
if (memcmp (data, state.data, state.size) != 0)
|
return pch_option_mismatch (cl_options[i].opt_text);
|
return pch_option_mismatch (cl_options[i].opt_text);
|
data += state.size;
|
data += state.size;
|
len -= state.size;
|
len -= state.size;
|
}
|
}
|
|
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Default tree printer. Handles declarations only. */
|
/* Default tree printer. Handles declarations only. */
|
static bool
|
static bool
|
default_tree_printer (pretty_printer * pp, text_info *text, const char *spec,
|
default_tree_printer (pretty_printer * pp, text_info *text, const char *spec,
|
int precision, bool wide, bool set_locus, bool hash)
|
int precision, bool wide, bool set_locus, bool hash)
|
{
|
{
|
tree t;
|
tree t;
|
|
|
/* FUTURE: %+x should set the locus. */
|
/* FUTURE: %+x should set the locus. */
|
if (precision != 0 || wide || hash)
|
if (precision != 0 || wide || hash)
|
return false;
|
return false;
|
|
|
switch (*spec)
|
switch (*spec)
|
{
|
{
|
case 'D':
|
case 'D':
|
t = va_arg (*text->args_ptr, tree);
|
t = va_arg (*text->args_ptr, tree);
|
if (DECL_DEBUG_EXPR_IS_FROM (t) && DECL_DEBUG_EXPR (t))
|
if (DECL_DEBUG_EXPR_IS_FROM (t) && DECL_DEBUG_EXPR (t))
|
t = DECL_DEBUG_EXPR (t);
|
t = DECL_DEBUG_EXPR (t);
|
break;
|
break;
|
|
|
case 'F':
|
case 'F':
|
case 'T':
|
case 'T':
|
t = va_arg (*text->args_ptr, tree);
|
t = va_arg (*text->args_ptr, tree);
|
break;
|
break;
|
|
|
default:
|
default:
|
return false;
|
return false;
|
}
|
}
|
|
|
if (set_locus && text->locus)
|
if (set_locus && text->locus)
|
*text->locus = DECL_SOURCE_LOCATION (t);
|
*text->locus = DECL_SOURCE_LOCATION (t);
|
|
|
if (DECL_P (t))
|
if (DECL_P (t))
|
{
|
{
|
const char *n = DECL_NAME (t)
|
const char *n = DECL_NAME (t)
|
? lang_hooks.decl_printable_name (t, 2)
|
? lang_hooks.decl_printable_name (t, 2)
|
: "<anonymous>";
|
: "<anonymous>";
|
pp_string (pp, n);
|
pp_string (pp, n);
|
}
|
}
|
else
|
else
|
dump_generic_node (pp, t, 0, 0, 0);
|
dump_generic_node (pp, t, 0, 0, 0);
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Initialization of the front end environment, before command line
|
/* Initialization of the front end environment, before command line
|
options are parsed. Signal handlers, internationalization etc.
|
options are parsed. Signal handlers, internationalization etc.
|
ARGV0 is main's argv[0]. */
|
ARGV0 is main's argv[0]. */
|
static void
|
static void
|
general_init (const char *argv0)
|
general_init (const char *argv0)
|
{
|
{
|
const char *p;
|
const char *p;
|
|
|
p = argv0 + strlen (argv0);
|
p = argv0 + strlen (argv0);
|
while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
|
while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
|
--p;
|
--p;
|
progname = p;
|
progname = p;
|
|
|
xmalloc_set_program_name (progname);
|
xmalloc_set_program_name (progname);
|
|
|
hex_init ();
|
hex_init ();
|
|
|
/* Unlock the stdio streams. */
|
/* Unlock the stdio streams. */
|
unlock_std_streams ();
|
unlock_std_streams ();
|
|
|
gcc_init_libintl ();
|
gcc_init_libintl ();
|
|
|
/* Initialize the diagnostics reporting machinery, so option parsing
|
/* Initialize the diagnostics reporting machinery, so option parsing
|
can give warnings and errors. */
|
can give warnings and errors. */
|
diagnostic_initialize (global_dc);
|
diagnostic_initialize (global_dc);
|
/* Set a default printer. Language specific initializations will
|
/* Set a default printer. Language specific initializations will
|
override it later. */
|
override it later. */
|
pp_format_decoder (global_dc->printer) = &default_tree_printer;
|
pp_format_decoder (global_dc->printer) = &default_tree_printer;
|
|
|
/* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
|
/* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
|
#ifdef SIGSEGV
|
#ifdef SIGSEGV
|
signal (SIGSEGV, crash_signal);
|
signal (SIGSEGV, crash_signal);
|
#endif
|
#endif
|
#ifdef SIGILL
|
#ifdef SIGILL
|
signal (SIGILL, crash_signal);
|
signal (SIGILL, crash_signal);
|
#endif
|
#endif
|
#ifdef SIGBUS
|
#ifdef SIGBUS
|
signal (SIGBUS, crash_signal);
|
signal (SIGBUS, crash_signal);
|
#endif
|
#endif
|
#ifdef SIGABRT
|
#ifdef SIGABRT
|
signal (SIGABRT, crash_signal);
|
signal (SIGABRT, crash_signal);
|
#endif
|
#endif
|
#if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
|
#if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
|
signal (SIGIOT, crash_signal);
|
signal (SIGIOT, crash_signal);
|
#endif
|
#endif
|
#ifdef SIGFPE
|
#ifdef SIGFPE
|
signal (SIGFPE, crash_signal);
|
signal (SIGFPE, crash_signal);
|
#endif
|
#endif
|
|
|
/* Other host-specific signal setup. */
|
/* Other host-specific signal setup. */
|
(*host_hooks.extra_signals)();
|
(*host_hooks.extra_signals)();
|
|
|
/* Initialize the garbage-collector, string pools and tree type hash
|
/* Initialize the garbage-collector, string pools and tree type hash
|
table. */
|
table. */
|
init_ggc ();
|
init_ggc ();
|
init_stringpool ();
|
init_stringpool ();
|
linemap_init (&line_table);
|
linemap_init (&line_table);
|
init_ttree ();
|
init_ttree ();
|
|
|
/* Initialize register usage now so switches may override. */
|
/* Initialize register usage now so switches may override. */
|
init_reg_sets ();
|
init_reg_sets ();
|
|
|
/* Register the language-independent parameters. */
|
/* Register the language-independent parameters. */
|
add_params (lang_independent_params, LAST_PARAM);
|
add_params (lang_independent_params, LAST_PARAM);
|
|
|
/* This must be done after add_params but before argument processing. */
|
/* This must be done after add_params but before argument processing. */
|
init_ggc_heuristics();
|
init_ggc_heuristics();
|
init_optimization_passes ();
|
init_optimization_passes ();
|
}
|
}
|
|
|
/* Return true if the current target supports -fsection-anchors. */
|
/* Return true if the current target supports -fsection-anchors. */
|
|
|
static bool
|
static bool
|
target_supports_section_anchors_p (void)
|
target_supports_section_anchors_p (void)
|
{
|
{
|
if (targetm.min_anchor_offset == 0 && targetm.max_anchor_offset == 0)
|
if (targetm.min_anchor_offset == 0 && targetm.max_anchor_offset == 0)
|
return false;
|
return false;
|
|
|
if (targetm.asm_out.output_anchor == NULL)
|
if (targetm.asm_out.output_anchor == NULL)
|
return false;
|
return false;
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Process the options that have been parsed. */
|
/* Process the options that have been parsed. */
|
static void
|
static void
|
process_options (void)
|
process_options (void)
|
{
|
{
|
/* Just in case lang_hooks.post_options ends up calling a debug_hook.
|
/* Just in case lang_hooks.post_options ends up calling a debug_hook.
|
This can happen with incorrect pre-processed input. */
|
This can happen with incorrect pre-processed input. */
|
debug_hooks = &do_nothing_debug_hooks;
|
debug_hooks = &do_nothing_debug_hooks;
|
|
|
/* Allow the front end to perform consistency checks and do further
|
/* Allow the front end to perform consistency checks and do further
|
initialization based on the command line options. This hook also
|
initialization based on the command line options. This hook also
|
sets the original filename if appropriate (e.g. foo.i -> foo.c)
|
sets the original filename if appropriate (e.g. foo.i -> foo.c)
|
so we can correctly initialize debug output. */
|
so we can correctly initialize debug output. */
|
no_backend = lang_hooks.post_options (&main_input_filename);
|
no_backend = lang_hooks.post_options (&main_input_filename);
|
#ifndef USE_MAPPED_LOCATION
|
#ifndef USE_MAPPED_LOCATION
|
input_filename = main_input_filename;
|
input_filename = main_input_filename;
|
#endif
|
#endif
|
|
|
#ifdef OVERRIDE_OPTIONS
|
#ifdef OVERRIDE_OPTIONS
|
/* Some machines may reject certain combinations of options. */
|
/* Some machines may reject certain combinations of options. */
|
OVERRIDE_OPTIONS;
|
OVERRIDE_OPTIONS;
|
#endif
|
#endif
|
|
|
if (flag_section_anchors && !target_supports_section_anchors_p ())
|
if (flag_section_anchors && !target_supports_section_anchors_p ())
|
{
|
{
|
warning (OPT_fsection_anchors,
|
warning (OPT_fsection_anchors,
|
"this target does not support %qs", "-fsection-anchors");
|
"this target does not support %qs", "-fsection-anchors");
|
flag_section_anchors = 0;
|
flag_section_anchors = 0;
|
}
|
}
|
|
|
if (flag_short_enums == 2)
|
if (flag_short_enums == 2)
|
flag_short_enums = targetm.default_short_enums ();
|
flag_short_enums = targetm.default_short_enums ();
|
|
|
/* Set aux_base_name if not already set. */
|
/* Set aux_base_name if not already set. */
|
if (aux_base_name)
|
if (aux_base_name)
|
;
|
;
|
else if (main_input_filename)
|
else if (main_input_filename)
|
{
|
{
|
char *name = xstrdup (lbasename (main_input_filename));
|
char *name = xstrdup (lbasename (main_input_filename));
|
|
|
strip_off_ending (name, strlen (name));
|
strip_off_ending (name, strlen (name));
|
aux_base_name = name;
|
aux_base_name = name;
|
}
|
}
|
else
|
else
|
aux_base_name = "gccaux";
|
aux_base_name = "gccaux";
|
|
|
/* Set up the align_*_log variables, defaulting them to 1 if they
|
/* Set up the align_*_log variables, defaulting them to 1 if they
|
were still unset. */
|
were still unset. */
|
if (align_loops <= 0) align_loops = 1;
|
if (align_loops <= 0) align_loops = 1;
|
if (align_loops_max_skip > align_loops || !align_loops)
|
if (align_loops_max_skip > align_loops || !align_loops)
|
align_loops_max_skip = align_loops - 1;
|
align_loops_max_skip = align_loops - 1;
|
align_loops_log = floor_log2 (align_loops * 2 - 1);
|
align_loops_log = floor_log2 (align_loops * 2 - 1);
|
if (align_jumps <= 0) align_jumps = 1;
|
if (align_jumps <= 0) align_jumps = 1;
|
if (align_jumps_max_skip > align_jumps || !align_jumps)
|
if (align_jumps_max_skip > align_jumps || !align_jumps)
|
align_jumps_max_skip = align_jumps - 1;
|
align_jumps_max_skip = align_jumps - 1;
|
align_jumps_log = floor_log2 (align_jumps * 2 - 1);
|
align_jumps_log = floor_log2 (align_jumps * 2 - 1);
|
if (align_labels <= 0) align_labels = 1;
|
if (align_labels <= 0) align_labels = 1;
|
align_labels_log = floor_log2 (align_labels * 2 - 1);
|
align_labels_log = floor_log2 (align_labels * 2 - 1);
|
if (align_labels_max_skip > align_labels || !align_labels)
|
if (align_labels_max_skip > align_labels || !align_labels)
|
align_labels_max_skip = align_labels - 1;
|
align_labels_max_skip = align_labels - 1;
|
if (align_functions <= 0) align_functions = 1;
|
if (align_functions <= 0) align_functions = 1;
|
align_functions_log = floor_log2 (align_functions * 2 - 1);
|
align_functions_log = floor_log2 (align_functions * 2 - 1);
|
|
|
/* Unrolling all loops implies that standard loop unrolling must also
|
/* Unrolling all loops implies that standard loop unrolling must also
|
be done. */
|
be done. */
|
if (flag_unroll_all_loops)
|
if (flag_unroll_all_loops)
|
flag_unroll_loops = 1;
|
flag_unroll_loops = 1;
|
|
|
/* The loop unrolling code assumes that cse will be run after loop.
|
/* The loop unrolling code assumes that cse will be run after loop.
|
web and rename-registers also help when run after loop unrolling. */
|
web and rename-registers also help when run after loop unrolling. */
|
|
|
if (flag_rerun_cse_after_loop == AUTODETECT_VALUE)
|
if (flag_rerun_cse_after_loop == AUTODETECT_VALUE)
|
flag_rerun_cse_after_loop = flag_unroll_loops || flag_peel_loops;
|
flag_rerun_cse_after_loop = flag_unroll_loops || flag_peel_loops;
|
if (flag_web == AUTODETECT_VALUE)
|
if (flag_web == AUTODETECT_VALUE)
|
flag_web = flag_unroll_loops || flag_peel_loops;
|
flag_web = flag_unroll_loops || flag_peel_loops;
|
if (flag_rename_registers == AUTODETECT_VALUE)
|
if (flag_rename_registers == AUTODETECT_VALUE)
|
flag_rename_registers = flag_unroll_loops || flag_peel_loops;
|
flag_rename_registers = flag_unroll_loops || flag_peel_loops;
|
|
|
if (flag_non_call_exceptions)
|
if (flag_non_call_exceptions)
|
flag_asynchronous_unwind_tables = 1;
|
flag_asynchronous_unwind_tables = 1;
|
if (flag_asynchronous_unwind_tables)
|
if (flag_asynchronous_unwind_tables)
|
flag_unwind_tables = 1;
|
flag_unwind_tables = 1;
|
|
|
/* Disable unit-at-a-time mode for frontends not supporting callgraph
|
/* Disable unit-at-a-time mode for frontends not supporting callgraph
|
interface. */
|
interface. */
|
if (flag_unit_at_a_time && ! lang_hooks.callgraph.expand_function)
|
if (flag_unit_at_a_time && ! lang_hooks.callgraph.expand_function)
|
flag_unit_at_a_time = 0;
|
flag_unit_at_a_time = 0;
|
|
|
if (!flag_unit_at_a_time)
|
if (!flag_unit_at_a_time)
|
flag_section_anchors = 0;
|
flag_section_anchors = 0;
|
|
|
if (flag_value_profile_transformations)
|
if (flag_value_profile_transformations)
|
flag_profile_values = 1;
|
flag_profile_values = 1;
|
|
|
/* Warn about options that are not supported on this machine. */
|
/* Warn about options that are not supported on this machine. */
|
#ifndef INSN_SCHEDULING
|
#ifndef INSN_SCHEDULING
|
if (flag_schedule_insns || flag_schedule_insns_after_reload)
|
if (flag_schedule_insns || flag_schedule_insns_after_reload)
|
warning (0, "instruction scheduling not supported on this target machine");
|
warning (0, "instruction scheduling not supported on this target machine");
|
#endif
|
#endif
|
#ifndef DELAY_SLOTS
|
#ifndef DELAY_SLOTS
|
if (flag_delayed_branch)
|
if (flag_delayed_branch)
|
warning (0, "this target machine does not have delayed branches");
|
warning (0, "this target machine does not have delayed branches");
|
#endif
|
#endif
|
|
|
user_label_prefix = USER_LABEL_PREFIX;
|
user_label_prefix = USER_LABEL_PREFIX;
|
if (flag_leading_underscore != -1)
|
if (flag_leading_underscore != -1)
|
{
|
{
|
/* If the default prefix is more complicated than "" or "_",
|
/* If the default prefix is more complicated than "" or "_",
|
issue a warning and ignore this option. */
|
issue a warning and ignore this option. */
|
if (user_label_prefix[0] == 0 ||
|
if (user_label_prefix[0] == 0 ||
|
(user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
|
(user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
|
{
|
{
|
user_label_prefix = flag_leading_underscore ? "_" : "";
|
user_label_prefix = flag_leading_underscore ? "_" : "";
|
}
|
}
|
else
|
else
|
warning (0, "-f%sleading-underscore not supported on this target machine",
|
warning (0, "-f%sleading-underscore not supported on this target machine",
|
flag_leading_underscore ? "" : "no-");
|
flag_leading_underscore ? "" : "no-");
|
}
|
}
|
|
|
/* If we are in verbose mode, write out the version and maybe all the
|
/* If we are in verbose mode, write out the version and maybe all the
|
option flags in use. */
|
option flags in use. */
|
if (version_flag)
|
if (version_flag)
|
{
|
{
|
print_version (stderr, "");
|
print_version (stderr, "");
|
if (! quiet_flag)
|
if (! quiet_flag)
|
print_switch_values (stderr, 0, MAX_LINE, "", " ", "\n");
|
print_switch_values (stderr, 0, MAX_LINE, "", " ", "\n");
|
}
|
}
|
|
|
if (flag_syntax_only)
|
if (flag_syntax_only)
|
{
|
{
|
write_symbols = NO_DEBUG;
|
write_symbols = NO_DEBUG;
|
profile_flag = 0;
|
profile_flag = 0;
|
}
|
}
|
|
|
/* A lot of code assumes write_symbols == NO_DEBUG if the debugging
|
/* A lot of code assumes write_symbols == NO_DEBUG if the debugging
|
level is 0. */
|
level is 0. */
|
if (debug_info_level == DINFO_LEVEL_NONE)
|
if (debug_info_level == DINFO_LEVEL_NONE)
|
write_symbols = NO_DEBUG;
|
write_symbols = NO_DEBUG;
|
|
|
/* Now we know write_symbols, set up the debug hooks based on it.
|
/* Now we know write_symbols, set up the debug hooks based on it.
|
By default we do nothing for debug output. */
|
By default we do nothing for debug output. */
|
if (PREFERRED_DEBUGGING_TYPE == NO_DEBUG)
|
if (PREFERRED_DEBUGGING_TYPE == NO_DEBUG)
|
default_debug_hooks = &do_nothing_debug_hooks;
|
default_debug_hooks = &do_nothing_debug_hooks;
|
#if defined(DBX_DEBUGGING_INFO)
|
#if defined(DBX_DEBUGGING_INFO)
|
else if (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG)
|
else if (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG)
|
default_debug_hooks = &dbx_debug_hooks;
|
default_debug_hooks = &dbx_debug_hooks;
|
#endif
|
#endif
|
#if defined(XCOFF_DEBUGGING_INFO)
|
#if defined(XCOFF_DEBUGGING_INFO)
|
else if (PREFERRED_DEBUGGING_TYPE == XCOFF_DEBUG)
|
else if (PREFERRED_DEBUGGING_TYPE == XCOFF_DEBUG)
|
default_debug_hooks = &xcoff_debug_hooks;
|
default_debug_hooks = &xcoff_debug_hooks;
|
#endif
|
#endif
|
#ifdef SDB_DEBUGGING_INFO
|
#ifdef SDB_DEBUGGING_INFO
|
else if (PREFERRED_DEBUGGING_TYPE == SDB_DEBUG)
|
else if (PREFERRED_DEBUGGING_TYPE == SDB_DEBUG)
|
default_debug_hooks = &sdb_debug_hooks;
|
default_debug_hooks = &sdb_debug_hooks;
|
#endif
|
#endif
|
#ifdef DWARF2_DEBUGGING_INFO
|
#ifdef DWARF2_DEBUGGING_INFO
|
else if (PREFERRED_DEBUGGING_TYPE == DWARF2_DEBUG)
|
else if (PREFERRED_DEBUGGING_TYPE == DWARF2_DEBUG)
|
default_debug_hooks = &dwarf2_debug_hooks;
|
default_debug_hooks = &dwarf2_debug_hooks;
|
#endif
|
#endif
|
#ifdef VMS_DEBUGGING_INFO
|
#ifdef VMS_DEBUGGING_INFO
|
else if (PREFERRED_DEBUGGING_TYPE == VMS_DEBUG
|
else if (PREFERRED_DEBUGGING_TYPE == VMS_DEBUG
|
|| PREFERRED_DEBUGGING_TYPE == VMS_AND_DWARF2_DEBUG)
|
|| PREFERRED_DEBUGGING_TYPE == VMS_AND_DWARF2_DEBUG)
|
default_debug_hooks = &vmsdbg_debug_hooks;
|
default_debug_hooks = &vmsdbg_debug_hooks;
|
#endif
|
#endif
|
|
|
if (write_symbols == NO_DEBUG)
|
if (write_symbols == NO_DEBUG)
|
;
|
;
|
#if defined(DBX_DEBUGGING_INFO)
|
#if defined(DBX_DEBUGGING_INFO)
|
else if (write_symbols == DBX_DEBUG)
|
else if (write_symbols == DBX_DEBUG)
|
debug_hooks = &dbx_debug_hooks;
|
debug_hooks = &dbx_debug_hooks;
|
#endif
|
#endif
|
#if defined(XCOFF_DEBUGGING_INFO)
|
#if defined(XCOFF_DEBUGGING_INFO)
|
else if (write_symbols == XCOFF_DEBUG)
|
else if (write_symbols == XCOFF_DEBUG)
|
debug_hooks = &xcoff_debug_hooks;
|
debug_hooks = &xcoff_debug_hooks;
|
#endif
|
#endif
|
#ifdef SDB_DEBUGGING_INFO
|
#ifdef SDB_DEBUGGING_INFO
|
else if (write_symbols == SDB_DEBUG)
|
else if (write_symbols == SDB_DEBUG)
|
debug_hooks = &sdb_debug_hooks;
|
debug_hooks = &sdb_debug_hooks;
|
#endif
|
#endif
|
#ifdef DWARF2_DEBUGGING_INFO
|
#ifdef DWARF2_DEBUGGING_INFO
|
else if (write_symbols == DWARF2_DEBUG)
|
else if (write_symbols == DWARF2_DEBUG)
|
debug_hooks = &dwarf2_debug_hooks;
|
debug_hooks = &dwarf2_debug_hooks;
|
#endif
|
#endif
|
#ifdef VMS_DEBUGGING_INFO
|
#ifdef VMS_DEBUGGING_INFO
|
else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
|
else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
|
debug_hooks = &vmsdbg_debug_hooks;
|
debug_hooks = &vmsdbg_debug_hooks;
|
#endif
|
#endif
|
else
|
else
|
error ("target system does not support the \"%s\" debug format",
|
error ("target system does not support the \"%s\" debug format",
|
debug_type_names[write_symbols]);
|
debug_type_names[write_symbols]);
|
|
|
/* Now we know which debug output will be used so we can set
|
/* Now we know which debug output will be used so we can set
|
flag_var_tracking, flag_rename_registers if the user has
|
flag_var_tracking, flag_rename_registers if the user has
|
not specified them. */
|
not specified them. */
|
if (debug_info_level < DINFO_LEVEL_NORMAL
|
if (debug_info_level < DINFO_LEVEL_NORMAL
|
|| debug_hooks->var_location == do_nothing_debug_hooks.var_location)
|
|| debug_hooks->var_location == do_nothing_debug_hooks.var_location)
|
{
|
{
|
if (flag_var_tracking == 1)
|
if (flag_var_tracking == 1)
|
{
|
{
|
if (debug_info_level < DINFO_LEVEL_NORMAL)
|
if (debug_info_level < DINFO_LEVEL_NORMAL)
|
warning (0, "variable tracking requested, but useless unless "
|
warning (0, "variable tracking requested, but useless unless "
|
"producing debug info");
|
"producing debug info");
|
else
|
else
|
warning (0, "variable tracking requested, but not supported "
|
warning (0, "variable tracking requested, but not supported "
|
"by this debug format");
|
"by this debug format");
|
}
|
}
|
flag_var_tracking = 0;
|
flag_var_tracking = 0;
|
}
|
}
|
|
|
if (flag_rename_registers == AUTODETECT_VALUE)
|
if (flag_rename_registers == AUTODETECT_VALUE)
|
flag_rename_registers = default_debug_hooks->var_location
|
flag_rename_registers = default_debug_hooks->var_location
|
!= do_nothing_debug_hooks.var_location;
|
!= do_nothing_debug_hooks.var_location;
|
|
|
if (flag_var_tracking == AUTODETECT_VALUE)
|
if (flag_var_tracking == AUTODETECT_VALUE)
|
flag_var_tracking = optimize >= 1;
|
flag_var_tracking = optimize >= 1;
|
|
|
/* If auxiliary info generation is desired, open the output file.
|
/* If auxiliary info generation is desired, open the output file.
|
This goes in the same directory as the source file--unlike
|
This goes in the same directory as the source file--unlike
|
all the other output files. */
|
all the other output files. */
|
if (flag_gen_aux_info)
|
if (flag_gen_aux_info)
|
{
|
{
|
aux_info_file = fopen (aux_info_file_name, "w");
|
aux_info_file = fopen (aux_info_file_name, "w");
|
if (aux_info_file == 0)
|
if (aux_info_file == 0)
|
fatal_error ("can%'t open %s: %m", aux_info_file_name);
|
fatal_error ("can%'t open %s: %m", aux_info_file_name);
|
}
|
}
|
|
|
if (! targetm.have_named_sections)
|
if (! targetm.have_named_sections)
|
{
|
{
|
if (flag_function_sections)
|
if (flag_function_sections)
|
{
|
{
|
warning (0, "-ffunction-sections not supported for this target");
|
warning (0, "-ffunction-sections not supported for this target");
|
flag_function_sections = 0;
|
flag_function_sections = 0;
|
}
|
}
|
if (flag_data_sections)
|
if (flag_data_sections)
|
{
|
{
|
warning (0, "-fdata-sections not supported for this target");
|
warning (0, "-fdata-sections not supported for this target");
|
flag_data_sections = 0;
|
flag_data_sections = 0;
|
}
|
}
|
}
|
}
|
|
|
if (flag_function_sections && profile_flag)
|
if (flag_function_sections && profile_flag)
|
{
|
{
|
warning (0, "-ffunction-sections disabled; it makes profiling impossible");
|
warning (0, "-ffunction-sections disabled; it makes profiling impossible");
|
flag_function_sections = 0;
|
flag_function_sections = 0;
|
}
|
}
|
|
|
#ifndef HAVE_prefetch
|
#ifndef HAVE_prefetch
|
if (flag_prefetch_loop_arrays)
|
if (flag_prefetch_loop_arrays)
|
{
|
{
|
warning (0, "-fprefetch-loop-arrays not supported for this target");
|
warning (0, "-fprefetch-loop-arrays not supported for this target");
|
flag_prefetch_loop_arrays = 0;
|
flag_prefetch_loop_arrays = 0;
|
}
|
}
|
#else
|
#else
|
if (flag_prefetch_loop_arrays && !HAVE_prefetch)
|
if (flag_prefetch_loop_arrays && !HAVE_prefetch)
|
{
|
{
|
warning (0, "-fprefetch-loop-arrays not supported for this target (try -march switches)");
|
warning (0, "-fprefetch-loop-arrays not supported for this target (try -march switches)");
|
flag_prefetch_loop_arrays = 0;
|
flag_prefetch_loop_arrays = 0;
|
}
|
}
|
#endif
|
#endif
|
|
|
/* This combination of options isn't handled for i386 targets and doesn't
|
/* This combination of options isn't handled for i386 targets and doesn't
|
make much sense anyway, so don't allow it. */
|
make much sense anyway, so don't allow it. */
|
if (flag_prefetch_loop_arrays && optimize_size)
|
if (flag_prefetch_loop_arrays && optimize_size)
|
{
|
{
|
warning (0, "-fprefetch-loop-arrays is not supported with -Os");
|
warning (0, "-fprefetch-loop-arrays is not supported with -Os");
|
flag_prefetch_loop_arrays = 0;
|
flag_prefetch_loop_arrays = 0;
|
}
|
}
|
|
|
#ifndef OBJECT_FORMAT_ELF
|
#ifndef OBJECT_FORMAT_ELF
|
#ifndef OBJECT_FORMAT_MACHO
|
#ifndef OBJECT_FORMAT_MACHO
|
if (flag_function_sections && write_symbols != NO_DEBUG)
|
if (flag_function_sections && write_symbols != NO_DEBUG)
|
warning (0, "-ffunction-sections may affect debugging on some targets");
|
warning (0, "-ffunction-sections may affect debugging on some targets");
|
#endif
|
#endif
|
#endif
|
#endif
|
|
|
/* The presence of IEEE signaling NaNs, implies all math can trap. */
|
/* The presence of IEEE signaling NaNs, implies all math can trap. */
|
if (flag_signaling_nans)
|
if (flag_signaling_nans)
|
flag_trapping_math = 1;
|
flag_trapping_math = 1;
|
|
|
/* With -fcx-limited-range, we do cheap and quick complex arithmetic. */
|
/* With -fcx-limited-range, we do cheap and quick complex arithmetic. */
|
if (flag_cx_limited_range)
|
if (flag_cx_limited_range)
|
flag_complex_method = 0;
|
flag_complex_method = 0;
|
|
|
/* Targets must be able to place spill slots at lower addresses. If the
|
/* Targets must be able to place spill slots at lower addresses. If the
|
target already uses a soft frame pointer, the transition is trivial. */
|
target already uses a soft frame pointer, the transition is trivial. */
|
if (!FRAME_GROWS_DOWNWARD && flag_stack_protect)
|
if (!FRAME_GROWS_DOWNWARD && flag_stack_protect)
|
{
|
{
|
warning (0, "-fstack-protector not supported for this target");
|
warning (0, "-fstack-protector not supported for this target");
|
flag_stack_protect = 0;
|
flag_stack_protect = 0;
|
}
|
}
|
if (!flag_stack_protect)
|
if (!flag_stack_protect)
|
warn_stack_protect = 0;
|
warn_stack_protect = 0;
|
|
|
/* ??? Unwind info is not correct around the CFG unless either a frame
|
/* ??? Unwind info is not correct around the CFG unless either a frame
|
pointer is present or A_O_A is set. Fixing this requires rewriting
|
pointer is present or A_O_A is set. Fixing this requires rewriting
|
unwind info generation to be aware of the CFG and propagating states
|
unwind info generation to be aware of the CFG and propagating states
|
around edges. */
|
around edges. */
|
if (flag_unwind_tables && !ACCUMULATE_OUTGOING_ARGS
|
if (flag_unwind_tables && !ACCUMULATE_OUTGOING_ARGS
|
&& flag_omit_frame_pointer)
|
&& flag_omit_frame_pointer)
|
{
|
{
|
warning (0, "unwind tables currently requires a frame pointer "
|
warning (0, "unwind tables currently requires a frame pointer "
|
"for correctness");
|
"for correctness");
|
flag_omit_frame_pointer = 0;
|
flag_omit_frame_pointer = 0;
|
}
|
}
|
}
|
}
|
|
|
/* Initialize the compiler back end. */
|
/* Initialize the compiler back end. */
|
static void
|
static void
|
backend_init (void)
|
backend_init (void)
|
{
|
{
|
init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL
|
init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL
|
|| debug_info_level == DINFO_LEVEL_VERBOSE
|
|| debug_info_level == DINFO_LEVEL_VERBOSE
|
#ifdef VMS_DEBUGGING_INFO
|
#ifdef VMS_DEBUGGING_INFO
|
/* Enable line number info for traceback. */
|
/* Enable line number info for traceback. */
|
|| debug_info_level > DINFO_LEVEL_NONE
|
|| debug_info_level > DINFO_LEVEL_NONE
|
#endif
|
#endif
|
|| flag_test_coverage);
|
|| flag_test_coverage);
|
|
|
init_rtlanal ();
|
init_rtlanal ();
|
init_regs ();
|
init_regs ();
|
init_fake_stack_mems ();
|
init_fake_stack_mems ();
|
init_alias_once ();
|
init_alias_once ();
|
init_reload ();
|
init_reload ();
|
init_varasm_once ();
|
init_varasm_once ();
|
|
|
/* The following initialization functions need to generate rtl, so
|
/* The following initialization functions need to generate rtl, so
|
provide a dummy function context for them. */
|
provide a dummy function context for them. */
|
init_dummy_function_start ();
|
init_dummy_function_start ();
|
init_expmed ();
|
init_expmed ();
|
if (flag_caller_saves)
|
if (flag_caller_saves)
|
init_caller_save ();
|
init_caller_save ();
|
expand_dummy_function_end ();
|
expand_dummy_function_end ();
|
}
|
}
|
|
|
/* Language-dependent initialization. Returns nonzero on success. */
|
/* Language-dependent initialization. Returns nonzero on success. */
|
static int
|
static int
|
lang_dependent_init (const char *name)
|
lang_dependent_init (const char *name)
|
{
|
{
|
location_t save_loc = input_location;
|
location_t save_loc = input_location;
|
if (dump_base_name == 0)
|
if (dump_base_name == 0)
|
dump_base_name = name && name[0] ? name : "gccdump";
|
dump_base_name = name && name[0] ? name : "gccdump";
|
|
|
/* Other front-end initialization. */
|
/* Other front-end initialization. */
|
#ifdef USE_MAPPED_LOCATION
|
#ifdef USE_MAPPED_LOCATION
|
input_location = BUILTINS_LOCATION;
|
input_location = BUILTINS_LOCATION;
|
#else
|
#else
|
input_filename = "<built-in>";
|
input_filename = "<built-in>";
|
input_line = 0;
|
input_line = 0;
|
#endif
|
#endif
|
if (lang_hooks.init () == 0)
|
if (lang_hooks.init () == 0)
|
return 0;
|
return 0;
|
input_location = save_loc;
|
input_location = save_loc;
|
|
|
init_asm_output (name);
|
init_asm_output (name);
|
|
|
/* These create various _DECL nodes, so need to be called after the
|
/* These create various _DECL nodes, so need to be called after the
|
front end is initialized. */
|
front end is initialized. */
|
init_eh ();
|
init_eh ();
|
init_optabs ();
|
init_optabs ();
|
|
|
/* The following initialization functions need to generate rtl, so
|
/* The following initialization functions need to generate rtl, so
|
provide a dummy function context for them. */
|
provide a dummy function context for them. */
|
init_dummy_function_start ();
|
init_dummy_function_start ();
|
init_expr_once ();
|
init_expr_once ();
|
expand_dummy_function_end ();
|
expand_dummy_function_end ();
|
|
|
/* If dbx symbol table desired, initialize writing it and output the
|
/* If dbx symbol table desired, initialize writing it and output the
|
predefined types. */
|
predefined types. */
|
timevar_push (TV_SYMOUT);
|
timevar_push (TV_SYMOUT);
|
|
|
#if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
|
#if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
|
if (dwarf2out_do_frame ())
|
if (dwarf2out_do_frame ())
|
dwarf2out_frame_init ();
|
dwarf2out_frame_init ();
|
#endif
|
#endif
|
|
|
/* Now we have the correct original filename, we can initialize
|
/* Now we have the correct original filename, we can initialize
|
debug output. */
|
debug output. */
|
(*debug_hooks->init) (name);
|
(*debug_hooks->init) (name);
|
|
|
timevar_pop (TV_SYMOUT);
|
timevar_pop (TV_SYMOUT);
|
|
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Clean up: close opened files, etc. */
|
/* Clean up: close opened files, etc. */
|
|
|
static void
|
static void
|
finalize (void)
|
finalize (void)
|
{
|
{
|
/* Close the dump files. */
|
/* Close the dump files. */
|
if (flag_gen_aux_info)
|
if (flag_gen_aux_info)
|
{
|
{
|
fclose (aux_info_file);
|
fclose (aux_info_file);
|
if (errorcount)
|
if (errorcount)
|
unlink (aux_info_file_name);
|
unlink (aux_info_file_name);
|
}
|
}
|
|
|
/* Close non-debugging input and output files. Take special care to note
|
/* Close non-debugging input and output files. Take special care to note
|
whether fclose returns an error, since the pages might still be on the
|
whether fclose returns an error, since the pages might still be on the
|
buffer chain while the file is open. */
|
buffer chain while the file is open. */
|
|
|
if (asm_out_file)
|
if (asm_out_file)
|
{
|
{
|
if (ferror (asm_out_file) != 0)
|
if (ferror (asm_out_file) != 0)
|
fatal_error ("error writing to %s: %m", asm_file_name);
|
fatal_error ("error writing to %s: %m", asm_file_name);
|
if (fclose (asm_out_file) != 0)
|
if (fclose (asm_out_file) != 0)
|
fatal_error ("error closing %s: %m", asm_file_name);
|
fatal_error ("error closing %s: %m", asm_file_name);
|
}
|
}
|
|
|
finish_optimization_passes ();
|
finish_optimization_passes ();
|
|
|
if (mem_report)
|
if (mem_report)
|
{
|
{
|
ggc_print_statistics ();
|
ggc_print_statistics ();
|
stringpool_statistics ();
|
stringpool_statistics ();
|
dump_tree_statistics ();
|
dump_tree_statistics ();
|
dump_rtx_statistics ();
|
dump_rtx_statistics ();
|
dump_varray_statistics ();
|
dump_varray_statistics ();
|
dump_alloc_pool_statistics ();
|
dump_alloc_pool_statistics ();
|
dump_ggc_loc_statistics ();
|
dump_ggc_loc_statistics ();
|
}
|
}
|
|
|
/* Free up memory for the benefit of leak detectors. */
|
/* Free up memory for the benefit of leak detectors. */
|
free_reg_info ();
|
free_reg_info ();
|
|
|
/* Language-specific end of compilation actions. */
|
/* Language-specific end of compilation actions. */
|
lang_hooks.finish ();
|
lang_hooks.finish ();
|
}
|
}
|
|
|
/* Initialize the compiler, and compile the input file. */
|
/* Initialize the compiler, and compile the input file. */
|
static void
|
static void
|
do_compile (void)
|
do_compile (void)
|
{
|
{
|
/* Initialize timing first. The C front ends read the main file in
|
/* Initialize timing first. The C front ends read the main file in
|
the post_options hook, and C++ does file timings. */
|
the post_options hook, and C++ does file timings. */
|
if (time_report || !quiet_flag || flag_detailed_statistics)
|
if (time_report || !quiet_flag || flag_detailed_statistics)
|
timevar_init ();
|
timevar_init ();
|
timevar_start (TV_TOTAL);
|
timevar_start (TV_TOTAL);
|
|
|
process_options ();
|
process_options ();
|
|
|
/* Don't do any more if an error has already occurred. */
|
/* Don't do any more if an error has already occurred. */
|
if (!errorcount)
|
if (!errorcount)
|
{
|
{
|
/* This must be run always, because it is needed to compute the FP
|
/* This must be run always, because it is needed to compute the FP
|
predefined macros, such as __LDBL_MAX__, for targets using non
|
predefined macros, such as __LDBL_MAX__, for targets using non
|
default FP formats. */
|
default FP formats. */
|
init_adjust_machine_modes ();
|
init_adjust_machine_modes ();
|
|
|
/* Set up the back-end if requested. */
|
/* Set up the back-end if requested. */
|
if (!no_backend)
|
if (!no_backend)
|
backend_init ();
|
backend_init ();
|
|
|
/* Language-dependent initialization. Returns true on success. */
|
/* Language-dependent initialization. Returns true on success. */
|
if (lang_dependent_init (main_input_filename))
|
if (lang_dependent_init (main_input_filename))
|
compile_file ();
|
compile_file ();
|
|
|
finalize ();
|
finalize ();
|
}
|
}
|
|
|
/* Stop timing and print the times. */
|
/* Stop timing and print the times. */
|
timevar_stop (TV_TOTAL);
|
timevar_stop (TV_TOTAL);
|
timevar_print (stderr);
|
timevar_print (stderr);
|
}
|
}
|
|
|
/* Entry point of cc1, cc1plus, jc1, f771, etc.
|
/* Entry point of cc1, cc1plus, jc1, f771, etc.
|
Exit code is FATAL_EXIT_CODE if can't open files or if there were
|
Exit code is FATAL_EXIT_CODE if can't open files or if there were
|
any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
|
any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
|
|
|
It is not safe to call this function more than once. */
|
It is not safe to call this function more than once. */
|
|
|
int
|
int
|
toplev_main (unsigned int argc, const char **argv)
|
toplev_main (unsigned int argc, const char **argv)
|
{
|
{
|
save_argv = argv;
|
save_argv = argv;
|
|
|
/* Initialization of GCC's environment, and diagnostics. */
|
/* Initialization of GCC's environment, and diagnostics. */
|
general_init (argv[0]);
|
general_init (argv[0]);
|
|
|
/* Parse the options and do minimal processing; basically just
|
/* Parse the options and do minimal processing; basically just
|
enough to default flags appropriately. */
|
enough to default flags appropriately. */
|
decode_options (argc, argv);
|
decode_options (argc, argv);
|
|
|
randomize ();
|
randomize ();
|
|
|
/* Exit early if we can (e.g. -help). */
|
/* Exit early if we can (e.g. -help). */
|
if (!exit_after_options)
|
if (!exit_after_options)
|
do_compile ();
|
do_compile ();
|
|
|
if (errorcount || sorrycount)
|
if (errorcount || sorrycount)
|
return (FATAL_EXIT_CODE);
|
return (FATAL_EXIT_CODE);
|
|
|
return (SUCCESS_EXIT_CODE);
|
return (SUCCESS_EXIT_CODE);
|
}
|
}
|
|
|
