Subversion Repositories scarts

/* Top level of GCC compilers (cc1, cc1plus, etc.)

   Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,

   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006

   Free Software Foundation, Inc.

This file is part of GCC.

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

Software Foundation; either version 2, or (at your option) any later

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING.  If not, write to the Free

Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA

02110-1301, USA.  */

/* This is the top level of cc1/c++.

   It parses command args, opens files, invokes the various passes

   in the proper order, and counts the time used by each.

   Error messages and low-level interface to malloc also handled here.  */

#include "config.h"

#undef FLOAT /* This is for hpux. They should change hpux.  */

#undef FFS  /* Some systems define this in param.h.  */

#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"           /* Needed for external data

                                   declarations for e.g. AIX 4.x.  */

#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 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 *);

/* Nonzero to dump debug info whilst parsing (-dy option).  */

static int set_yydebug;

/* True if we don't need a backend (e.g. preprocessing only).  */

static bool no_backend;

/* Length of line when printing switch values.  */

#define MAX_LINE 75

/* Name of program invoked, sans directories.  */

const char *progname;

/* Copy of argument vector to toplev_main.  */

static const char **save_argv;

/* Name of top-level original source file (what was input to cpp).

   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.  */

const char *main_input_filename;

#ifndef USE_MAPPED_LOCATION

location_t unknown_location = { NULL, 0 };

#endif

/* Used to enable -fvar-tracking, -fweb and -frename-registers according

   to optimize and default_debug_hooks in process_options ().  */

#define AUTODETECT_VALUE 2

/* Current position in real source file.  */

location_t input_location;

struct line_maps line_table;

/* Nonzero if it is unsafe to create any new pseudo registers.  */

int no_new_pseudos;

/* Stack of currently pending input files.  */

struct file_stack *input_file_stack;

/* Incremented on each change to input_file_stack.  */

int input_file_stack_tick;

/* Name to use as base of names for dump output files.  */

const char *dump_base_name;

/* Name to use as a base for auxiliary output files.  */

const char *aux_base_name;

/* Bit flags that specify the machine subtype we are compiling for.

   Bits are tested using macros TARGET_... defined in the tm.h file

   and set by `-m...' switches.  Must be defined in rtlanal.c.  */

extern int target_flags;

/* A mask of target_flags that includes bit X if X was set or cleared

   on the command line.  */

int target_flags_explicit;

/* Debug hooks - dependent upon command line options.  */

const struct gcc_debug_hooks *debug_hooks;

/* Debug hooks - target default.  */

static const struct gcc_debug_hooks *default_debug_hooks;

/* Other flags saying which kinds of debugging dump have been requested.  */

int rtl_dump_and_exit;

int flag_print_asm_name;

enum graph_dump_types graph_dump_format;

/* Name for output file of assembly code, specified with -o.  */

const char *asm_file_name;

/* Nonzero means do optimizations.  -O.

   Particular numeric values stand for particular amounts of optimization;

   thus, -O2 stores 2 here.  However, the optimizations beyond the basic

   ones are not controlled directly by this variable.  Instead, they are

   controlled by individual `flag_...' variables that are defaulted

   based on this variable.  */

int optimize = 0;

/* Nonzero means optimize for size.  -Os.

   The only valid values are zero and nonzero. When optimize_size is

   nonzero, optimize defaults to 2, but certain individual code

   bloating optimizations are disabled.  */

int optimize_size = 0;

/* The FUNCTION_DECL for the function currently being compiled,

   or 0 if between functions.  */

tree current_function_decl;

/* Set to the FUNC_BEGIN label of the current function, or NULL

   if none.  */

const char * current_function_func_begin_label;

/* Temporarily suppress certain warnings.

   This is set while reading code from a system header file.  */

int in_system_header = 0;

/* Nonzero means to collect statistics which might be expensive

   and to print them when we are done.  */

int flag_detailed_statistics = 0;

/* A random sequence of characters, unless overridden by user.  */

const char *flag_random_seed;

/* 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

   user has specified a particular random seed.  */

unsigned local_tick;

/* -f flags.  */

/* Nonzero means `char' should be signed.  */

int flag_signed_char;

