Subversion Repositories openrisc

/* 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, 2007, 2008, 2009, 2010

   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 3, 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 COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

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

#include "tree-pass.h"

#include "gimple.h"

#include "tree-ssa-alias.h"

#include "plugin.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);

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

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

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

const char *dump_base_name;

/* Directory used for dump output files.  */

const char *dump_dir_name;

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

const char *aux_base_name;

/* Prefix for profile data files */

const char *profile_data_prefix;

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

/* True if this is the lto front end.  This is used to disable

   gimple generation and lowering passes that are normally run on the

   output of a front end.  These passes must be bypassed for lto since

   they have already been done before the gimple was written.  */

bool in_lto_p = false;

/* Nonzero if we should write GIMPLE bytecode for link-time optimization.  */

int flag_generate_lto;

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

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

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

/* Set the default region and algorithm for the integrated register

   allocator.  */

enum ira_algorithm flag_ira_algorithm = IRA_ALGORITHM_CB;

enum ira_region flag_ira_region = IRA_REGION_MIXED;

/* Set the default value for -fira-verbose.  */

unsigned int flag_ira_verbose = 5;

/* Set the default for excess precision.  */

enum excess_precision flag_excess_precision_cmdline = EXCESS_PRECISION_DEFAULT;

enum excess_precision flag_excess_precision = EXCESS_PRECISION_DEFAULT;

/* Nonzero means change certain warnings into errors.

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

int flag_pedantic_errors = 0;

/* Nonzero means make permerror produce warnings instead of errors.  */

int flag_permissive = 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;

/* Positive if we should track variables, negative if we should run

   the var-tracking pass only to discard debug annotations, zero if

   we're not to run it.  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;

/* Positive if we should track variables at assignments, negative if

   we should run the var-tracking pass only to discard debug

   annotations.  When flag_var_tracking_assignments ==

   AUTODETECT_VALUE it will be set according to flag_var_tracking.  */

int flag_var_tracking_assignments = AUTODETECT_VALUE;

/* Nonzero if we should toggle flag_var_tracking_assignments after

   processing options and computing its default.  */

int flag_var_tracking_assignments_toggle = 0;

/* Type of stack check.  */

enum stack_check_type flag_stack_check = NO_STACK_CHECK;

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

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, false, MIN, MAX, HELP },

#include "params.def"

#undef DEFPARAM

  { NULL, 0, false, 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_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl))));

      else

        fprintf (stderr, " %s",

                 identifier_to_locale (lang_hooks.decl_printable_name (decl, 2)));

      fflush (stderr);

      pp_needs_newline (global_dc->printer) = true;

      diagnostic_set_last_function (global_dc, (diagnostic_info *) NULL);

    }

}

/* Initialize local_tick with the time of day, or -1 if

   flag_random_seed is set.  */

static void

init_local_tick (void)

{

  if (!flag_random_seed)

    {

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

    }

  else

    local_tick = -1;

}

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

   already specified one.  Must be called after init_local_tick.  */

static void

init_random_seed (void)

{

  unsigned HOST_WIDE_INT value;

  static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];

  value = local_tick ^ getpid ();

  sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);

  flag_random_seed = random_seed;

}

/* Obtain the random_seed string.  Unless NOINIT, initialize it if

   it's not provided in the command line.  */

const char *

get_random_seed (bool noinit)

{

  if (!flag_random_seed && !noinit)

    init_random_seed ();

  return flag_random_seed;

}

/* Modify the random_seed string to VAL.  Return its previous

   value.  */

const char *

set_random_seed (const char *val)

{

  const char *old = flag_random_seed;

  flag_random_seed = val;

  return old;

}

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

}

#if GCC_VERSION < 3004

/* The functions floor_log2 and exact_log2 are defined as inline

   functions in toplev.h if GCC_VERSION >= 3004.  The definitions here

   are used for older versions of gcc.  */

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

  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;

  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;

  return floor_log2 (x);

}

#endif /* GCC_VERSION < 3004 */

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

  else

    input_name = remap_debug_filename (input_name);

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

  putc ('\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