#include "config.h"
#undef FLOAT
#undef FFS
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include <signal.h>
#ifdef HAVE_SYS_RESOURCE_H
# include <sys/resource.h>
#endif
#ifdef HAVE_SYS_TIMES_H
# include <sys/times.h>
#endif
#include "line-map.h"
#include "input.h"
#include "tree.h"
#include "version.h"
#include "rtl.h"
#include "tm_p.h"
#include "flags.h"
#include "insn-attr.h"
#include "insn-config.h"
#include "insn-flags.h"
#include "hard-reg-set.h"
#include "recog.h"
#include "output.h"
#include "except.h"
#include "function.h"
#include "toplev.h"
#include "expr.h"
#include "basic-block.h"
#include "intl.h"
#include "ggc.h"
#include "graph.h"
#include "regs.h"
#include "timevar.h"
#include "diagnostic.h"
#include "params.h"
#include "reload.h"
#include "dwarf2asm.h"
#include "integrate.h"
#include "real.h"
#include "debug.h"
#include "target.h"
#include "langhooks.h"
#include "cfglayout.h"
#include "cfgloop.h"
#include "hosthooks.h"
#include "cgraph.h"
#include "opts.h"
#include "coverage.h"
#include "value-prof.h"
#include "alloc-pool.h"
#include "tree-mudflap.h"
#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
#include "dwarf2out.h"
#endif
#if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
#include "dbxout.h"
#endif
#ifdef SDB_DEBUGGING_INFO
#include "sdbout.h"
#endif
#ifdef XCOFF_DEBUGGING_INFO
#include "xcoffout.h"
#endif
static void general_init (const char *);
static void do_compile (void);
static void process_options (void);
static void backend_init (void);
static int lang_dependent_init (const char *);
static void init_asm_output (const char *);
static void finalize (void);
static void crash_signal (int) ATTRIBUTE_NORETURN;
static void interrupt_signal (int) ATTRIBUTE_NORETURN;
static void setup_core_dumping (void);
static void compile_file (void);
static int print_single_switch (FILE *, int, int, const char *,
const char *, const char *,
const char *, const char *);
static void print_switch_values (FILE *, int, int, const char *,
const char *, const char *);
static int set_yydebug;
static bool no_backend;
#define MAX_LINE 75
const char *progname;
static const char **save_argv;
const char *main_input_filename;
#ifndef USE_MAPPED_LOCATION
location_t unknown_location = { NULL, 0 };
#endif
#define AUTODETECT_FLAG_VAR_TRACKING 2
location_t input_location;
struct line_maps line_table;
int no_new_pseudos;
struct file_stack *input_file_stack;
int input_file_stack_tick;
const char *dump_base_name;
const char *aux_base_name;
extern int target_flags;
int target_flags_explicit;
const struct gcc_debug_hooks *debug_hooks;
static const struct gcc_debug_hooks *default_debug_hooks;
int rtl_dump_and_exit;
int flag_print_asm_name;
enum graph_dump_types graph_dump_format;
const char *asm_file_name;
char *asm_file_name2;
tree current_function_decl;
const char * current_function_func_begin_label;
int in_system_header = 0;
int flag_detailed_statistics = 0;
const char *flag_random_seed;
unsigned local_tick;
int flag_signed_char;
int flag_short_enums;
int flag_fast = 0;
int flag_fastf = 0;
int flag_fastcp = 0;
int flag_fppc = 0;
#ifndef DEFAULT_PCC_STRUCT_RETURN
#define DEFAULT_PCC_STRUCT_RETURN 1
#endif
int flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
int flag_writable_strings = 0;
int flag_disable_opts_for_faltivec = 0;
int flag_complex_method = 1;
int flag_obey_inline;
int flag_really_no_inline = 2;
int flag_gen_aux_info = 0;
const char *aux_info_file_name;
int flag_shlib;
enum tls_model flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
int flag_pedantic_errors = 0;
int flag_debug_asm = 0;
int flag_dump_rtl_in_asm = 0;
rtx stack_limit_rtx;
int flag_renumber_insns = 1;
int predictive_compilation = -1;
int flag_var_tracking = AUTODETECT_FLAG_VAR_TRACKING;
bool user_defined_section_attribute = false;
int align_loops_log;
int align_jumps_log;
int align_labels_log;
int align_labels_max_skip;
int align_functions_log;
int force_align_functions_log;
typedef struct
{
const char *const string;
int *const variable;
const int on_value;
}
lang_independent_options;
int flag_evaluation_order = 0;
const char *user_label_prefix;
static const param_info lang_independent_params[] = {
#define DEFPARAM(ENUM, OPTION, HELP, DEFAULT, MIN, MAX) \
{ OPTION, DEFAULT, MIN, MAX, HELP },
#include "params.def"
#undef DEFPARAM
{ NULL, 0, 0, 0, NULL }
};
static const struct
{
const char *const name;
const int value;
const char *const description;
}
target_switches[] = TARGET_SWITCHES;
#ifdef TARGET_OPTIONS
static const struct
{
const char *const prefix;
const char **const variable;
const char *const description;
const char *const value;
}
target_options[] = TARGET_OPTIONS;
#endif
int warn_return_type;
FILE *asm_out_file;
FILE *aux_info_file;
FILE *dump_file = NULL;
const char *dump_file_name;
int flag_pch_file;
int flag_save_repository;
static const char *src_pwd;
bool
set_src_pwd (const char *pwd)
{
if (src_pwd)
{
if (strcmp (src_pwd, pwd) == 0)
return true;
else
return false;
}
src_pwd = xstrdup (pwd);
return true;
}
const char *
get_src_pwd (void)
{
if (! src_pwd)
{
src_pwd = getpwd ();
if (!src_pwd)
src_pwd = ".";
}
return src_pwd;
}
void
announce_function (tree decl)
{
if (!quiet_flag)
{
if (rtl_dump_and_exit)
verbatim ("%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
else
verbatim (" %s", lang_hooks.decl_printable_name (decl, 2));
fflush (stderr);
pp_needs_newline (global_dc->printer) = true;
diagnostic_set_last_function (global_dc);
}
}
static void
randomize (void)
{
if (!flag_random_seed)
{
unsigned HOST_WIDE_INT value;
static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
#ifdef HAVE_GETTIMEOFDAY
{
struct timeval tv;
gettimeofday (&tv, NULL);
local_tick = tv.tv_sec * 1000 + tv.tv_usec / 1000;
}
#else
{
time_t now = time (NULL);
if (now != (time_t)-1)
local_tick = (unsigned) now;
}
#endif
value = local_tick ^ getpid ();
sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
flag_random_seed = random_seed;
}
else if (!local_tick)
local_tick = -1;
}
int
read_integral_parameter (const char *p, const char *pname, const int defval)
{
const char *endp = p;
while (*endp)
{
if (ISDIGIT (*endp))
endp++;
else
break;
}
if (*endp != 0)
{
if (pname != 0)
error ("invalid option argument %qs", pname);
return defval;
}
return atoi (p);
}
int
floor_log2 (unsigned HOST_WIDE_INT x)
{
int t = 0;
if (x == 0)
return -1;
#ifdef CLZ_HWI
t = HOST_BITS_PER_WIDE_INT - 1 - (int) CLZ_HWI (x);
#else
if (HOST_BITS_PER_WIDE_INT > 64)
if (x >= (unsigned HOST_WIDE_INT) 1 << (t + 64))
t += 64;
if (HOST_BITS_PER_WIDE_INT > 32)
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 32))
t += 32;
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 16))
t += 16;
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 8))
t += 8;
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 4))
t += 4;
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 2))
t += 2;
if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 1))
t += 1;
#endif
return t;
}
static void
interrupt_signal (int signo ATTRIBUTE_UNUSED)
{
if (flag_gen_aux_info)
{
fclose (aux_info_file);
unlink (aux_info_file_name);
}
if (asm_out_file)
{
fclose (asm_out_file);
if (asm_file_name && *asm_file_name)
unlink (asm_file_name);
}
exit (FATAL_EXIT_CODE);
}
int
exact_log2 (unsigned HOST_WIDE_INT x)
{
if (x != (x & -x))
return -1;
#ifdef CTZ_HWI
return x ? CTZ_HWI (x) : -1;
#else
return floor_log2 (x);
#endif
}
static void
crash_signal (int signo)
{
signal (signo, SIG_DFL);
if (this_is_asm_operands)
{
output_operand_lossage ("unrecoverable error");
exit (FATAL_EXIT_CODE);
}
internal_error ("%s", strsignal (signo));
}
static void
setup_core_dumping (void)
{
#ifdef SIGABRT
signal (SIGABRT, SIG_DFL);
#endif
#if defined(HAVE_SETRLIMIT)
{
struct rlimit rlim;
if (getrlimit (RLIMIT_CORE, &rlim) != 0)
fatal_error ("getting core file size maximum limit: %m");
rlim.rlim_cur = rlim.rlim_max;
if (setrlimit (RLIMIT_CORE, &rlim) != 0)
fatal_error ("setting core file size limit to maximum: %m");
}
#endif
diagnostic_abort_on_error (global_dc);
}
void
strip_off_ending (char *name, int len)
{
int i;
for (i = 2; i < 6 && len > i; i++)
{
if (name[len - i] == '.')
{
name[len - i] = '\0';
break;
}
}
}
void
output_quoted_string (FILE *asm_file, const char *string)
{
#ifdef OUTPUT_QUOTED_STRING
OUTPUT_QUOTED_STRING (asm_file, string);
#else
char c;
putc ('\"', asm_file);
while ((c = *string++) != 0)
{
if (ISPRINT (c))
{
if (c == '\"' || c == '\\')
putc ('\\', asm_file);
putc (c, asm_file);
}
else
fprintf (asm_file, "\\%03o", (unsigned char) c);
}
putc ('\"', asm_file);
#endif
}
void
output_file_directive (FILE *asm_file, const char *input_name)
{
int len;
const char *na;
if (input_name == NULL)
input_name = "<stdin>";
len = strlen (input_name);
na = input_name + len;
while (na > input_name)
{
if (IS_DIR_SEPARATOR (na[-1]))
break;
na--;
}
#ifdef ASM_OUTPUT_SOURCE_FILENAME
ASM_OUTPUT_SOURCE_FILENAME (asm_file, na);
#else
fprintf (asm_file, "\t.file\t");
output_quoted_string (asm_file, na);
fputc ('\n', asm_file);
#endif
}
int
wrapup_global_declarations (tree *vec, int len)
{
tree decl;
int i;
int reconsider;
int output_something = 0;
for (i = 0; i < len; i++)
{
decl = vec[i];
if (DECL_DEFER_OUTPUT (decl) != 0)
DECL_DEFER_OUTPUT (decl) = 0;
if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0)
lang_hooks.finish_incomplete_decl (decl);
}
do
{
reconsider = 0;
for (i = 0; i < len; i++)
{
decl = vec[i];
if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl))
continue;
if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
{
struct cgraph_varpool_node *node;
bool needed = 1;
node = cgraph_varpool_node (decl);
if (flag_unit_at_a_time && node->finalized)
needed = 0;
else if (node->alias)
needed = 0;
else if ((flag_unit_at_a_time && !cgraph_global_info_ready)
&& (TREE_USED (decl)
|| TREE_USED (DECL_ASSEMBLER_NAME (decl))))
;
else if (node->needed)
;
else if (DECL_COMDAT (decl))
needed = 0;
else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl)
&& (optimize || !flag_keep_static_consts
|| DECL_ARTIFICIAL (decl)))
needed = 0;
if (needed)
{
reconsider = 1;
rest_of_decl_compilation (decl, 1, 1);
}
}
}
if (reconsider)
output_something = 1;
}
while (reconsider);
return output_something;
}
void
check_global_declarations (tree *vec, int len)
{
tree decl;
int i;
for (i = 0; i < len; i++)
{
decl = vec[i];
if (TREE_CODE (decl) == VAR_DECL
&& TREE_STATIC (decl)
&& !TREE_ASM_WRITTEN (decl))
DECL_IGNORED_P (decl) = 1;
if (TREE_CODE (decl) == FUNCTION_DECL
&& DECL_INITIAL (decl) == 0
&& DECL_EXTERNAL (decl)
&& ! DECL_ARTIFICIAL (decl)
&& ! TREE_NO_WARNING (decl)
&& ! TREE_PUBLIC (decl)
&& (warn_unused_function
|| TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
{
if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
pedwarn ("%J%qF used but never defined", decl, decl);
else
warning ("%J%qF declared %<static%> but never defined",
decl, decl);
TREE_PUBLIC (decl) = 1;
assemble_external (decl);
}
if (((warn_unused_function && TREE_CODE (decl) == FUNCTION_DECL)
|| (warn_unused_variable
&& TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
&& ! DECL_IN_SYSTEM_HEADER (decl)
&& ! TREE_USED (decl)
&& ! TREE_USED (DECL_NAME (decl))
&& ! DECL_EXTERNAL (decl)
&& ! TREE_PUBLIC (decl)
&& ! TREE_THIS_VOLATILE (decl)
&& ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
&& lang_hooks.decls.warn_unused_global (decl))
warning ("%J%qD defined but not used", decl, decl);
if (errorcount == 0 && sorrycount == 0)
{
timevar_push (TV_SYMOUT);
(*debug_hooks->global_decl) (decl);
timevar_pop (TV_SYMOUT);
}
}
}
void
warn_deprecated_use (tree node)
{
if (node == 0 || !warn_deprecated_decl)
return;
if (DECL_P (node))
{
expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (node));
warning ("%qs is deprecated (declared at %s:%d)",
IDENTIFIER_POINTER (DECL_NAME (node)),
xloc.file, xloc.line);
}
else if (TYPE_P (node))
{
const char *what = NULL;
tree decl = TYPE_STUB_DECL (node);
if (TYPE_NAME (node))
{
if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
what = IDENTIFIER_POINTER (TYPE_NAME (node));
else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
&& DECL_NAME (TYPE_NAME (node)))
what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)));
}
if (decl)
{
expanded_location xloc
= expand_location (DECL_SOURCE_LOCATION (decl));
if (what)
warning ("%qs is deprecated (declared at %s:%d)", what,
xloc.file, xloc.line);
else
warning ("type is deprecated (declared at %s:%d)",
xloc.file, xloc.line);
}
else
{
if (what)
warning ("%qs is deprecated", what);
else
warning ("type is deprecated");
}
}
}
void
warn_unavailable_use (tree node)
{
if (node == 0)
return;
if (DECL_P (node))
warning ("%qs is unavailable (declared at %s:%d)",
IDENTIFIER_POINTER (DECL_NAME (node)),
DECL_SOURCE_FILE (node), DECL_SOURCE_LINE (node));
else if (TYPE_P (node))
{
const char *what = NULL;
tree decl = TYPE_STUB_DECL (node);
if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
what = IDENTIFIER_POINTER (TYPE_NAME (node));
else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
&& DECL_NAME (TYPE_NAME (node)))
what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)));
if (what)
{
if (decl)
warning ("%qs is unavailable (declared at %s:%d)", what,
DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
else
warning ("%qs is unavailable", what);
}
else if (decl)
warning ("type is unavailable (declared at %s:%d)",
DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
else
warning ("type is unavailable");
}
}
void
#ifdef USE_MAPPED_LOCATION
push_srcloc (location_t fline)
#else
push_srcloc (const char *file, int line)
#endif
{
struct file_stack *fs;
fs = xmalloc (sizeof (struct file_stack));
fs->location = input_location;
fs->next = input_file_stack;
#ifdef USE_MAPPED_LOCATION
input_location = fline;
#else
input_filename = file;
input_line = line;
#endif
input_file_stack = fs;
input_file_stack_tick++;
}
void
pop_srcloc (void)
{
struct file_stack *fs;
fs = input_file_stack;
input_location = fs->location;
input_file_stack = fs->next;
free (fs);
input_file_stack_tick++;
}
static void
compile_file (void)
{
init_cgraph ();
init_final (main_input_filename);
coverage_init (aux_base_name);
timevar_push (TV_PARSE);
lang_hooks.parse_file (set_yydebug);
lang_hooks.clear_binding_stack ();
timevar_pop (TV_PARSE);
if (flag_syntax_only)
return;
lang_hooks.decls.final_write_globals ();
cgraph_varpool_assemble_pending_decls ();
finish_aliases_2 ();
coverage_finish ();
if (flag_mudflap)
mudflap_finish_file ();
weak_finish ();
timevar_push (TV_SYMOUT);
#ifdef DWARF2_UNWIND_INFO
if (dwarf2out_do_frame ())
dwarf2out_frame_finish ();
#endif
(*debug_hooks->finish) (main_input_filename);
timevar_pop (TV_SYMOUT);
dw2_output_indirect_constants ();
process_pending_assemble_externals ();
#ifdef IDENT_ASM_OP
if (!flag_no_ident)
fprintf (asm_out_file, "%s\"GCC: (GNU) %s\"\n",
IDENT_ASM_OP, version_string);
#endif
targetm.asm_out.file_end ();
}
void
display_target_options (void)
{
int undoc, i;
static bool displayed = false;
if (displayed)
return;
displayed = true;
if (ARRAY_SIZE (target_switches) > 1
#ifdef TARGET_OPTIONS
|| ARRAY_SIZE (target_options) > 1
#endif
)
{
int doc = 0;
undoc = 0;
printf (_("\nTarget specific options:\n"));
for (i = ARRAY_SIZE (target_switches); i--;)
{
const char *option = target_switches[i].name;
const char *description = target_switches[i].description;
if (option == NULL || *option == 0)
continue;
else if (description == NULL)
{
undoc = 1;
if (extra_warnings)
printf (_(" -m%-23s [undocumented]\n"), option);
}
else if (*description != 0)
doc += printf (" -m%-23s %s\n", option, _(description));
}
#ifdef TARGET_OPTIONS
for (i = ARRAY_SIZE (target_options); i--;)
{
const char *option = target_options[i].prefix;
const char *description = target_options[i].description;
if (option == NULL || *option == 0)
continue;
else if (description == NULL)
{
undoc = 1;
if (extra_warnings)
printf (_(" -m%-23s [undocumented]\n"), option);
}
else if (*description != 0)
doc += printf (" -m%-23s %s\n", option, _(description));
}
#endif
if (undoc)
{
if (doc)
printf (_("\nThere are undocumented target specific options as well.\n"));
else
printf (_(" They exist, but they are not documented.\n"));
}
}
}
void
decode_d_option (const char *arg)
{
int c;
while (*arg)
switch (c = *arg++)
{
case 'A':
flag_debug_asm = 1;
break;
case 'p':
flag_print_asm_name = 1;
break;
case 'P':
flag_dump_rtl_in_asm = 1;
flag_print_asm_name = 1;
break;
case 'v':
graph_dump_format = vcg;
break;
case 'x':
rtl_dump_and_exit = 1;
break;
case 'y':
set_yydebug = 1;
break;
case 'D':
case 'I':
break;
case 'H':
setup_core_dumping();
break;
case 'a':
default:
if (!enable_rtl_dump_file (c))
warning ("unrecognized gcc debugging option: %c", c);
break;
}
}
const char *const debug_type_names[] =
{
"none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
};
void
set_target_switch (const char *name)
{
size_t j;
int valid_target_option = 0;
for (j = 0; j < ARRAY_SIZE (target_switches); j++)
if (!strcmp (target_switches[j].name, name))
{
if (target_switches[j].value < 0)
target_flags &= ~-target_switches[j].value;
else
target_flags |= target_switches[j].value;
if (name[0] != 0)
{
if (target_switches[j].value < 0)
target_flags_explicit |= -target_switches[j].value;
else
target_flags_explicit |= target_switches[j].value;
}
valid_target_option = 1;
}
#ifdef TARGET_OPTIONS
if (!valid_target_option)
for (j = 0; j < ARRAY_SIZE (target_options); j++)
{
int len = strlen (target_options[j].prefix);
if (target_options[j].value)
{
if (!strcmp (target_options[j].prefix, name))
{
*target_options[j].variable = target_options[j].value;
valid_target_option = 1;
}
}
else
{
if (!strncmp (target_options[j].prefix, name, len))
{
*target_options[j].variable = name + len;
valid_target_option = 1;
}
}
}
#endif
if (!valid_target_option)
error ("invalid option %qs", name);
}
void
print_version (FILE *file, const char *indent)
{
#ifndef __VERSION__
#define __VERSION__ "[?]"
#endif
fnotice (file,
#ifdef __GNUC__
"%s%s%s version %s (%s)\n%s\tcompiled by GNU C version %s.\n"
#else
"%s%s%s version %s (%s) compiled by CC.\n"
#endif
, indent, *indent != 0 ? " " : "",
lang_hooks.name, version_string, TARGET_NAME,
indent, __VERSION__);
fnotice (file, "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n",
indent, *indent != 0 ? " " : "",
PARAM_VALUE (GGC_MIN_EXPAND), PARAM_VALUE (GGC_MIN_HEAPSIZE));
}
static int
print_single_switch (FILE *file, int pos, int max,
const char *indent, const char *sep, const char *term,
const char *type, const char *name)
{
int len = strlen (sep) + strlen (type) + strlen (name);
if (pos != 0
&& pos + len > max)
{
fprintf (file, "%s", term);
pos = 0;
}
if (pos == 0)
{
fprintf (file, "%s", indent);
pos = strlen (indent);
}
fprintf (file, "%s%s%s", sep, type, name);
pos += len;
return pos;
}
static void
print_switch_values (FILE *file, int pos, int max,
const char *indent, const char *sep, const char *term)
{
size_t j;
const char **p;
randomize ();
pos = print_single_switch (file, pos, max, indent, *indent ? " " : "", term,
_("options passed: "), "");
for (p = &save_argv[1]; *p != NULL; p++)
if (**p == '-')
{
if (strcmp (*p, "-o") == 0)
{
if (p[1] != NULL)
p++;
continue;
}
if (strcmp (*p, "-quiet") == 0)
continue;
if (strcmp (*p, "-version") == 0)
continue;
if ((*p)[1] == 'd')
continue;
if ((flag_fast || flag_fastf || flag_fastcp)
&& (*p)[0] == '-' && (*p)[1] == 'O')
{
int optimize_val;
if ((*p)[2] == 's' && (*p)[3] == '\0')
continue;
optimize_val = read_integral_parameter (*p+2, 0, -1);
if (optimize_val != 3)
continue;
}
pos = print_single_switch (file, pos, max, indent, sep, term, *p, "");
}
if (pos > 0)
fprintf (file, "%s", term);
pos = print_single_switch (file, 0, max, indent, *indent ? " " : "", term,
_("options enabled: "), "");
for (j = 0; j < cl_options_count; j++)
{
if (!(cl_options[j].flag_var || cl_options[j].access_flag)
|| !(cl_options[j].flags & CL_REPORT))
continue;
if (cl_options[j].access_flag && !cl_options[j].has_set_value)
{
if (!(cl_options[j].access_flag (0, 0)))
continue;
}
else if (cl_options[j].access_flag && cl_options[j].has_set_value)
{
if ((cl_options[j].access_flag (0, 0)) != cl_options[j].set_value)
continue;
}
else if (cl_options[j].has_set_value)
{
if (*cl_options[j].flag_var != cl_options[j].set_value)
continue;
}
else
{
if (!*cl_options[j].flag_var)
continue;
}
pos = print_single_switch (file, pos, max, indent, sep, term,
"", cl_options[j].opt_text);
}
for (j = 0; j < ARRAY_SIZE (target_switches); j++)
if (target_switches[j].name[0] != '\0'
&& target_switches[j].value > 0
&& ((target_switches[j].value & target_flags)
== target_switches[j].value))
{
pos = print_single_switch (file, pos, max, indent, sep, term,
"-m", target_switches[j].name);
}
#ifdef TARGET_OPTIONS
for (j = 0; j < ARRAY_SIZE (target_options); j++)
if (*target_options[j].variable != NULL)
{
char prefix[256];
sprintf (prefix, "-m%s", target_options[j].prefix);
pos = print_single_switch (file, pos, max, indent, sep, term,
prefix, *target_options[j].variable);
}
#endif
fprintf (file, "%s", term);
}
static void
init_asm_output (const char *name)
{
if (name == NULL && asm_file_name == 0)
asm_out_file = stdout;
else
{
if (asm_file_name == 0)
{
int len = strlen (dump_base_name);
char *dumpname = xmalloc (len + 6);
memcpy (dumpname, dump_base_name, len + 1);
strip_off_ending (dumpname, len);
strcat (dumpname, ".s");
asm_file_name = dumpname;
}
if (!strcmp (asm_file_name, "-"))
asm_out_file = stdout;
else
{
if (flag_save_repository
&& flag_pch_file && !flag_debug_only_used_symbols)
{
asm_file_name2 = (char *) xmalloc (strlen (asm_file_name) + 3);
sprintf (asm_file_name2, "%s.t", asm_file_name);
asm_out_file = fopen (asm_file_name2, "w+b");
}
else
asm_out_file = fopen (asm_file_name, "w+b");
}
if (asm_out_file == 0)
fatal_error ("can%'t open %s for writing: %m", asm_file_name);
}
if (!flag_syntax_only)
{
targetm.asm_out.file_start ();
#ifdef ASM_COMMENT_START
if (flag_verbose_asm)
{
print_version (asm_out_file, ASM_COMMENT_START);
print_switch_values (asm_out_file, 0, MAX_LINE,
ASM_COMMENT_START, " ", "\n");
fprintf (asm_out_file, "\n");
}
#endif
}
}
void *
default_get_pch_validity (size_t *len)
{
#ifdef TARGET_OPTIONS
size_t i;
#endif
char *result, *r;
*len = sizeof (target_flags) + 2;
#ifdef TARGET_OPTIONS
for (i = 0; i < ARRAY_SIZE (target_options); i++)
{
*len += 1;
if (*target_options[i].variable)
*len += strlen (*target_options[i].variable);
}
#endif
result = r = xmalloc (*len);
r[0] = flag_pic;
r[1] = flag_pie;
r += 2;
memcpy (r, &target_flags, sizeof (target_flags));
r += sizeof (target_flags);
#ifdef TARGET_OPTIONS
for (i = 0; i < ARRAY_SIZE (target_options); i++)
{
const char *str = *target_options[i].variable;
size_t l;
if (! str)
str = "";
l = strlen (str) + 1;
memcpy (r, str, l);
r += l;
}
#endif
return result;
}
const char *
default_pch_valid_p (const void *data_p, size_t len)
{
const char *data = (const char *)data_p;
const char *flag_that_differs = NULL;
size_t i;
if (data[0] != flag_pic)
return _("created and used with different settings of -fpic");
if (data[1] != flag_pie)
return _("created and used with different settings of -fpie");
data += 2;
if (memcmp (data, &target_flags, sizeof (target_flags)) != 0)
{
for (i = 0; i < ARRAY_SIZE (target_switches); i++)
{
int bits;
int tf;
memcpy (&tf, data, sizeof (target_flags));
bits = target_switches[i].value;
if (bits < 0)
bits = -bits;
if ((target_flags & bits) != (tf & bits))
{
flag_that_differs = target_switches[i].name;
goto make_message;
}
}
gcc_unreachable ();
}
data += sizeof (target_flags);
len -= sizeof (target_flags);
#ifdef TARGET_OPTIONS
for (i = 0; i < ARRAY_SIZE (target_options); i++)
{
const char *str = *target_options[i].variable;
size_t l;
if (! str)
str = "";
l = strlen (str) + 1;
if (len < l || memcmp (data, str, l) != 0)
{
flag_that_differs = target_options[i].prefix;
goto make_message;
}
data += l;
len -= l;
}
#endif
return NULL;
make_message:
{
char *r;
asprintf (&r, _("created and used with differing settings of '-m%s'"),
flag_that_differs);
if (r == NULL)
return _("out of memory");
return r;
}
}
static bool
default_tree_printer (pretty_printer * pp, text_info *text)
{
tree t;
switch (*text->format_spec)
{
case 'D':
t = va_arg (*text->args_ptr, tree);
if (DECL_DEBUG_EXPR (t) && DECL_DEBUG_EXPR_IS_FROM (t))
t = DECL_DEBUG_EXPR (t);
break;
case 'F':
case 'T':
t = va_arg (*text->args_ptr, tree);
break;
default:
return false;
}
if (DECL_P (t))
{
const char *n = DECL_NAME (t)
? lang_hooks.decl_printable_name (t, 2)
: "<anonymous>";
pp_string (pp, n);
}
else
dump_generic_node (pp, t, 0, 0, 0);
return true;
}
static void
general_init (const char *argv0)
{
const char *p;
p = argv0 + strlen (argv0);
while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
--p;
progname = p;
xmalloc_set_program_name (progname);
hex_init ();
unlock_std_streams ();
gcc_init_libintl ();
diagnostic_initialize (global_dc);
pp_format_decoder (global_dc->printer) = &default_tree_printer;
#ifdef SIGSEGV
signal (SIGSEGV, crash_signal);
#endif
#ifdef SIGILL
signal (SIGILL, crash_signal);
#endif
#ifdef SIGBUS
signal (SIGBUS, crash_signal);
#endif
#ifdef SIGABRT
signal (SIGABRT, crash_signal);
#endif
#if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
signal (SIGIOT, crash_signal);
#endif
if (signal (SIGINT, SIG_IGN) != SIG_IGN)
signal (SIGINT, interrupt_signal);
if (signal (SIGKILL, SIG_IGN) != SIG_IGN)
signal (SIGINT, interrupt_signal);
if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
signal (SIGTERM, interrupt_signal);
#ifdef SIGFPE
signal (SIGFPE, crash_signal);
#endif
(*host_hooks.extra_signals)();
#ifdef RLIMIT_STACK
{
struct rlimit rlim;
getrlimit (RLIMIT_STACK, &rlim);
rlim.rlim_cur = rlim.rlim_max;
setrlimit (RLIMIT_STACK, &rlim);
}
#endif
init_ggc ();
init_stringpool ();
linemap_init (&line_table);
init_ttree ();
init_reg_sets ();
add_params (lang_independent_params, LAST_PARAM);
init_ggc_heuristics();
init_tree_optimization_passes ();
}
static void
process_options (void)
{
no_backend = lang_hooks.post_options (&main_input_filename);
#ifndef USE_MAPPED_LOCATION
input_filename = main_input_filename;
#endif
#ifdef OVERRIDE_OPTIONS
OVERRIDE_OPTIONS;
#endif
if (flag_short_enums == 2)
flag_short_enums = targetm.default_short_enums ();
if (aux_base_name)
;
else if (main_input_filename)
{
char *name = xstrdup (lbasename (main_input_filename));
strip_off_ending (name, strlen (name));
aux_base_name = name;
}
else
aux_base_name = "gccaux";
if (align_loops <= 0) align_loops = 1;
if (align_loops_max_skip > align_loops || !align_loops)
align_loops_max_skip = align_loops - 1;
align_loops_log = floor_log2 (align_loops * 2 - 1);
if (align_jumps <= 0) align_jumps = 1;
if (align_jumps_max_skip > align_jumps || !align_jumps)
align_jumps_max_skip = align_jumps - 1;
align_jumps_log = floor_log2 (align_jumps * 2 - 1);
if (align_labels <= 0) align_labels = 1;
align_labels_log = floor_log2 (align_labels * 2 - 1);
if (align_labels_max_skip > align_labels || !align_labels)
align_labels_max_skip = align_labels - 1;
if (align_functions <= 0) align_functions = 1;
align_functions_log = floor_log2 (align_functions * 2 - 1);
if (flag_unroll_all_loops)
flag_unroll_loops = 1;
if (flag_unroll_loops || flag_peel_loops)
flag_rerun_cse_after_loop = 1;
if (flag_loop_optimize2)
flag_loop_optimize = 0;
if (flag_move_loop_invariants
|| flag_unswitch_loops
|| flag_peel_loops
|| flag_unroll_loops
|| flag_branch_on_count_reg)
flag_loop_optimize2 = 1;
if (flag_non_call_exceptions)
flag_asynchronous_unwind_tables = 1;
if (flag_asynchronous_unwind_tables)
flag_unwind_tables = 1;
if (flag_unit_at_a_time && ! lang_hooks.callgraph.expand_function)
flag_unit_at_a_time = 0;
if (flag_value_profile_transformations)
flag_profile_values = 1;
if (flag_speculative_prefetching)
{
flag_profile_values = 1;
flag_prefetch_loop_arrays = 0;
}
#ifndef INSN_SCHEDULING
if (flag_schedule_insns || flag_schedule_insns_after_reload)
warning ("instruction scheduling not supported on this target machine");
#endif
#ifndef DELAY_SLOTS
if (flag_delayed_branch)
warning ("this target machine does not have delayed branches");
#endif
if (flag_tree_based_profiling && flag_profile_values)
sorry ("value-based profiling not yet implemented in trees.");
user_label_prefix = USER_LABEL_PREFIX;
if (flag_leading_underscore != -1)
{
if (user_label_prefix[0] == 0 ||
(user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
{
user_label_prefix = flag_leading_underscore ? "_" : "";
}
else
warning ("-f%sleading-underscore not supported on this target machine",
flag_leading_underscore ? "" : "no-");
}
if (version_flag)
{
print_version (stderr, "");
if (! quiet_flag)
print_switch_values (stderr, 0, MAX_LINE, "", " ", "\n");
}
if (flag_syntax_only)
{
write_symbols = NO_DEBUG;
profile_flag = 0;
}
if (debug_info_level == DINFO_LEVEL_NONE)
write_symbols = NO_DEBUG;
if (PREFERRED_DEBUGGING_TYPE == NO_DEBUG)
default_debug_hooks = &do_nothing_debug_hooks;
#if defined(DBX_DEBUGGING_INFO)
else if (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG)
default_debug_hooks = &dbx_debug_hooks;
#endif
#if defined(XCOFF_DEBUGGING_INFO)
else if (PREFERRED_DEBUGGING_TYPE == XCOFF_DEBUG)
default_debug_hooks = &xcoff_debug_hooks;
#endif
#ifdef SDB_DEBUGGING_INFO
else if (PREFERRED_DEBUGGING_TYPE == SDB_DEBUG)
default_debug_hooks = &sdb_debug_hooks;
#endif
#ifdef DWARF2_DEBUGGING_INFO
else if (PREFERRED_DEBUGGING_TYPE == DWARF2_DEBUG)
default_debug_hooks = &dwarf2_debug_hooks;
#endif
#ifdef VMS_DEBUGGING_INFO
else if (PREFERRED_DEBUGGING_TYPE == VMS_DEBUG
|| PREFERRED_DEBUGGING_TYPE == VMS_AND_DWARF2_DEBUG)
default_debug_hooks = &vmsdbg_debug_hooks;
#endif
debug_hooks = &do_nothing_debug_hooks;
if (write_symbols == NO_DEBUG)
;
#if defined(DBX_DEBUGGING_INFO)
else if (write_symbols == DBX_DEBUG)
debug_hooks = &dbx_debug_hooks;
#endif
#if defined(XCOFF_DEBUGGING_INFO)
else if (write_symbols == XCOFF_DEBUG)
debug_hooks = &xcoff_debug_hooks;
#endif
#ifdef SDB_DEBUGGING_INFO
else if (write_symbols == SDB_DEBUG)
debug_hooks = &sdb_debug_hooks;
#endif
#ifdef DWARF2_DEBUGGING_INFO
else if (write_symbols == DWARF2_DEBUG)
debug_hooks = &dwarf2_debug_hooks;
#endif
#ifdef VMS_DEBUGGING_INFO
else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
debug_hooks = &vmsdbg_debug_hooks;
#endif
else
error ("target system does not support the \"%s\" debug format",
debug_type_names[write_symbols]);
if (debug_info_level < DINFO_LEVEL_NORMAL
|| debug_hooks->var_location == do_nothing_debug_hooks.var_location)
{
if (flag_var_tracking == 1)
{
if (debug_info_level < DINFO_LEVEL_NORMAL)
warning ("variable tracking requested, but useless unless "
"producing debug info");
else
warning ("variable tracking requested, but not supported "
"by this debug format");
}
flag_var_tracking = 0;
}
if (flag_rename_registers == AUTODETECT_FLAG_VAR_TRACKING)
flag_rename_registers = default_debug_hooks->var_location
!= do_nothing_debug_hooks.var_location;
if (flag_var_tracking == AUTODETECT_FLAG_VAR_TRACKING)
flag_var_tracking = optimize >= 1;
if (flag_gen_aux_info)
{
aux_info_file = fopen (aux_info_file_name, "w");
if (aux_info_file == 0)
fatal_error ("can%'t open %s: %m", aux_info_file_name);
}
if (! targetm.have_named_sections)
{
if (flag_function_sections)
{
warning ("-ffunction-sections not supported for this target");
flag_function_sections = 0;
}
if (flag_data_sections)
{
warning ("-fdata-sections not supported for this target");
flag_data_sections = 0;
}
}
if (flag_function_sections && profile_flag)
{
warning ("-ffunction-sections disabled; it makes profiling impossible");
flag_function_sections = 0;
}
#ifndef HAVE_prefetch
if (flag_prefetch_loop_arrays)
{
warning ("-fprefetch-loop-arrays not supported for this target");
flag_prefetch_loop_arrays = 0;
}
if (flag_speculative_prefetching)
{
if (flag_speculative_prefetching_set)
warning ("-fspeculative-prefetching not supported for this target");
flag_speculative_prefetching = 0;
}
#else
if (flag_prefetch_loop_arrays && !HAVE_prefetch)
{
warning ("-fprefetch-loop-arrays not supported for this target (try -march switches)");
flag_prefetch_loop_arrays = 0;
}
if (flag_speculative_prefetching && !HAVE_prefetch)
{
if (flag_speculative_prefetching_set)
warning ("-fspeculative-prefetching not supported for this target (try -march switches)");
flag_speculative_prefetching = 0;
}
#endif
if (flag_prefetch_loop_arrays && optimize_size)
{
warning ("-fprefetch-loop-arrays is not supported with -Os");
flag_prefetch_loop_arrays = 0;
}
#ifndef OBJECT_FORMAT_ELF
if (flag_function_sections && write_symbols != NO_DEBUG)
warning ("-ffunction-sections may affect debugging on some targets");
#endif
if (flag_signaling_nans)
flag_trapping_math = 1;
if (flag_cx_limited_range)
flag_complex_method = 0;
cl_pf_opts_cooked = cl_pf_opts;
}
static void
backend_init (void)
{
init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL
|| debug_info_level == DINFO_LEVEL_VERBOSE
#ifdef VMS_DEBUGGING_INFO
|| debug_info_level > DINFO_LEVEL_NONE
#endif
|| flag_test_coverage);
init_rtlanal ();
init_regs ();
init_fake_stack_mems ();
init_alias_once ();
init_loop ();
init_reload ();
init_function_once ();
init_varasm_once ();
init_dummy_function_start ();
init_expmed ();
init_caller_save ();
expand_dummy_function_end ();
}
static int
lang_dependent_init (const char *name)
{
location_t save_loc = input_location;
if (dump_base_name == 0)
dump_base_name = name && name[0] ? name : "gccdump";
#ifdef USE_MAPPED_LOCATION
input_location = BUILTINS_LOCATION;
#else
input_filename = "<built-in>";
input_line = 0;
#endif
if (lang_hooks.init () == 0)
return 0;
input_location = save_loc;
init_asm_output (name);
init_eh ();
init_optabs ();
init_dummy_function_start ();
init_expr_once ();
init_set_costs ();
expand_dummy_function_end ();
timevar_push (TV_SYMOUT);
#ifdef DWARF2_UNWIND_INFO
if (dwarf2out_do_frame ())
dwarf2out_frame_init ();
#endif
(*debug_hooks->init) (name);
timevar_pop (TV_SYMOUT);
return 1;
}
static void
finalize (void)
{
if (flag_gen_aux_info)
{
fclose (aux_info_file);
if (errorcount)
unlink (aux_info_file_name);
}
if (asm_out_file)
{
if (ferror (asm_out_file) != 0)
fatal_error ("error writing to %s: %m", asm_file_name);
if (flag_save_repository
&& flag_pch_file
&& !flag_debug_only_used_symbols)
unlink (asm_file_name2);
else if (fclose (asm_out_file) != 0)
fatal_error ("error closing %s: %m", asm_file_name);
}
finish_optimization_passes ();
if (mem_report)
{
ggc_print_statistics ();
stringpool_statistics ();
dump_tree_statistics ();
dump_rtx_statistics ();
dump_varray_statistics ();
dump_alloc_pool_statistics ();
dump_ggc_loc_statistics ();
}
free_reg_info ();
lang_hooks.finish ();
}
static void
do_compile (void)
{
if (time_report || !quiet_flag || flag_detailed_statistics)
timevar_init ();
timevar_start (TV_TOTAL);
process_options ();
if (!errorcount)
{
init_adjust_machine_modes ();
if (!no_backend)
backend_init ();
if (lang_dependent_init (main_input_filename))
compile_file ();
finalize ();
}
timevar_stop (TV_TOTAL);
timevar_print (stderr);
}
int
toplev_main (unsigned int argc, const char **argv)
{
save_argv = argv;
general_init (argv[0]);
decode_options (argc, argv);
randomize ();
if (!exit_after_options)
do_compile ();
if (errorcount || sorrycount)
return (FATAL_EXIT_CODE);
return (SUCCESS_EXIT_CODE);
}