/* Nonzero means give an enum type only as many bytes as it needs.  A value

   of 2 means it has not yet been initialized.  */

int flag_short_enums;

/* Nonzero if structures and unions should be returned in memory.

   This should only be defined if compatibility with another compiler or

   with an ABI is needed, because it results in slower code.  */

#ifndef DEFAULT_PCC_STRUCT_RETURN

#define DEFAULT_PCC_STRUCT_RETURN 1

#endif

/* Nonzero for -fpcc-struct-return: return values the same way PCC does.  */

int flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;

/* 0 means straightforward implementation of complex divide acceptable.

   1 means wide ranges of inputs must work for complex divide.

   2 means C99-like requirements for complex multiply and divide.  */

int flag_complex_method = 1;

/* Nonzero means that we don't want inlining by virtue of -fno-inline,

   not just because the tree inliner turned us off.  */

int flag_really_no_inline = 2;

/* Nonzero means we should be saving declaration info into a .X file.  */

int flag_gen_aux_info = 0;

/* Specified name of aux-info file.  */

const char *aux_info_file_name;

/* Nonzero if we are compiling code for a shared library, zero for

   executable.  */

int flag_shlib;

/* Generate code for GNU or NeXT Objective-C runtime environment.  */

#ifdef NEXT_OBJC_RUNTIME

int flag_next_runtime = 1;

#else

int flag_next_runtime = 0;

#endif

/* Set to the default thread-local storage (tls) model to use.  */

enum tls_model flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;

/* Nonzero means change certain warnings into errors.

   Usually these are warnings about failure to conform to some standard.  */

int flag_pedantic_errors = 0;

/* -dA causes debug commentary information to be produced in

   the generated assembly code (to make it more readable).  This option

   is generally only of use to those who actually need to read the

   generated assembly code (perhaps while debugging the compiler itself).

   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.  */

int flag_debug_asm = 0;

/* -dP causes the rtl to be emitted as a comment in assembly.  */

int flag_dump_rtl_in_asm = 0;

/* When non-NULL, indicates that whenever space is allocated on the

   stack, the resulting stack pointer must not pass this

   address---that is, for stacks that grow downward, the stack pointer

   must always be greater than or equal to this address; for stacks

   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

   the support provided depends on the backend.  */

rtx stack_limit_rtx;

/* If one, renumber instruction UIDs to reduce the number of

   unused UIDs if there are a lot of instructions.  If greater than

   one, unconditionally renumber instruction UIDs.  */

int flag_renumber_insns = 1;

/* Nonzero if we should track variables.  When

   flag_var_tracking == AUTODETECT_VALUE it will be set according

   to optimize, debug_info_level and debug_hooks in process_options ().  */

int flag_var_tracking = AUTODETECT_VALUE;

/* True if the user has tagged the function with the 'section'

   attribute.  */

bool user_defined_section_attribute = false;

/* Values of the -falign-* flags: how much to align labels in code.

   For each variable, there is an _log variant which is the power

   of two not less than the variable, for .align output.  */

int align_loops_log;

int align_loops_max_skip;

int align_jumps_log;

int align_jumps_max_skip;

int align_labels_log;

int align_labels_max_skip;

int align_functions_log;

/* Like align_functions_log above, but used by front-ends to force the

   minimum function alignment.  Zero means no alignment is forced.  */

int force_align_functions_log;

typedef struct

{

  const char *const string;

  int *const variable;

  const int on_value;

}

lang_independent_options;

/* Nonzero if subexpressions must be evaluated from left-to-right.  */

int flag_evaluation_order = 0;

/* The user symbol prefix after having resolved same.  */

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 }

};

/* Output files for assembler code (real compiler output)

   and debugging dumps.  */

FILE *asm_out_file;

FILE *aux_info_file;

FILE *dump_file = NULL;

const char *dump_file_name;

/* The current working directory of a translation.  It's generally the

   directory from which compilation was initiated, but a preprocessed

   file may specify the original directory in which it was

   created.  */

static const char *src_pwd;

/* Initialize src_pwd with the given string, and return true.  If it

   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

   initialized yet.  */

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;

}

/* Return the directory from which the translation unit was initiated,

   in case set_src_pwd() was not called before to assign it a

   different value.  */

const char *

get_src_pwd (void)

{

  if (! src_pwd)

    {

      src_pwd = getpwd ();

      if (!src_pwd)

        src_pwd = ".";

    }

   return src_pwd;

}

/* Called when the start of a function definition is parsed,

   this function prints on stderr the name of the function.  */

void

announce_function (tree decl)

{

  if (!quiet_flag)

    {

      if (rtl_dump_and_exit)

        fprintf (stderr, "%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));

      else

        fprintf (stderr, " %s", lang_hooks.decl_printable_name (decl, 2));

      fflush (stderr);

      pp_needs_newline (global_dc->printer) = true;

      diagnostic_set_last_function (global_dc);

    }

}

/* Set up a default flag_random_seed and local_tick, unless the user

   already specified one.  */

static void

randomize (void)

{

  if (!flag_random_seed)

    {

      unsigned HOST_WIDE_INT value;

      static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];

      /* Get some more or less random data.  */

#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;

}

/* Decode the string P as an integral parameter.

   If the string is indeed an integer return its numeric value else

   issue an Invalid Option error for the option PNAME and return DEFVAL.

   If PNAME is zero just return DEFVAL, do not call error.  */

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);

}

/* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.

   If X is 0, return -1.  */

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;

}

/* Return the logarithm of X, base 2, considering X unsigned,

   if X is a power of 2.  Otherwise, returns -1.  */

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

}

/* Handler for fatal signals, such as SIGSEGV.  These are transformed

   into ICE messages, which is much more user friendly.  In case the

   error printer crashes, reset the signal to prevent infinite recursion.  */

static void

crash_signal (int signo)

{

  signal (signo, SIG_DFL);

  /* If we crashed while processing an ASM statement, then be a little more

     graceful.  It's most likely the user's fault.  */

  if (this_is_asm_operands)

    {

      output_operand_lossage ("unrecoverable error");

      exit (FATAL_EXIT_CODE);

    }

  internal_error ("%s", strsignal (signo));

}

/* Arrange to dump core on error.  (The regular error message is still

   printed first, except in the case of abort().)  */

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);

}

/* 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

   our front ends, we strip off an ending of a period followed by

   up to five characters.  (Java uses ".class".)  */

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;

        }

    }

}

/* Output a quoted string.  */

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

}

/* Output a file name in the form wanted by System V.  */

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;

  /* NA gets INPUT_NAME sans directory names.  */

  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

}

/* A subroutine of wrapup_global_declarations.  We've come to the end of

   the compilation unit.  All deferred variables should be undeferred,

   and all incomplete decls should be finalized.  */

void

wrapup_global_declaration_1 (tree decl)

{

  /* We're not deferring this any longer.  Assignment is conditional to

     avoid needlessly dirtying PCH pages.  */

  if (CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_WITH_VIS)

      && 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);

}

/* A subroutine of wrapup_global_declarations.  Decide whether or not DECL

   needs to be output.  Return true if it is output.  */

bool

wrapup_global_declaration_2 (tree decl)

{

  if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl))

    return false;

  /* Don't write out static consts, unless we still need them.

     We also keep static consts if not optimizing (for debugging),

     unless the user specified -fno-keep-static-consts.

     ??? They might be better written into the debug information.

     This is possible when using DWARF.

     A language processor that wants static constants to be always

     written out (even if it is not used) is responsible for

     calling rest_of_decl_compilation itself.  E.g. the C front-end

     calls rest_of_decl_compilation from finish_decl.

     One motivation for this is that is conventional in some

     environments to write things like:

     static const char rcsid[] = "... version string ...";

     intending to force the string to be in the executable.

     A language processor that would prefer to have unneeded

     static constants "optimized away" would just defer writing

     them out until here.  E.g. C++ does this, because static

     constants are often defined in header files.

     ??? A tempting alternative (for both C and C++) would be

     to force a constant to be written if and only if it is

     defined in a main file, as opposed to an include file.  */

  if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))

    {

      struct cgraph_varpool_node *node;

      bool needed = true;

      node = cgraph_varpool_node (decl);

      if (node->finalized)

        needed = false;

      else if (node->alias)

        needed = false;