LCOV - code coverage report
Current view: top level - gcc - toplev.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 756 991 76.3 %
Date: 2020-03-28 11:57:23 Functions: 40 49 81.6 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Top level of GCC compilers (cc1, cc1plus, etc.)
       2                 :            :    Copyright (C) 1987-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify it under
       7                 :            : the terms of the GNU General Public License as published by the Free
       8                 :            : Software Foundation; either version 3, or (at your option) any later
       9                 :            : version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : /* This is the top level of cc1/c++.
      21                 :            :    It parses command args, opens files, invokes the various passes
      22                 :            :    in the proper order, and counts the time used by each.
      23                 :            :    Error messages and low-level interface to malloc also handled here.  */
      24                 :            : 
      25                 :            : #include "config.h"
      26                 :            : #include "system.h"
      27                 :            : #include "coretypes.h"
      28                 :            : #include "backend.h"
      29                 :            : #include "target.h"
      30                 :            : #include "rtl.h"
      31                 :            : #include "tree.h"
      32                 :            : #include "gimple.h"
      33                 :            : #include "alloc-pool.h"
      34                 :            : #include "timevar.h"
      35                 :            : #include "memmodel.h"
      36                 :            : #include "tm_p.h"
      37                 :            : #include "optabs-libfuncs.h"
      38                 :            : #include "insn-config.h"
      39                 :            : #include "ira.h"
      40                 :            : #include "recog.h"
      41                 :            : #include "cgraph.h"
      42                 :            : #include "coverage.h"
      43                 :            : #include "diagnostic.h"
      44                 :            : #include "varasm.h"
      45                 :            : #include "tree-inline.h"
      46                 :            : #include "realmpfr.h" /* For GMP/MPFR/MPC versions, in print_version.  */
      47                 :            : #include "version.h"
      48                 :            : #include "flags.h"
      49                 :            : #include "insn-attr.h"
      50                 :            : #include "output.h"
      51                 :            : #include "toplev.h"
      52                 :            : #include "expr.h"
      53                 :            : #include "intl.h"
      54                 :            : #include "tree-diagnostic.h"
      55                 :            : #include "reload.h"
      56                 :            : #include "lra.h"
      57                 :            : #include "dwarf2asm.h"
      58                 :            : #include "debug.h"
      59                 :            : #include "common/common-target.h"
      60                 :            : #include "langhooks.h"
      61                 :            : #include "cfgloop.h" /* for init_set_costs */
      62                 :            : #include "hosthooks.h"
      63                 :            : #include "opts.h"
      64                 :            : #include "opts-diagnostic.h"
      65                 :            : #include "stringpool.h"
      66                 :            : #include "attribs.h"
      67                 :            : #include "asan.h"
      68                 :            : #include "tsan.h"
      69                 :            : #include "plugin.h"
      70                 :            : #include "context.h"
      71                 :            : #include "pass_manager.h"
      72                 :            : #include "auto-profile.h"
      73                 :            : #include "dwarf2out.h"
      74                 :            : #include "ipa-reference.h"
      75                 :            : #include "symbol-summary.h"
      76                 :            : #include "tree-vrp.h"
      77                 :            : #include "ipa-prop.h"
      78                 :            : #include "gcse.h"
      79                 :            : #include "omp-offload.h"
      80                 :            : #include "hsa-common.h"
      81                 :            : #include "edit-context.h"
      82                 :            : #include "tree-pass.h"
      83                 :            : #include "dumpfile.h"
      84                 :            : #include "ipa-fnsummary.h"
      85                 :            : #include "dump-context.h"
      86                 :            : #include "print-tree.h"
      87                 :            : #include "optinfo-emit-json.h"
      88                 :            : 
      89                 :            : #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
      90                 :            : #include "dbxout.h"
      91                 :            : #endif
      92                 :            : 
      93                 :            : #ifdef XCOFF_DEBUGGING_INFO
      94                 :            : #include "xcoffout.h"         /* Needed for external data declarations. */
      95                 :            : #endif
      96                 :            : 
      97                 :            : #include "selftest.h"
      98                 :            : 
      99                 :            : #ifdef HAVE_isl
     100                 :            : #include <isl/version.h>
     101                 :            : #endif
     102                 :            : 
     103                 :            : static void general_init (const char *, bool);
     104                 :            : static void do_compile ();
     105                 :            : static void process_options (void);
     106                 :            : static void backend_init (void);
     107                 :            : static int lang_dependent_init (const char *);
     108                 :            : static void init_asm_output (const char *);
     109                 :            : static void finalize (bool);
     110                 :            : 
     111                 :            : static void crash_signal (int) ATTRIBUTE_NORETURN;
     112                 :            : static void compile_file (void);
     113                 :            : 
     114                 :            : /* True if we don't need a backend (e.g. preprocessing only).  */
     115                 :            : static bool no_backend;
     116                 :            : 
     117                 :            : /* Length of line when printing switch values.  */
     118                 :            : #define MAX_LINE 75
     119                 :            : 
     120                 :            : /* Decoded options, and number of such options.  */
     121                 :            : struct cl_decoded_option *save_decoded_options;
     122                 :            : unsigned int save_decoded_options_count;
     123                 :            : 
     124                 :            : /* Used to enable -fvar-tracking, -fweb and -frename-registers according
     125                 :            :    to optimize in process_options ().  */
     126                 :            : #define AUTODETECT_VALUE 2
     127                 :            : 
     128                 :            : /* Debug hooks - dependent upon command line options.  */
     129                 :            : 
     130                 :            : const struct gcc_debug_hooks *debug_hooks;
     131                 :            : 
     132                 :            : /* The FUNCTION_DECL for the function currently being compiled,
     133                 :            :    or 0 if between functions.  */
     134                 :            : tree current_function_decl;
     135                 :            : 
     136                 :            : /* Set to the FUNC_BEGIN label of the current function, or NULL
     137                 :            :    if none.  */
     138                 :            : const char * current_function_func_begin_label;
     139                 :            : 
     140                 :            : /* A random sequence of characters, unless overridden by user.  */
     141                 :            : static const char *flag_random_seed;
     142                 :            : 
     143                 :            : /* A local time stamp derived from the time of compilation. It will be
     144                 :            :    zero if the system cannot provide a time.  It will be -1u, if the
     145                 :            :    user has specified a particular random seed.  */
     146                 :            : unsigned local_tick;
     147                 :            : 
     148                 :            : /* Random number for this compilation */
     149                 :            : HOST_WIDE_INT random_seed;
     150                 :            : 
     151                 :            : /* -f flags.  */
     152                 :            : 
     153                 :            : /* When non-NULL, indicates that whenever space is allocated on the
     154                 :            :    stack, the resulting stack pointer must not pass this
     155                 :            :    address---that is, for stacks that grow downward, the stack pointer
     156                 :            :    must always be greater than or equal to this address; for stacks
     157                 :            :    that grow upward, the stack pointer must be less than this address.
     158                 :            :    At present, the rtx may be either a REG or a SYMBOL_REF, although
     159                 :            :    the support provided depends on the backend.  */
     160                 :            : rtx stack_limit_rtx;
     161                 :            : 
     162                 :            : class target_flag_state default_target_flag_state;
     163                 :            : #if SWITCHABLE_TARGET
     164                 :            : class target_flag_state *this_target_flag_state = &default_target_flag_state;
     165                 :            : #else
     166                 :            : #define this_target_flag_state (&default_target_flag_state)
     167                 :            : #endif
     168                 :            : 
     169                 :            : /* The user symbol prefix after having resolved same.  */
     170                 :            : const char *user_label_prefix;
     171                 :            : 
     172                 :            : /* Output files for assembler code (real compiler output)
     173                 :            :    and debugging dumps.  */
     174                 :            : 
     175                 :            : FILE *asm_out_file;
     176                 :            : FILE *aux_info_file;
     177                 :            : FILE *callgraph_info_file = NULL;
     178                 :            : static bitmap callgraph_info_external_printed;
     179                 :            : FILE *stack_usage_file = NULL;
     180                 :            : 
     181                 :            : /* The current working directory of a translation.  It's generally the
     182                 :            :    directory from which compilation was initiated, but a preprocessed
     183                 :            :    file may specify the original directory in which it was
     184                 :            :    created.  */
     185                 :            : 
     186                 :            : static const char *src_pwd;
     187                 :            : 
     188                 :            : /* Initialize src_pwd with the given string, and return true.  If it
     189                 :            :    was already initialized, return false.  As a special case, it may
     190                 :            :    be called with a NULL argument to test whether src_pwd has NOT been
     191                 :            :    initialized yet.  */
     192                 :            : 
     193                 :            : bool
     194                 :         19 : set_src_pwd (const char *pwd)
     195                 :            : {
     196                 :         19 :   if (src_pwd)
     197                 :            :     {
     198                 :          0 :       if (strcmp (src_pwd, pwd) == 0)
     199                 :            :         return true;
     200                 :            :       else
     201                 :          0 :         return false;
     202                 :            :     }
     203                 :            : 
     204                 :         19 :   src_pwd = xstrdup (pwd);
     205                 :         19 :   return true;
     206                 :            : }
     207                 :            : 
     208                 :            : /* Return the directory from which the translation unit was initiated,
     209                 :            :    in case set_src_pwd() was not called before to assign it a
     210                 :            :    different value.  */
     211                 :            : 
     212                 :            : const char *
     213                 :      39074 : get_src_pwd (void)
     214                 :            : {
     215                 :      39074 :   if (! src_pwd)
     216                 :            :     {
     217                 :      39055 :       src_pwd = getpwd ();
     218                 :      39055 :       if (!src_pwd)
     219                 :          0 :         src_pwd = ".";
     220                 :            :     }
     221                 :            : 
     222                 :      39074 :    return src_pwd;
     223                 :            : }
     224                 :            : 
     225                 :            : /* Called when the start of a function definition is parsed,
     226                 :            :    this function prints on stderr the name of the function.  */
     227                 :            : void
     228                 :   41187800 : announce_function (tree decl)
     229                 :            : {
     230                 :   41187800 :   if (!quiet_flag)
     231                 :            :     {
     232                 :          0 :       if (rtl_dump_and_exit)
     233                 :          0 :         fprintf (stderr, "%s ",
     234                 :          0 :                  identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl))));
     235                 :            :       else
     236                 :          0 :         fprintf (stderr, " %s",
     237                 :          0 :                  identifier_to_locale (lang_hooks.decl_printable_name (decl, 2)));
     238                 :          0 :       fflush (stderr);
     239                 :          0 :       pp_needs_newline (global_dc->printer) = true;
     240                 :          0 :       diagnostic_set_last_function (global_dc, (diagnostic_info *) NULL);
     241                 :            :     }
     242                 :   41187800 : }
     243                 :            : 
     244                 :            : /* Initialize local_tick with the time of day, or -1 if
     245                 :            :    flag_random_seed is set.  */
     246                 :            : 
     247                 :            : static void
     248                 :     200535 : init_local_tick (void)
     249                 :            : {
     250                 :     200535 :   if (!flag_random_seed)
     251                 :            :     {
     252                 :            : #ifdef HAVE_GETTIMEOFDAY
     253                 :     198429 :       {
     254                 :     198429 :         struct timeval tv;
     255                 :            : 
     256                 :     198429 :         gettimeofday (&tv, NULL);
     257                 :     198429 :         local_tick = (unsigned) tv.tv_sec * 1000 + tv.tv_usec / 1000;
     258                 :            :       }
     259                 :            : #else
     260                 :            :       {
     261                 :            :         time_t now = time (NULL);
     262                 :            : 
     263                 :            :         if (now != (time_t)-1)
     264                 :            :           local_tick = (unsigned) now;
     265                 :            :       }
     266                 :            : #endif
     267                 :            :     }
     268                 :            :   else
     269                 :       2106 :     local_tick = -1;
     270                 :     200535 : }
     271                 :            : 
     272                 :            : /* Obtain the random_seed.  Unless NOINIT, initialize it if
     273                 :            :    it's not provided in the command line.  */
     274                 :            : 
     275                 :            : HOST_WIDE_INT
     276                 :     361700 : get_random_seed (bool noinit)
     277                 :            : {
     278                 :     361700 :   if (!random_seed && !noinit)
     279                 :            :     {
     280                 :      21397 :       int fd = open ("/dev/urandom", O_RDONLY);
     281                 :      21397 :       if (fd >= 0)
     282                 :            :         {
     283                 :      21397 :           if (read (fd, &random_seed, sizeof (random_seed))
     284                 :            :               != sizeof (random_seed))
     285                 :          0 :             random_seed = 0;
     286                 :      21397 :           close (fd);
     287                 :            :         }
     288                 :      21397 :       if (!random_seed)
     289                 :          0 :         random_seed = local_tick ^ getpid ();
     290                 :            :     }
     291                 :     361700 :   return random_seed;
     292                 :            : }
     293                 :            : 
     294                 :            : /* Set flag_random_seed to VAL, and if non-null, reinitialize random_seed.  */
     295                 :            : 
     296                 :            : void
     297                 :       2106 : set_random_seed (const char *val)
     298                 :            : {
     299                 :       2106 :   flag_random_seed = val;
     300                 :       2106 :   if (flag_random_seed)
     301                 :            :     {
     302                 :       2106 :       char *endp;
     303                 :            : 
     304                 :            :       /* When the driver passed in a hex number don't crc it again */
     305                 :       2106 :       random_seed = strtoul (flag_random_seed, &endp, 0);
     306                 :       2106 :       if (!(endp > flag_random_seed && *endp == 0))
     307                 :        512 :         random_seed = crc32_string (0, flag_random_seed);
     308                 :            :     }
     309                 :       2106 : }
     310                 :            : 
     311                 :            : /* Handler for fatal signals, such as SIGSEGV.  These are transformed
     312                 :            :    into ICE messages, which is much more user friendly.  In case the
     313                 :            :    error printer crashes, reset the signal to prevent infinite recursion.  */
     314                 :            : 
     315                 :            : static void
     316                 :          0 : crash_signal (int signo)
     317                 :            : {
     318                 :          0 :   signal (signo, SIG_DFL);
     319                 :            : 
     320                 :            :   /* If we crashed while processing an ASM statement, then be a little more
     321                 :            :      graceful.  It's most likely the user's fault.  */
     322                 :          0 :   if (this_is_asm_operands)
     323                 :            :     {
     324                 :          0 :       output_operand_lossage ("unrecoverable error");
     325                 :          0 :       exit (FATAL_EXIT_CODE);
     326                 :            :     }
     327                 :            : 
     328                 :          0 :   internal_error ("%s", strsignal (signo));
     329                 :            : }
     330                 :            : 
     331                 :            : /* A subroutine of wrapup_global_declarations.  We've come to the end of
     332                 :            :    the compilation unit.  All deferred variables should be undeferred,
     333                 :            :    and all incomplete decls should be finalized.  */
     334                 :            : 
     335                 :            : void
     336                 :  312466000 : wrapup_global_declaration_1 (tree decl)
     337                 :            : {
     338                 :            :   /* We're not deferring this any longer.  Assignment is conditional to
     339                 :            :      avoid needlessly dirtying PCH pages.  */
     340                 :  312466000 :   if (CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_WITH_VIS)
     341                 :  312466000 :       && DECL_DEFER_OUTPUT (decl) != 0)
     342                 :   13672300 :     DECL_DEFER_OUTPUT (decl) = 0;
     343                 :            : 
     344                 :  333694000 :   if (VAR_P (decl) && DECL_SIZE (decl) == 0)
     345                 :     408163 :     lang_hooks.finish_incomplete_decl (decl);
     346                 :  312466000 : }
     347                 :            : 
     348                 :            : /* A subroutine of wrapup_global_declarations.  Decide whether or not DECL
     349                 :            :    needs to be output.  Return true if it is output.  */
     350                 :            : 
     351                 :            : bool
     352                 :  371381000 : wrapup_global_declaration_2 (tree decl)
     353                 :            : {
     354                 :  370156000 :   if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl)
     355                 :  392667000 :       || (VAR_P (decl) && DECL_HAS_VALUE_EXPR_P (decl)))
     356                 :            :     return false;
     357                 :            : 
     358                 :            :   /* Don't write out static consts, unless we still need them.
     359                 :            : 
     360                 :            :      We also keep static consts if not optimizing (for debugging),
     361                 :            :      unless the user specified -fno-keep-static-consts.
     362                 :            :      ??? They might be better written into the debug information.
     363                 :            :      This is possible when using DWARF.
     364                 :            : 
     365                 :            :      A language processor that wants static constants to be always
     366                 :            :      written out (even if it is not used) is responsible for
     367                 :            :      calling rest_of_decl_compilation itself.  E.g. the C front-end
     368                 :            :      calls rest_of_decl_compilation from finish_decl.
     369                 :            :      One motivation for this is that is conventional in some
     370                 :            :      environments to write things like:
     371                 :            :      static const char rcsid[] = "... version string ...";
     372                 :            :      intending to force the string to be in the executable.
     373                 :            : 
     374                 :            :      A language processor that would prefer to have unneeded
     375                 :            :      static constants "optimized away" would just defer writing
     376                 :            :      them out until here.  E.g. C++ does this, because static
     377                 :            :      constants are often defined in header files.
     378                 :            : 
     379                 :            :      ??? A tempting alternative (for both C and C++) would be
     380                 :            :      to force a constant to be written if and only if it is
     381                 :            :      defined in a main file, as opposed to an include file.  */
     382                 :            : 
     383                 :   21285600 :   if (VAR_P (decl) && TREE_STATIC (decl))
     384                 :            :     {
     385                 :    6020810 :       varpool_node *node;
     386                 :    6020810 :       bool needed = true;
     387                 :    6020810 :       node = varpool_node::get (decl);
     388                 :            : 
     389                 :    6020810 :       if (!node && flag_ltrans)
     390                 :            :         needed = false;
     391                 :    6020810 :       else if (node && node->definition)
     392                 :            :         needed = false;
     393                 :    1359700 :       else if (node && node->alias)
     394                 :            :         needed = false;
     395                 :    1359490 :       else if (!symtab->global_info_ready
     396                 :    1359490 :                && (TREE_USED (decl)
     397                 :    1359490 :                    || TREE_USED (DECL_ASSEMBLER_NAME (decl))))
     398                 :            :         /* needed */;
     399                 :     710748 :       else if (node && node->analyzed)
     400                 :            :         /* needed */;
     401                 :     710748 :       else if (DECL_COMDAT (decl))
     402                 :            :         needed = false;
     403                 :     710899 :       else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl)
     404                 :     710754 :                && (optimize || !flag_keep_static_consts
     405                 :          6 :                    || DECL_ARTIFICIAL (decl)))
     406                 :            :         needed = false;
     407                 :            : 
     408                 :            :       if (needed)
     409                 :            :         {
     410                 :    1359490 :           rest_of_decl_compilation (decl, 1, 1);
     411                 :    1359490 :           return true;
     412                 :            :         }
     413                 :            :     }
     414                 :            : 
     415                 :            :   return false;
     416                 :            : }
     417                 :            : 
     418                 :            : /* Do any final processing required for the declarations in VEC, of
     419                 :            :    which there are LEN.  We write out inline functions and variables
     420                 :            :    that have been deferred until this point, but which are required.
     421                 :            :    Returns nonzero if anything was put out.  */
     422                 :            : 
     423                 :            : bool
     424                 :     148426 : wrapup_global_declarations (tree *vec, int len)
     425                 :            : {
     426                 :     148426 :   bool reconsider, output_something = false;
     427                 :     148426 :   int i;
     428                 :            : 
     429                 :  119167000 :   for (i = 0; i < len; i++)
     430                 :  119018000 :     wrapup_global_declaration_1 (vec[i]);
     431                 :            : 
     432                 :            :   /* Now emit any global variables or functions that we have been
     433                 :            :      putting off.  We need to loop in case one of the things emitted
     434                 :            :      here references another one which comes earlier in the list.  */
     435                 :     161661 :   do
     436                 :            :     {
     437                 :     161661 :       reconsider = false;
     438                 :  125678000 :       for (i = 0; i < len; i++)
     439                 :  125516000 :         reconsider |= wrapup_global_declaration_2 (vec[i]);
     440                 :     161661 :       if (reconsider)
     441                 :      13235 :         output_something = true;
     442                 :            :     }
     443                 :            :   while (reconsider);
     444                 :            : 
     445                 :     148426 :   return output_something;
     446                 :            : }
     447                 :            : 
     448                 :            : /* Compile an entire translation unit.  Write a file of assembly
     449                 :            :    output and various debugging dumps.  */
     450                 :            : 
     451                 :            : static void
     452                 :     198350 : compile_file (void)
     453                 :            : {
     454                 :     198350 :   timevar_start (TV_PHASE_PARSING);
     455                 :     198350 :   timevar_push (TV_PARSE_GLOBAL);
     456                 :            : 
     457                 :            :   /* Parse entire file and generate initial debug information.  */
     458                 :     198350 :   lang_hooks.parse_file ();
     459                 :            : 
     460                 :     198146 :   timevar_pop (TV_PARSE_GLOBAL);
     461                 :     198146 :   timevar_stop (TV_PHASE_PARSING);
     462                 :            : 
     463                 :     198146 :   if (flag_dump_locations)
     464                 :          0 :     dump_location_info (stderr);
     465                 :            : 
     466                 :            :   /* Compilation is now finished except for writing
     467                 :            :      what's left of the symbol table output.  */
     468                 :            : 
     469                 :     198146 :   if (flag_syntax_only || flag_wpa)
     470                 :            :     return;
     471                 :            :  
     472                 :            :   /* Reset maximum_field_alignment, it can be adjusted by #pragma pack
     473                 :            :      and this shouldn't influence any types built by the middle-end
     474                 :            :      from now on (like gcov_info_type).  */
     475                 :     192684 :   maximum_field_alignment = initial_max_fld_align * BITS_PER_UNIT;
     476                 :            : 
     477                 :     192684 :   ggc_protect_identifiers = false;
     478                 :            : 
     479                 :            :   /* Run the actual compilation process.  */
     480                 :     192684 :   if (!in_lto_p)
     481                 :            :     {
     482                 :     183708 :       timevar_start (TV_PHASE_OPT_GEN);
     483                 :     183708 :       symtab->finalize_compilation_unit ();
     484                 :     183708 :       timevar_stop (TV_PHASE_OPT_GEN);
     485                 :            :     }
     486                 :            : 
     487                 :            :   /* Perform any post compilation-proper parser cleanups and
     488                 :            :      processing.  This is currently only needed for the C++ parser,
     489                 :            :      which can be hopefully cleaned up so this hook is no longer
     490                 :            :      necessary.  */
     491                 :     192684 :   if (lang_hooks.decls.post_compilation_parsing_cleanups)
     492                 :      77614 :     lang_hooks.decls.post_compilation_parsing_cleanups ();
     493                 :            : 
     494                 :     192684 :   dump_context::get ().finish_any_json_writer ();
     495                 :            : 
     496                 :     192684 :   if (seen_error ())
     497                 :            :     return;
     498                 :            : 
     499                 :     171964 :   timevar_start (TV_PHASE_LATE_ASM);
     500                 :            : 
     501                 :            :   /* Compilation unit is finalized.  When producing non-fat LTO object, we are
     502                 :            :      basically finished.  */
     503                 :     171964 :   if ((in_lto_p && flag_incremental_link != INCREMENTAL_LINK_LTO)
     504                 :     163017 :       || !flag_lto || flag_fat_lto_objects)
     505                 :            :     {
     506                 :            :       /* File-scope initialization for AddressSanitizer.  */
     507                 :     163649 :       if (flag_sanitize & SANITIZE_ADDRESS)
     508                 :       1809 :         asan_finish_file ();
     509                 :            : 
     510                 :     163649 :       if (flag_sanitize & SANITIZE_THREAD)
     511                 :        185 :         tsan_finish_file ();
     512                 :            : 
     513                 :     163649 :       omp_finish_file ();
     514                 :            : 
     515                 :     163649 :       hsa_output_brig ();
     516                 :            : 
     517                 :     163649 :       output_shared_constant_pool ();
     518                 :     163649 :       output_object_blocks ();
     519                 :     163649 :       finish_tm_clone_pairs ();
     520                 :            : 
     521                 :            :       /* Write out any pending weak symbol declarations.  */
     522                 :     163649 :       weak_finish ();
     523                 :            : 
     524                 :            :       /* This must be at the end before unwind and debug info.
     525                 :            :          Some target ports emit PIC setup thunks here.  */
     526                 :     163649 :       targetm.asm_out.code_end ();
     527                 :            : 
     528                 :            :       /* Do dbx symbols.  */
     529                 :     163649 :       timevar_push (TV_SYMOUT);
     530                 :            : 
     531                 :            : #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
     532                 :     163649 :       dwarf2out_frame_finish ();
     533                 :            : #endif
     534                 :            : 
     535                 :     163649 :       debuginfo_start ();
     536                 :     163649 :       (*debug_hooks->finish) (main_input_filename);
     537                 :     163649 :       debuginfo_stop ();
     538                 :     163649 :       timevar_pop (TV_SYMOUT);
     539                 :            : 
     540                 :            :       /* Output some stuff at end of file if nec.  */
     541                 :            : 
     542                 :     163649 :       dw2_output_indirect_constants ();
     543                 :            : 
     544                 :            :       /* Flush any pending external directives.  */
     545                 :     163649 :       process_pending_assemble_externals ();
     546                 :            :    }
     547                 :            : 
     548                 :            :   /* Let linker plugin know that this is a slim object and must be LTOed
     549                 :            :      even when user did not ask for it.  */
     550                 :     171964 :   if (flag_generate_lto && !flag_fat_lto_objects)
     551                 :            :     {
     552                 :            : #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
     553                 :       8315 :       ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, NULL_TREE, "__gnu_lto_slim",
     554                 :       8315 :                                       HOST_WIDE_INT_1U, 8);
     555                 :            : #elif defined ASM_OUTPUT_ALIGNED_COMMON
     556                 :            :       ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, "__gnu_lto_slim",
     557                 :            :                                  HOST_WIDE_INT_1U, 8);
     558                 :            : #else
     559                 :            :       ASM_OUTPUT_COMMON (asm_out_file, "__gnu_lto_slim",
     560                 :            :                          HOST_WIDE_INT_1U,
     561                 :            :                          HOST_WIDE_INT_1U);
     562                 :            : #endif
     563                 :            :     }
     564                 :            : 
     565                 :            :   /* Attach a special .ident directive to the end of the file to identify
     566                 :            :      the version of GCC which compiled this code.  The format of the .ident
     567                 :            :      string is patterned after the ones produced by native SVR4 compilers.  */
     568                 :     171964 :   if (!flag_no_ident)
     569                 :            :     {
     570                 :     166717 :       const char *pkg_version = "(GNU) ";
     571                 :     166717 :       char *ident_str;
     572                 :            : 
     573                 :     166717 :       if (strcmp ("(GCC) ", pkgversion_string))
     574                 :          0 :         pkg_version = pkgversion_string;
     575                 :            : 
     576                 :     166717 :       ident_str = ACONCAT (("GCC: ", pkg_version, version_string, NULL));
     577                 :     166717 :       targetm.asm_out.output_ident (ident_str);
     578                 :            :     }
     579                 :            : 
     580                 :            :   /* Auto profile finalization. */
     581                 :     171964 :   if (flag_auto_profile)
     582                 :          0 :     end_auto_profile ();
     583                 :            : 
     584                 :            :   /* Invoke registered plugin callbacks.  */
     585                 :     171964 :   invoke_plugin_callbacks (PLUGIN_FINISH_UNIT, NULL);
     586                 :            : 
     587                 :            :   /* This must be at the end.  Some target ports emit end of file directives
     588                 :            :      into the assembly file here, and hence we cannot output anything to the
     589                 :            :      assembly file after this point.  */
     590                 :     171964 :   targetm.asm_out.file_end ();
     591                 :            : 
     592                 :     171964 :   timevar_stop (TV_PHASE_LATE_ASM);
     593                 :            : }
     594                 :            : 
     595                 :            : /* Print version information to FILE.
     596                 :            :    Each line begins with INDENT (for the case where FILE is the
     597                 :            :    assembler output file).
     598                 :            : 
     599                 :            :    If SHOW_GLOBAL_STATE is true (for cc1 etc), we are within the compiler
     600                 :            :    proper and can print pertinent state (e.g. params and plugins).
     601                 :            : 
     602                 :            :    If SHOW_GLOBAL_STATE is false (for use by libgccjit), we are outside the
     603                 :            :    compiler, and we don't hold the mutex on the compiler's global state:
     604                 :            :    we can't print params and plugins, since they might not be initialized,
     605                 :            :    or might be being manipulated by a compile running in another
     606                 :            :    thread.  */
     607                 :            : 
     608                 :            : void
     609                 :       1762 : print_version (FILE *file, const char *indent, bool show_global_state)
     610                 :            : {
     611                 :       1762 :   static const char fmt1[] =
     612                 :            : #ifdef __GNUC__
     613                 :            :     N_("%s%s%s %sversion %s (%s)\n%s\tcompiled by GNU C version %s, ")
     614                 :            : #else
     615                 :            :     N_("%s%s%s %sversion %s (%s) compiled by CC, ")
     616                 :            : #endif
     617                 :            :     ;
     618                 :       1762 :   static const char fmt2[] =
     619                 :            :     N_("GMP version %s, MPFR version %s, MPC version %s, isl version %s\n");
     620                 :       1762 :   static const char fmt3[] =
     621                 :            :     N_("%s%swarning: %s header version %s differs from library version %s.\n");
     622                 :       1762 :   static const char fmt4[] =
     623                 :            :     N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n");
     624                 :            : #ifndef __VERSION__
     625                 :            : #define __VERSION__ "[?]"
     626                 :            : #endif
     627                 :       1762 :   fprintf (file,
     628                 :       1762 :            file == stderr ? _(fmt1) : fmt1,
     629                 :       1762 :            indent, *indent != 0 ? " " : "",
     630                 :            :            lang_hooks.name, pkgversion_string, version_string, TARGET_NAME,
     631                 :            :            indent, __VERSION__);
     632                 :            : 
     633                 :            :   /* We need to stringify the GMP macro values.  Ugh, gmp_version has
     634                 :            :      two string formats, "i.j.k" and "i.j" when k is zero.  As of
     635                 :            :      gmp-4.3.0, GMP always uses the 3 number format.  */
     636                 :            : #define GCC_GMP_STRINGIFY_VERSION3(X) #X
     637                 :            : #define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3 (X)
     638                 :            : #define GCC_GMP_VERSION_NUM(X,Y,Z) (((X) << 16L) | ((Y) << 8) | (Z))
     639                 :            : #define GCC_GMP_VERSION \
     640                 :            :   GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL)
     641                 :            : #if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,0) && __GNU_MP_VERSION_PATCHLEVEL == 0
     642                 :            : #define GCC_GMP_STRINGIFY_VERSION \
     643                 :            :   GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \
     644                 :            :   GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR)
     645                 :            : #else
     646                 :            : #define GCC_GMP_STRINGIFY_VERSION \
     647                 :            :   GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \
     648                 :            :   GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR) "." \
     649                 :            :   GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_PATCHLEVEL)
     650                 :            : #endif
     651                 :       3524 :   fprintf (file,
     652                 :       1762 :            file == stderr ? _(fmt2) : fmt2,
     653                 :            :            GCC_GMP_STRINGIFY_VERSION, MPFR_VERSION_STRING, MPC_VERSION_STRING,
     654                 :            : #ifndef HAVE_isl
     655                 :            :            "none"
     656                 :            : #else
     657                 :            :            isl_version ()
     658                 :            : #endif
     659                 :            :            );
     660                 :       1762 :   if (strcmp (GCC_GMP_STRINGIFY_VERSION, gmp_version))
     661                 :          0 :     fprintf (file,
     662                 :          0 :              file == stderr ? _(fmt3) : fmt3,
     663                 :          0 :              indent, *indent != 0 ? " " : "",
     664                 :            :              "GMP", GCC_GMP_STRINGIFY_VERSION, gmp_version);
     665                 :       1762 :   if (strcmp (MPFR_VERSION_STRING, mpfr_get_version ()))
     666                 :          0 :     fprintf (file,
     667                 :          0 :              file == stderr ? _(fmt3) : fmt3,
     668                 :          0 :              indent, *indent != 0 ? " " : "",
     669                 :            :              "MPFR", MPFR_VERSION_STRING, mpfr_get_version ());
     670                 :       1762 :   if (strcmp (MPC_VERSION_STRING, mpc_get_version ()))
     671                 :          0 :     fprintf (file,
     672                 :          0 :              file == stderr ? _(fmt3) : fmt3,
     673                 :          0 :              indent, *indent != 0 ? " " : "",
     674                 :            :              "MPC", MPC_VERSION_STRING, mpc_get_version ());
     675                 :            : 
     676                 :       1762 :   if (show_global_state)
     677                 :            :     {
     678                 :        232 :       fprintf (file,
     679                 :        232 :                file == stderr ? _(fmt4) : fmt4,
     680                 :        232 :                indent, *indent != 0 ? " " : "",
     681                 :            :                param_ggc_min_expand, param_ggc_min_heapsize);
     682                 :            : 
     683                 :        232 :       print_plugins_versions (file, indent);
     684                 :            :     }
     685                 :       1762 : }
     686                 :            : 
     687                 :            : static int
     688                 :       2671 : print_to_asm_out_file (print_switch_type type, const char * text)
     689                 :            : {
     690                 :       2671 :   bool prepend_sep = true;
     691                 :            : 
     692                 :       2671 :   switch (type)
     693                 :            :     {
     694                 :        498 :     case SWITCH_TYPE_LINE_END:
     695                 :        498 :       putc ('\n', asm_out_file);
     696                 :        498 :       return 1;
     697                 :            : 
     698                 :        498 :     case SWITCH_TYPE_LINE_START:
     699                 :        498 :       fputs (ASM_COMMENT_START, asm_out_file);
     700                 :        498 :       return strlen (ASM_COMMENT_START);
     701                 :            : 
     702                 :            :     case SWITCH_TYPE_DESCRIPTIVE:
     703                 :            :       if (ASM_COMMENT_START[0] == 0)
     704                 :            :         prepend_sep = false;
     705                 :            :       /* FALLTHRU */
     706                 :       1675 :     case SWITCH_TYPE_PASSED:
     707                 :       1675 :     case SWITCH_TYPE_ENABLED:
     708                 :       1675 :       if (prepend_sep)
     709                 :       1675 :         fputc (' ', asm_out_file);
     710                 :       1675 :       fputs (text, asm_out_file);
     711                 :            :       /* No need to return the length here as
     712                 :            :          print_single_switch has already done it.  */
     713                 :       1675 :       return 0;
     714                 :            : 
     715                 :            :     default:
     716                 :            :       return -1;
     717                 :            :     }
     718                 :            : }
     719                 :            : 
     720                 :            : static int
     721                 :          0 : print_to_stderr (print_switch_type type, const char * text)
     722                 :            : {
     723                 :          0 :   switch (type)
     724                 :            :     {
     725                 :          0 :     case SWITCH_TYPE_LINE_END:
     726                 :          0 :       putc ('\n', stderr);
     727                 :          0 :       return 1;
     728                 :            : 
     729                 :            :     case SWITCH_TYPE_LINE_START:
     730                 :            :       return 0;
     731                 :            : 
     732                 :          0 :     case SWITCH_TYPE_PASSED:
     733                 :          0 :     case SWITCH_TYPE_ENABLED:
     734                 :          0 :       fputc (' ', stderr);
     735                 :            :       /* FALLTHRU */
     736                 :            : 
     737                 :          0 :     case SWITCH_TYPE_DESCRIPTIVE:
     738                 :          0 :       fputs (text, stderr);
     739                 :            :       /* No need to return the length here as
     740                 :            :          print_single_switch has already done it.  */
     741                 :          0 :       return 0;
     742                 :            : 
     743                 :          0 :     default:
     744                 :          0 :       return -1;
     745                 :            :     }
     746                 :            : }
     747                 :            : 
     748                 :            : /* Print an option value and return the adjusted position in the line.
     749                 :            :    ??? print_fn doesn't handle errors, eg disk full; presumably other
     750                 :            :    code will catch a disk full though.  */
     751                 :            : 
     752                 :            : static int
     753                 :       1675 : print_single_switch (print_switch_fn_type print_fn,
     754                 :            :                      int pos,
     755                 :            :                      print_switch_type type,
     756                 :            :                      const char * text)
     757                 :            : {
     758                 :            :   /* The ultrix fprintf returns 0 on success, so compute the result
     759                 :            :      we want here since we need it for the following test.  The +1
     760                 :            :      is for the separator character that will probably be emitted.  */
     761                 :       1675 :   int len = strlen (text) + 1;
     762                 :            : 
     763                 :       1675 :   if (pos != 0
     764                 :       1653 :       && pos + len > MAX_LINE)
     765                 :            :     {
     766                 :        476 :       print_fn (SWITCH_TYPE_LINE_END, NULL);
     767                 :        476 :       pos = 0;
     768                 :            :     }
     769                 :            : 
     770                 :       1675 :   if (pos == 0)
     771                 :        498 :     pos += print_fn (SWITCH_TYPE_LINE_START, NULL);
     772                 :            : 
     773                 :       1675 :   print_fn (type, text);
     774                 :       1675 :   return pos + len;
     775                 :            : }
     776                 :            : 
     777                 :            : /* Print active target switches using PRINT_FN.
     778                 :            :    POS is the current cursor position and MAX is the size of a "line".
     779                 :            :    Each line begins with INDENT and ends with TERM.
     780                 :            :    Each switch is separated from the next by SEP.  */
     781                 :            : 
     782                 :            : static void
     783                 :         11 : print_switch_values (print_switch_fn_type print_fn)
     784                 :            : {
     785                 :         11 :   int pos = 0;
     786                 :         11 :   size_t j;
     787                 :            : 
     788                 :            :   /* Print the options as passed.  */
     789                 :         11 :   pos = print_single_switch (print_fn, pos,
     790                 :         11 :                              SWITCH_TYPE_DESCRIPTIVE, _("options passed: "));
     791                 :            : 
     792                 :        179 :   for (j = 1; j < save_decoded_options_count; j++)
     793                 :            :     {
     794                 :        168 :       switch (save_decoded_options[j].opt_index)
     795                 :            :         {
     796                 :         34 :         case OPT_o:
     797                 :         34 :         case OPT_d:
     798                 :         34 :         case OPT_dumpbase:
     799                 :         34 :         case OPT_dumpdir:
     800                 :         34 :         case OPT_auxbase:
     801                 :         34 :         case OPT_quiet:
     802                 :         34 :         case OPT_version:
     803                 :            :           /* Ignore these.  */
     804                 :         34 :           continue;
     805                 :            :         }
     806                 :            : 
     807                 :        134 :       pos = print_single_switch (print_fn, pos, SWITCH_TYPE_PASSED,
     808                 :            :                                  save_decoded_options[j].orig_option_with_args_text);
     809                 :            :     }
     810                 :            : 
     811                 :         11 :   if (pos > 0)
     812                 :         11 :     print_fn (SWITCH_TYPE_LINE_END, NULL);
     813                 :            : 
     814                 :            :   /* Print the -f and -m options that have been enabled.
     815                 :            :      We don't handle language specific options but printing argv
     816                 :            :      should suffice.  */
     817                 :         22 :   pos = print_single_switch (print_fn, 0,
     818                 :         11 :                              SWITCH_TYPE_DESCRIPTIVE, _("options enabled: "));
     819                 :            : 
     820                 :         11 :   unsigned lang_mask = lang_hooks.option_lang_mask ();
     821                 :      21076 :   for (j = 0; j < cl_options_count; j++)
     822                 :      21065 :     if (cl_options[j].cl_report
     823                 :      21065 :         && option_enabled (j, lang_mask, &global_options) > 0)
     824                 :       1519 :       pos = print_single_switch (print_fn, pos,
     825                 :       1519 :                                  SWITCH_TYPE_ENABLED, cl_options[j].opt_text);
     826                 :            : 
     827                 :         11 :   print_fn (SWITCH_TYPE_LINE_END, NULL);
     828                 :         11 : }
     829                 :            : 
     830                 :            : /* Open assembly code output file.  Do this even if -fsyntax-only is
     831                 :            :    on, because then the driver will have provided the name of a
     832                 :            :    temporary file or bit bucket for us.  NAME is the file specified on
     833                 :            :    the command line, possibly NULL.  */
     834                 :            : static void
     835                 :     193317 : init_asm_output (const char *name)
     836                 :            : {
     837                 :     193317 :   if (name == NULL && asm_file_name == 0)
     838                 :          0 :     asm_out_file = stdout;
     839                 :            :   else
     840                 :            :     {
     841                 :     193317 :       if (asm_file_name == 0)
     842                 :            :         {
     843                 :        883 :           int len = strlen (dump_base_name);
     844                 :        883 :           char *dumpname = XNEWVEC (char, len + 6);
     845                 :            : 
     846                 :        883 :           memcpy (dumpname, dump_base_name, len + 1);
     847                 :        883 :           strip_off_ending (dumpname, len);
     848                 :        883 :           strcat (dumpname, ".s");
     849                 :        883 :           asm_file_name = dumpname;
     850                 :            :         }
     851                 :     193317 :       if (!strcmp (asm_file_name, "-"))
     852                 :         20 :         asm_out_file = stdout;
     853                 :     193297 :       else if (!canonical_filename_eq (asm_file_name, name)
     854                 :     193297 :                || !strcmp (asm_file_name, HOST_BIT_BUCKET))
     855                 :     193297 :         asm_out_file = fopen (asm_file_name, "w");
     856                 :            :       else
     857                 :            :         /* Use UNKOWN_LOCATION to prevent gcc from printing the first
     858                 :            :            line in the current file. */
     859                 :          0 :         fatal_error (UNKNOWN_LOCATION,
     860                 :            :                      "input file %qs is the same as output file",
     861                 :            :                      asm_file_name);
     862                 :     193317 :       if (asm_out_file == 0)
     863                 :          0 :         fatal_error (UNKNOWN_LOCATION,
     864                 :            :                      "cannot open %qs for writing: %m", asm_file_name);
     865                 :            :     }
     866                 :            : 
     867                 :     193317 :   if (!flag_syntax_only)
     868                 :            :     {
     869                 :     193234 :       targetm.asm_out.file_start ();
     870                 :            : 
     871                 :     193234 :       if (flag_record_gcc_switches)
     872                 :            :         {
     873                 :          0 :           if (targetm.asm_out.record_gcc_switches)
     874                 :            :             {
     875                 :            :               /* Let the target know that we are about to start recording.  */
     876                 :          0 :               targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE,
     877                 :            :                                                    NULL);
     878                 :            :               /* Now record the switches.  */
     879                 :          0 :               print_switch_values (targetm.asm_out.record_gcc_switches);
     880                 :            :               /* Let the target know that the recording is over.  */
     881                 :          0 :               targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE,
     882                 :            :                                                    NULL);
     883                 :            :             }
     884                 :            :           else
     885                 :          0 :             inform (UNKNOWN_LOCATION,
     886                 :            :                     "%<-frecord-gcc-switches%> is not supported by "
     887                 :            :                     "the current target");
     888                 :            :         }
     889                 :            : 
     890                 :     193234 :       if (flag_verbose_asm)
     891                 :            :         {
     892                 :            :           /* Print the list of switches in effect
     893                 :            :              into the assembler file as comments.  */
     894                 :         11 :           print_version (asm_out_file, ASM_COMMENT_START, true);
     895                 :         11 :           print_switch_values (print_to_asm_out_file);
     896                 :         11 :           putc ('\n', asm_out_file);
     897                 :            :         }
     898                 :            :     }
     899                 :     193317 : }
     900                 :            : 
     901                 :            : /* A helper function; used as the reallocator function for cpp's line
     902                 :            :    table.  */
     903                 :            : static void *
     904                 :   96652700 : realloc_for_line_map (void *ptr, size_t len)
     905                 :            : {
     906                 :   96652700 :   return ggc_realloc (ptr, len);
     907                 :            : }
     908                 :            : 
     909                 :            : /* A helper function: used as the allocator function for
     910                 :            :    identifier_to_locale.  */
     911                 :            : static void *
     912                 :        257 : alloc_for_identifier_to_locale (size_t len)
     913                 :            : {
     914                 :        257 :   return ggc_alloc_atomic (len);
     915                 :            : }
     916                 :            : 
     917                 :            : /* Output stack usage information.  */
     918                 :            : static void
     919                 :         34 : output_stack_usage_1 (FILE *cf)
     920                 :            : {
     921                 :         34 :   static bool warning_issued = false;
     922                 :         34 :   enum stack_usage_kind_type { STATIC = 0, DYNAMIC, DYNAMIC_BOUNDED };
     923                 :         34 :   const char *stack_usage_kind_str[] = {
     924                 :            :     "static",
     925                 :            :     "dynamic",
     926                 :            :     "dynamic,bounded"
     927                 :            :   };
     928                 :         34 :   HOST_WIDE_INT stack_usage = current_function_static_stack_size;
     929                 :         34 :   enum stack_usage_kind_type stack_usage_kind;
     930                 :            : 
     931                 :         34 :   if (stack_usage < 0)
     932                 :            :     {
     933                 :          0 :       if (!warning_issued)
     934                 :            :         {
     935                 :          0 :           warning (0, "stack usage computation not supported for this target");
     936                 :          0 :           warning_issued = true;
     937                 :            :         }
     938                 :          0 :       return;
     939                 :            :     }
     940                 :            : 
     941                 :         34 :   stack_usage_kind = STATIC;
     942                 :            : 
     943                 :            :   /* Add the maximum amount of space pushed onto the stack.  */
     944                 :         34 :   if (maybe_ne (current_function_pushed_stack_size, 0))
     945                 :            :     {
     946                 :          0 :       HOST_WIDE_INT extra;
     947                 :          0 :       if (current_function_pushed_stack_size.is_constant (&extra))
     948                 :            :         {
     949                 :          0 :           stack_usage += extra;
     950                 :          0 :           stack_usage_kind = DYNAMIC_BOUNDED;
     951                 :            :         }
     952                 :            :       else
     953                 :            :         {
     954                 :            :           extra = constant_lower_bound (current_function_pushed_stack_size);
     955                 :            :           stack_usage += extra;
     956                 :            :           stack_usage_kind = DYNAMIC;
     957                 :            :         }
     958                 :            :     }
     959                 :            : 
     960                 :            :   /* Now on to the tricky part: dynamic stack allocation.  */
     961                 :         34 :   if (current_function_allocates_dynamic_stack_space)
     962                 :            :     {
     963                 :          2 :       if (stack_usage_kind != DYNAMIC)
     964                 :            :         {
     965                 :          2 :           if (current_function_has_unbounded_dynamic_stack_size)
     966                 :            :             stack_usage_kind = DYNAMIC;
     967                 :            :           else
     968                 :            :             stack_usage_kind = DYNAMIC_BOUNDED;
     969                 :            :         }
     970                 :            : 
     971                 :            :       /* Add the size even in the unbounded case, this can't hurt.  */
     972                 :          2 :       stack_usage += current_function_dynamic_stack_size;
     973                 :            :     }
     974                 :            : 
     975                 :         34 :   if (flag_callgraph_info & CALLGRAPH_INFO_STACK_USAGE)
     976                 :          0 :     fprintf (cf, "\\n" HOST_WIDE_INT_PRINT_DEC " bytes (%s)",
     977                 :            :              stack_usage,
     978                 :          0 :              stack_usage_kind_str[stack_usage_kind]);
     979                 :            : 
     980                 :         34 :   if (stack_usage_file)
     981                 :            :     {
     982                 :         19 :       print_decl_identifier (stack_usage_file, current_function_decl,
     983                 :            :                              PRINT_DECL_ORIGIN | PRINT_DECL_NAME);
     984                 :         19 :       fprintf (stack_usage_file, "\t" HOST_WIDE_INT_PRINT_DEC"\t%s\n",
     985                 :         19 :                stack_usage, stack_usage_kind_str[stack_usage_kind]);
     986                 :            :     }
     987                 :            : 
     988                 :         34 :   if (warn_stack_usage >= 0 && warn_stack_usage < HOST_WIDE_INT_MAX)
     989                 :            :     {
     990                 :         15 :       const location_t loc = DECL_SOURCE_LOCATION (current_function_decl);
     991                 :            : 
     992                 :         15 :       if (stack_usage_kind == DYNAMIC)
     993                 :          1 :         warning_at (loc, OPT_Wstack_usage_, "stack usage might be unbounded");
     994                 :         14 :       else if (stack_usage > warn_stack_usage)
     995                 :            :         {
     996                 :          2 :           if (stack_usage_kind == DYNAMIC_BOUNDED)
     997                 :          1 :             warning_at (loc,
     998                 :            :                         OPT_Wstack_usage_, "stack usage might be %wu bytes",
     999                 :            :                         stack_usage);
    1000                 :            :           else
    1001                 :          1 :             warning_at (loc, OPT_Wstack_usage_, "stack usage is %wu bytes",
    1002                 :            :                         stack_usage);
    1003                 :            :         }
    1004                 :            :     }
    1005                 :            : }
    1006                 :            : 
    1007                 :            : /* Dump placeholder node for indirect calls in VCG format.  */
    1008                 :            : 
    1009                 :            : #define INDIRECT_CALL_NAME  "__indirect_call"
    1010                 :            : 
    1011                 :            : static void
    1012                 :          0 : dump_final_node_vcg_start (FILE *f, tree decl)
    1013                 :            : {
    1014                 :          0 :   fputs ("node: { title: \"", f);
    1015                 :          0 :   if (decl)
    1016                 :          0 :     print_decl_identifier (f, decl, PRINT_DECL_UNIQUE_NAME);
    1017                 :            :   else
    1018                 :          0 :     fputs (INDIRECT_CALL_NAME, f);
    1019                 :          0 :   fputs ("\" label: \"", f);
    1020                 :          0 :   if (decl)
    1021                 :            :     {
    1022                 :          0 :       print_decl_identifier (f, decl, PRINT_DECL_NAME);
    1023                 :          0 :       fputs ("\\n", f);
    1024                 :          0 :       print_decl_identifier (f, decl, PRINT_DECL_ORIGIN);
    1025                 :            :     }
    1026                 :            :   else
    1027                 :          0 :     fputs ("Indirect Call Placeholder", f);
    1028                 :          0 : }
    1029                 :            : 
    1030                 :            : /* Dump final cgraph edge in VCG format.  */
    1031                 :            : 
    1032                 :            : static void
    1033                 :          0 : dump_final_callee_vcg (FILE *f, location_t location, tree callee)
    1034                 :            : {
    1035                 :          0 :   if ((!callee || DECL_EXTERNAL (callee))
    1036                 :          0 :       && bitmap_set_bit (callgraph_info_external_printed,
    1037                 :          0 :                          callee ? DECL_UID (callee) + 1 : 0))
    1038                 :            :     {
    1039                 :          0 :       dump_final_node_vcg_start (f, callee);
    1040                 :          0 :       fputs ("\" shape : ellipse }\n", f);
    1041                 :            :     }
    1042                 :            : 
    1043                 :          0 :   fputs ("edge: { sourcename: \"", f);
    1044                 :          0 :   print_decl_identifier (f, current_function_decl, PRINT_DECL_UNIQUE_NAME);
    1045                 :          0 :   fputs ("\" targetname: \"", f);
    1046                 :          0 :   if (callee)
    1047                 :          0 :     print_decl_identifier (f, callee, PRINT_DECL_UNIQUE_NAME);
    1048                 :            :   else
    1049                 :          0 :     fputs (INDIRECT_CALL_NAME, f);
    1050                 :          0 :   if (LOCATION_LOCUS (location) != UNKNOWN_LOCATION)
    1051                 :            :     {
    1052                 :          0 :       expanded_location loc;
    1053                 :          0 :       fputs ("\" label: \"", f);
    1054                 :          0 :       loc = expand_location (location);
    1055                 :          0 :       fprintf (f, "%s:%d:%d", loc.file, loc.line, loc.column);
    1056                 :            :     }
    1057                 :          0 :   fputs ("\" }\n", f);
    1058                 :          0 : }
    1059                 :            : 
    1060                 :            : /* Dump final cgraph node in VCG format.  */
    1061                 :            : 
    1062                 :            : static void
    1063                 :          0 : dump_final_node_vcg (FILE *f)
    1064                 :            : {
    1065                 :          0 :   dump_final_node_vcg_start (f, current_function_decl);
    1066                 :            : 
    1067                 :          0 :   if (flag_stack_usage_info
    1068                 :          0 :       || (flag_callgraph_info & CALLGRAPH_INFO_STACK_USAGE))
    1069                 :          0 :     output_stack_usage_1 (f);
    1070                 :            : 
    1071                 :          0 :   if (flag_callgraph_info & CALLGRAPH_INFO_DYNAMIC_ALLOC)
    1072                 :            :     {
    1073                 :          0 :       fprintf (f, "\\n%u dynamic objects", vec_safe_length (cfun->su->dallocs));
    1074                 :            : 
    1075                 :          0 :       unsigned i;
    1076                 :          0 :       callinfo_dalloc *cda;
    1077                 :          0 :       FOR_EACH_VEC_SAFE_ELT (cfun->su->dallocs, i, cda)
    1078                 :            :         {
    1079                 :          0 :           expanded_location loc = expand_location (cda->location);
    1080                 :          0 :           fprintf (f, "\\n %s", cda->name);
    1081                 :          0 :           fprintf (f, " %s:%d:%d", loc.file, loc.line, loc.column);
    1082                 :            :         }
    1083                 :            : 
    1084                 :          0 :       vec_free (cfun->su->dallocs);
    1085                 :          0 :       cfun->su->dallocs = NULL;
    1086                 :            :     }
    1087                 :            : 
    1088                 :          0 :   fputs ("\" }\n", f);
    1089                 :            : 
    1090                 :          0 :   unsigned i;
    1091                 :          0 :   callinfo_callee *c;
    1092                 :          0 :   FOR_EACH_VEC_SAFE_ELT (cfun->su->callees, i, c)
    1093                 :          0 :     dump_final_callee_vcg (f, c->location, c->decl);
    1094                 :          0 :   vec_free (cfun->su->callees);
    1095                 :          0 :   cfun->su->callees = NULL;
    1096                 :          0 : }
    1097                 :            : 
    1098                 :            : /* Output stack usage and callgraph info, as requested.  */
    1099                 :            : void
    1100                 :         34 : output_stack_usage (void)
    1101                 :            : {
    1102                 :         34 :   if (flag_callgraph_info)
    1103                 :          0 :     dump_final_node_vcg (callgraph_info_file);
    1104                 :            :   else
    1105                 :         34 :     output_stack_usage_1 (NULL);
    1106                 :         34 : }
    1107                 :            : 
    1108                 :            : /* Open an auxiliary output file.  */
    1109                 :            : static FILE *
    1110                 :          4 : open_auxiliary_file (const char *ext)
    1111                 :            : {
    1112                 :          4 :   char *filename;
    1113                 :          4 :   FILE *file;
    1114                 :            : 
    1115                 :          4 :   filename = concat (aux_base_name, ".", ext, NULL);
    1116                 :          4 :   file = fopen (filename, "w");
    1117                 :          4 :   if (!file)
    1118                 :          0 :     fatal_error (input_location, "cannot open %s for writing: %m", filename);
    1119                 :          4 :   free (filename);
    1120                 :          4 :   return file;
    1121                 :            : }
    1122                 :            : 
    1123                 :            : /* Alternative diagnostics callback for reentered ICE reporting.  */
    1124                 :            : 
    1125                 :            : static void
    1126                 :          0 : internal_error_reentered (diagnostic_context *, const char *, va_list *)
    1127                 :            : {
    1128                 :            :   /* Flush the dump file if emergency_dump_function itself caused an ICE.  */
    1129                 :          0 :   if (dump_file)
    1130                 :          0 :     fflush (dump_file);
    1131                 :          0 : }
    1132                 :            : 
    1133                 :            : /* Auxiliary callback for the diagnostics code.  */
    1134                 :            : 
    1135                 :            : static void
    1136                 :          0 : internal_error_function (diagnostic_context *, const char *, va_list *)
    1137                 :            : {
    1138                 :          0 :   global_dc->internal_error = internal_error_reentered;
    1139                 :          0 :   warn_if_plugins ();
    1140                 :          0 :   emergency_dump_function ();
    1141                 :          0 : }
    1142                 :            : 
    1143                 :            : /* Initialization of the front end environment, before command line
    1144                 :            :    options are parsed.  Signal handlers, internationalization etc.
    1145                 :            :    ARGV0 is main's argv[0].  */
    1146                 :            : static void
    1147                 :     200540 : general_init (const char *argv0, bool init_signals)
    1148                 :            : {
    1149                 :     200540 :   const char *p;
    1150                 :            : 
    1151                 :     200540 :   p = argv0 + strlen (argv0);
    1152                 :    1171340 :   while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
    1153                 :     970796 :     --p;
    1154                 :     200540 :   progname = p;
    1155                 :            : 
    1156                 :     200540 :   xmalloc_set_program_name (progname);
    1157                 :            : 
    1158                 :     200540 :   hex_init ();
    1159                 :            : 
    1160                 :            :   /* Unlock the stdio streams.  */
    1161                 :     200540 :   unlock_std_streams ();
    1162                 :            : 
    1163                 :     200540 :   gcc_init_libintl ();
    1164                 :            : 
    1165                 :     200540 :   identifier_to_locale_alloc = alloc_for_identifier_to_locale;
    1166                 :     200540 :   identifier_to_locale_free = ggc_free;
    1167                 :            : 
    1168                 :            :   /* Initialize the diagnostics reporting machinery, so option parsing
    1169                 :            :      can give warnings and errors.  */
    1170                 :     200540 :   diagnostic_initialize (global_dc, N_OPTS);
    1171                 :     200540 :   global_dc->lang_mask = lang_hooks.option_lang_mask ();
    1172                 :            :   /* Set a default printer.  Language specific initializations will
    1173                 :            :      override it later.  */
    1174                 :     200540 :   tree_diagnostics_defaults (global_dc);
    1175                 :            : 
    1176                 :     200540 :   global_dc->show_caret
    1177                 :     200540 :     = global_options_init.x_flag_diagnostics_show_caret;
    1178                 :     200540 :   global_dc->show_labels_p
    1179                 :     200540 :     = global_options_init.x_flag_diagnostics_show_labels;
    1180                 :     200540 :   global_dc->show_line_numbers_p
    1181                 :     200540 :     = global_options_init.x_flag_diagnostics_show_line_numbers;
    1182                 :     200540 :   global_dc->show_cwe
    1183                 :     200540 :     = global_options_init.x_flag_diagnostics_show_cwe;
    1184                 :     200540 :   global_dc->path_format
    1185                 :     200540 :     = (enum diagnostic_path_format)global_options_init.x_flag_diagnostics_path_format;
    1186                 :     200540 :   global_dc->show_path_depths
    1187                 :     200540 :     = global_options_init.x_flag_diagnostics_show_path_depths;
    1188                 :     200540 :   global_dc->show_option_requested
    1189                 :     200540 :     = global_options_init.x_flag_diagnostics_show_option;
    1190                 :     200540 :   global_dc->min_margin_width
    1191                 :     200540 :     = global_options_init.x_diagnostics_minimum_margin_width;
    1192                 :     200540 :   global_dc->show_column
    1193                 :     200540 :     = global_options_init.x_flag_show_column;
    1194                 :     200540 :   global_dc->internal_error = internal_error_function;
    1195                 :     200540 :   global_dc->option_enabled = option_enabled;
    1196                 :     200540 :   global_dc->option_state = &global_options;
    1197                 :     200540 :   global_dc->option_name = option_name;
    1198                 :     200540 :   global_dc->get_option_url = get_option_url;
    1199                 :            : 
    1200                 :     200540 :   if (init_signals)
    1201                 :            :     {
    1202                 :            :       /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages.  */
    1203                 :            : #ifdef SIGSEGV
    1204                 :     199652 :       signal (SIGSEGV, crash_signal);
    1205                 :            : #endif
    1206                 :            : #ifdef SIGILL
    1207                 :     199652 :       signal (SIGILL, crash_signal);
    1208                 :            : #endif
    1209                 :            : #ifdef SIGBUS
    1210                 :     199652 :       signal (SIGBUS, crash_signal);
    1211                 :            : #endif
    1212                 :            : #ifdef SIGABRT
    1213                 :     199652 :       signal (SIGABRT, crash_signal);
    1214                 :            : #endif
    1215                 :            : #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
    1216                 :            :       signal (SIGIOT, crash_signal);
    1217                 :            : #endif
    1218                 :            : #ifdef SIGFPE
    1219                 :     199652 :       signal (SIGFPE, crash_signal);
    1220                 :            : #endif
    1221                 :            : 
    1222                 :            :       /* Other host-specific signal setup.  */
    1223                 :     199652 :       (*host_hooks.extra_signals)();
    1224                 :            :   }
    1225                 :            : 
    1226                 :            :   /* Initialize the garbage-collector, string pools and tree type hash
    1227                 :            :      table.  */
    1228                 :     200540 :   init_ggc ();
    1229                 :     200540 :   init_stringpool ();
    1230                 :     200540 :   input_location = UNKNOWN_LOCATION;
    1231                 :     200540 :   line_table = ggc_alloc<line_maps> ();
    1232                 :     200540 :   linemap_init (line_table, BUILTINS_LOCATION);
    1233                 :     200540 :   line_table->reallocator = realloc_for_line_map;
    1234                 :     200540 :   line_table->round_alloc_size = ggc_round_alloc_size;
    1235                 :     200540 :   line_table->default_range_bits = 5;
    1236                 :     200540 :   init_ttree ();
    1237                 :            : 
    1238                 :            :   /* Initialize register usage now so switches may override.  */
    1239                 :     200540 :   init_reg_sets ();
    1240                 :            : 
    1241                 :            :   /* Create the singleton holder for global state.  This creates the
    1242                 :            :      dump manager.  */
    1243                 :     200540 :   g = new gcc::context ();
    1244                 :            : 
    1245                 :            :   /* Allow languages and middle-end to register their dumps before the
    1246                 :            :      optimization passes.  */
    1247                 :     200540 :   g->get_dumps ()->register_dumps ();
    1248                 :            : 
    1249                 :            :   /* Create the passes.  */
    1250                 :     200540 :   g->set_passes (new gcc::pass_manager (g));
    1251                 :            : 
    1252                 :     200540 :   symtab = new (ggc_alloc <symbol_table> ()) symbol_table ();
    1253                 :            : 
    1254                 :     200540 :   statistics_early_init ();
    1255                 :     200540 :   debuginfo_early_init ();
    1256                 :     200540 : }
    1257                 :            : 
    1258                 :            : /* Return true if the current target supports -fsection-anchors.  */
    1259                 :            : 
    1260                 :            : static bool
    1261                 :          0 : target_supports_section_anchors_p (void)
    1262                 :            : {
    1263                 :          0 :   if (targetm.min_anchor_offset == 0 && targetm.max_anchor_offset == 0)
    1264                 :            :     return false;
    1265                 :            : 
    1266                 :          0 :   if (targetm.asm_out.output_anchor == NULL)
    1267                 :          0 :     return false;
    1268                 :            : 
    1269                 :            :   return true;
    1270                 :            : }
    1271                 :            : 
    1272                 :            : /* Parse "N[:M][:...]" into struct align_flags A.
    1273                 :            :    VALUES contains parsed values (in reverse order), all processed
    1274                 :            :    values are popped.  */
    1275                 :            : 
    1276                 :            : static void
    1277                 :     447596 : read_log_maxskip (auto_vec<unsigned> &values, align_flags_tuple *a)
    1278                 :            : {
    1279                 :     447596 :   unsigned n = values.pop ();
    1280                 :     447596 :   if (n != 0)
    1281                 :     358100 :     a->log = floor_log2 (n * 2 - 1);
    1282                 :            : 
    1283                 :     447596 :   if (values.is_empty ())
    1284                 :     268545 :     a->maxskip = n ? n - 1 : 0;
    1285                 :            :   else
    1286                 :            :     {
    1287                 :     179051 :       unsigned m = values.pop ();
    1288                 :            :       /* -falign-foo=N:M means M-1 max bytes of padding, not M.  */
    1289                 :     179051 :       if (m > 0)
    1290                 :      89555 :         m--;
    1291                 :     179051 :       a->maxskip = m;
    1292                 :            :     }
    1293                 :            : 
    1294                 :            :   /* Normalize the tuple.  */
    1295                 :     447596 :   a->normalize ();
    1296                 :     447596 : }
    1297                 :            : 
    1298                 :            : /* Parse "N[:M[:N2[:M2]]]" string FLAG into a pair of struct align_flags.  */
    1299                 :            : 
    1300                 :            : static void
    1301                 :  922354000 : parse_N_M (const char *flag, align_flags &a)
    1302                 :            : {
    1303                 :  922354000 :   if (flag)
    1304                 :            :     {
    1305                 :  789471000 :       static hash_map <nofree_string_hash, align_flags> cache;
    1306                 :  789471000 :       align_flags *entry = cache.get (flag);
    1307                 :  789471000 :       if (entry)
    1308                 :            :         {
    1309                 :  789202000 :           a = *entry;
    1310                 :  789202000 :           return;
    1311                 :            :         }
    1312                 :            : 
    1313                 :     537096 :       auto_vec<unsigned> result_values;
    1314                 :     268548 :       bool r = parse_and_check_align_values (flag, NULL, result_values, false,
    1315                 :            :                                              UNKNOWN_LOCATION);
    1316                 :     268548 :       if (!r)
    1317                 :  789202000 :         return;
    1318                 :            : 
    1319                 :            :       /* Reverse values for easier manipulation.  */
    1320                 :     268548 :       result_values.reverse ();
    1321                 :            : 
    1322                 :     268548 :       read_log_maxskip (result_values, &a.levels[0]);
    1323                 :     268548 :       if (!result_values.is_empty ())
    1324                 :     179048 :         read_log_maxskip (result_values, &a.levels[1]);
    1325                 :            : #ifdef SUBALIGN_LOG
    1326                 :            :       else
    1327                 :            :         {
    1328                 :            :           /* N2[:M2] is not specified.  This arch has a default for N2.
    1329                 :            :              Before -falign-foo=N:M:N2:M2 was introduced, x86 had a tweak.
    1330                 :            :              -falign-functions=N with N > 8 was adding secondary alignment.
    1331                 :            :              -falign-functions=10 was emitting this before every function:
    1332                 :            :                         .p2align 4,,9
    1333                 :            :                         .p2align 3
    1334                 :            :              Now this behavior (and more) can be explicitly requested:
    1335                 :            :              -falign-functions=16:10:8
    1336                 :            :              Retain old behavior if N2 is missing: */
    1337                 :            : 
    1338                 :      89500 :           int align = 1 << a.levels[0].log;
    1339                 :      89500 :           int subalign = 1 << SUBALIGN_LOG;
    1340                 :            : 
    1341                 :      89500 :           if (a.levels[0].log > SUBALIGN_LOG
    1342                 :      89499 :               && a.levels[0].maxskip >= subalign - 1)
    1343                 :            :             {
    1344                 :            :               /* Set N2 unless subalign can never have any effect.  */
    1345                 :      89499 :               if (align > a.levels[0].maxskip + 1)
    1346                 :            :                 {
    1347                 :         18 :                   a.levels[1].log = SUBALIGN_LOG;
    1348                 :         18 :                   a.levels[1].normalize ();
    1349                 :            :                 }
    1350                 :            :             }
    1351                 :            :         }
    1352                 :            : #endif
    1353                 :            : 
    1354                 :            :       /* Cache seen value.  */
    1355                 :     268548 :       cache.put (flag, a);
    1356                 :            :     }
    1357                 :            : }
    1358                 :            : 
    1359                 :            : /* Process -falign-foo=N[:M[:N2[:M2]]] options.  */
    1360                 :            : 
    1361                 :            : void
    1362                 :  230588000 : parse_alignment_opts (void)
    1363                 :            : {
    1364                 :  230588000 :   parse_N_M (str_align_loops, align_loops);
    1365                 :  230588000 :   parse_N_M (str_align_jumps, align_jumps);
    1366                 :  230588000 :   parse_N_M (str_align_labels, align_labels);
    1367                 :  230588000 :   parse_N_M (str_align_functions, align_functions);
    1368                 :  230588000 : }
    1369                 :            : 
    1370                 :            : /* Process the options that have been parsed.  */
    1371                 :            : static void
    1372                 :     200477 : process_options (void)
    1373                 :            : {
    1374                 :            :   /* Just in case lang_hooks.post_options ends up calling a debug_hook.
    1375                 :            :      This can happen with incorrect pre-processed input. */
    1376                 :     200477 :   debug_hooks = &do_nothing_debug_hooks;
    1377                 :            : 
    1378                 :     200477 :   maximum_field_alignment = initial_max_fld_align * BITS_PER_UNIT;
    1379                 :            : 
    1380                 :            :   /* Allow the front end to perform consistency checks and do further
    1381                 :            :      initialization based on the command line options.  This hook also
    1382                 :            :      sets the original filename if appropriate (e.g. foo.i -> foo.c)
    1383                 :            :      so we can correctly initialize debug output.  */
    1384                 :     200477 :   no_backend = lang_hooks.post_options (&main_input_filename);
    1385                 :            : 
    1386                 :            :   /* Some machines may reject certain combinations of options.  */
    1387                 :     200477 :   location_t saved_location = input_location;
    1388                 :     200477 :   input_location = UNKNOWN_LOCATION;
    1389                 :     200477 :   targetm.target_option.override ();
    1390                 :     200477 :   input_location = saved_location;
    1391                 :            : 
    1392                 :     200477 :   if (flag_diagnostics_generate_patch)
    1393                 :         18 :       global_dc->edit_context_ptr = new edit_context ();
    1394                 :            : 
    1395                 :            :   /* Avoid any informative notes in the second run of -fcompare-debug.  */
    1396                 :     200477 :   if (flag_compare_debug) 
    1397                 :        795 :     diagnostic_inhibit_notes (global_dc);
    1398                 :            : 
    1399                 :     200477 :   if (flag_section_anchors && !target_supports_section_anchors_p ())
    1400                 :            :     {
    1401                 :          0 :       warning_at (UNKNOWN_LOCATION, OPT_fsection_anchors,
    1402                 :            :                   "this target does not support %qs",
    1403                 :            :                   "-fsection-anchors");
    1404                 :          0 :       flag_section_anchors = 0;
    1405                 :            :     }
    1406                 :            : 
    1407                 :     200477 :   if (flag_short_enums == 2)
    1408                 :     200371 :     flag_short_enums = targetm.default_short_enums ();
    1409                 :            : 
    1410                 :            :   /* Set aux_base_name if not already set.  */
    1411                 :     200477 :   if (aux_base_name)
    1412                 :            :     ;
    1413                 :       2830 :   else if (main_input_filename)
    1414                 :            :     {
    1415                 :       2830 :       char *name = xstrdup (lbasename (main_input_filename));
    1416                 :            : 
    1417                 :       2830 :       strip_off_ending (name, strlen (name));
    1418                 :       2830 :       aux_base_name = name;
    1419                 :            :     }
    1420                 :            :   else
    1421                 :          0 :     aux_base_name = "gccaux";
    1422                 :            : 
    1423                 :            : #ifndef HAVE_isl
    1424                 :            :   if (flag_graphite
    1425                 :            :       || flag_loop_nest_optimize
    1426                 :            :       || flag_graphite_identity
    1427                 :            :       || flag_loop_parallelize_all)
    1428                 :            :     sorry ("Graphite loop optimizations cannot be used (isl is not available) "
    1429                 :            :            "(%<-fgraphite%>, %<-fgraphite-identity%>, "
    1430                 :            :            "%<-floop-nest-optimize%>, %<-floop-parallelize-all%>)");
    1431                 :            : #endif
    1432                 :            : 
    1433                 :     200477 :   if (flag_cf_protection != CF_NONE
    1434                 :        148 :       && !(flag_cf_protection & CF_SET))
    1435                 :            :     {
    1436                 :          0 :       if (flag_cf_protection == CF_FULL)
    1437                 :            :         {
    1438                 :          0 :           error_at (UNKNOWN_LOCATION,
    1439                 :            :                     "%<-fcf-protection=full%> is not supported for this "
    1440                 :            :                     "target");
    1441                 :          0 :           flag_cf_protection = CF_NONE;
    1442                 :            :         }
    1443                 :          0 :       if (flag_cf_protection == CF_BRANCH)
    1444                 :            :         {
    1445                 :          0 :           error_at (UNKNOWN_LOCATION,
    1446                 :            :                     "%<-fcf-protection=branch%> is not supported for this "
    1447                 :            :                     "target");
    1448                 :          0 :           flag_cf_protection = CF_NONE;
    1449                 :            :         }
    1450                 :          0 :       if (flag_cf_protection == CF_RETURN)
    1451                 :            :         {
    1452                 :          0 :           error_at (UNKNOWN_LOCATION,
    1453                 :            :                     "%<-fcf-protection=return%> is not supported for this "
    1454                 :            :                     "target");
    1455                 :          0 :           flag_cf_protection = CF_NONE;
    1456                 :            :         }
    1457                 :            :     }
    1458                 :            : 
    1459                 :            :   /* One region RA really helps to decrease the code size.  */
    1460                 :     200477 :   if (flag_ira_region == IRA_REGION_AUTODETECT)
    1461                 :     200473 :     flag_ira_region
    1462                 :     316669 :       = optimize_size || !optimize ? IRA_REGION_ONE : IRA_REGION_MIXED;
    1463                 :            : 
    1464                 :     200477 :   if (!abi_version_at_least (2))
    1465                 :            :     {
    1466                 :            :       /* -fabi-version=1 support was removed after GCC 4.9.  */
    1467                 :          0 :       error_at (UNKNOWN_LOCATION,
    1468                 :            :                 "%<-fabi-version=1%> is no longer supported");
    1469                 :          0 :       flag_abi_version = 2;
    1470                 :            :     }
    1471                 :            : 
    1472                 :            :   /* Unrolling all loops implies that standard loop unrolling must also
    1473                 :            :      be done.  */
    1474                 :     200477 :   if (flag_unroll_all_loops)
    1475                 :         25 :     flag_unroll_loops = 1;
    1476                 :            : 
    1477                 :            :   /* web and rename-registers help when run after loop unrolling.  */
    1478                 :     200477 :   if (flag_web == AUTODETECT_VALUE)
    1479                 :     200454 :     flag_web = flag_unroll_loops;
    1480                 :            : 
    1481                 :     200477 :   if (flag_rename_registers == AUTODETECT_VALUE)
    1482                 :     200415 :     flag_rename_registers = flag_unroll_loops;
    1483                 :            : 
    1484                 :     200477 :   if (flag_non_call_exceptions)
    1485                 :       4119 :     flag_asynchronous_unwind_tables = 1;
    1486                 :     200477 :   if (flag_asynchronous_unwind_tables)
    1487                 :     200443 :     flag_unwind_tables = 1;
    1488                 :            : 
    1489                 :     200477 :   if (flag_value_profile_transformations)
    1490                 :        126 :     flag_profile_values = 1;
    1491                 :            : 
    1492                 :            :   /* Warn about options that are not supported on this machine.  */
    1493                 :            : #ifndef INSN_SCHEDULING
    1494                 :            :   if (flag_schedule_insns || flag_schedule_insns_after_reload)
    1495                 :            :     warning_at (UNKNOWN_LOCATION, 0,
    1496                 :            :                 "instruction scheduling not supported on this target machine");
    1497                 :            : #endif
    1498                 :     200477 :   if (!DELAY_SLOTS && flag_delayed_branch)
    1499                 :          0 :     warning_at (UNKNOWN_LOCATION, 0,
    1500                 :            :                 "this target machine does not have delayed branches");
    1501                 :            : 
    1502                 :     200477 :   user_label_prefix = USER_LABEL_PREFIX;
    1503                 :     200477 :   if (flag_leading_underscore != -1)
    1504                 :            :     {
    1505                 :            :       /* If the default prefix is more complicated than "" or "_",
    1506                 :            :          issue a warning and ignore this option.  */
    1507                 :          3 :       if (user_label_prefix[0] == 0 ||
    1508                 :            :           (user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
    1509                 :            :         {
    1510                 :          3 :           user_label_prefix = flag_leading_underscore ? "_" : "";
    1511                 :            :         }
    1512                 :            :       else
    1513                 :            :         warning_at (UNKNOWN_LOCATION, 0,
    1514                 :            :                     "%<-f%sleading-underscore%> not supported on this "
    1515                 :            :                     "target machine", flag_leading_underscore ? "" : "no-");
    1516                 :            :     }
    1517                 :            : 
    1518                 :            :   /* If we are in verbose mode, write out the version and maybe all the
    1519                 :            :      option flags in use.  */
    1520                 :     200477 :   if (version_flag)
    1521                 :            :     {
    1522                 :        109 :       print_version (stderr, "", true);
    1523                 :        109 :       if (! quiet_flag)
    1524                 :          0 :         print_switch_values (print_to_stderr);
    1525                 :            :     }
    1526                 :            : 
    1527                 :     200477 :   if (flag_syntax_only)
    1528                 :            :     {
    1529                 :         96 :       write_symbols = NO_DEBUG;
    1530                 :         96 :       profile_flag = 0;
    1531                 :            :     }
    1532                 :            : 
    1533                 :     200477 :   if (flag_gtoggle)
    1534                 :            :     {
    1535                 :        787 :       if (debug_info_level == DINFO_LEVEL_NONE)
    1536                 :            :         {
    1537                 :        242 :           debug_info_level = DINFO_LEVEL_NORMAL;
    1538                 :            : 
    1539                 :        242 :           if (write_symbols == NO_DEBUG)
    1540                 :        242 :             write_symbols = PREFERRED_DEBUGGING_TYPE;
    1541                 :            :         }
    1542                 :            :       else
    1543                 :        545 :         debug_info_level = DINFO_LEVEL_NONE;
    1544                 :            :     }
    1545                 :            : 
    1546                 :     200477 :   if (flag_dump_final_insns && !flag_syntax_only && !no_backend)
    1547                 :            :     {
    1548                 :       1593 :       FILE *final_output = fopen (flag_dump_final_insns, "w");
    1549                 :       1593 :       if (!final_output)
    1550                 :            :         {
    1551                 :          0 :           error_at (UNKNOWN_LOCATION,
    1552                 :            :                     "could not open final insn dump file %qs: %m",
    1553                 :            :                     flag_dump_final_insns);
    1554                 :          0 :           flag_dump_final_insns = NULL;
    1555                 :            :         }
    1556                 :       1593 :       else if (fclose (final_output))
    1557                 :            :         {
    1558                 :          0 :           error_at (UNKNOWN_LOCATION,
    1559                 :            :                     "could not close zeroed insn dump file %qs: %m",
    1560                 :            :                     flag_dump_final_insns);
    1561                 :          0 :           flag_dump_final_insns = NULL;
    1562                 :            :         }
    1563                 :            :     }
    1564                 :            : 
    1565                 :            :   /* A lot of code assumes write_symbols == NO_DEBUG if the debugging
    1566                 :            :      level is 0.  */
    1567                 :     200477 :   if (debug_info_level == DINFO_LEVEL_NONE)
    1568                 :     158165 :     write_symbols = NO_DEBUG;
    1569                 :            : 
    1570                 :     200477 :   if (write_symbols == NO_DEBUG)
    1571                 :            :     ;
    1572                 :            : #if defined(DBX_DEBUGGING_INFO)
    1573                 :      42312 :   else if (write_symbols == DBX_DEBUG)
    1574                 :       2824 :     debug_hooks = &dbx_debug_hooks;
    1575                 :            : #endif
    1576                 :            : #if defined(XCOFF_DEBUGGING_INFO)
    1577                 :            :   else if (write_symbols == XCOFF_DEBUG)
    1578                 :            :     debug_hooks = &xcoff_debug_hooks;
    1579                 :            : #endif
    1580                 :            : #ifdef DWARF2_DEBUGGING_INFO
    1581                 :      39488 :   else if (write_symbols == DWARF2_DEBUG)
    1582                 :      39422 :     debug_hooks = &dwarf2_debug_hooks;
    1583                 :            : #endif
    1584                 :            : #ifdef VMS_DEBUGGING_INFO
    1585                 :            :   else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
    1586                 :            :     debug_hooks = &vmsdbg_debug_hooks;
    1587                 :            : #endif
    1588                 :            : #ifdef DWARF2_LINENO_DEBUGGING_INFO
    1589                 :            :   else if (write_symbols == DWARF2_DEBUG)
    1590                 :            :     debug_hooks = &dwarf2_lineno_debug_hooks;
    1591                 :            : #endif
    1592                 :            :   else
    1593                 :         66 :     error_at (UNKNOWN_LOCATION,
    1594                 :            :               "target system does not support the %qs debug format",
    1595                 :         66 :               debug_type_names[write_symbols]);
    1596                 :            : 
    1597                 :            :   /* We know which debug output will be used so we can set flag_var_tracking
    1598                 :            :      and flag_var_tracking_uninit if the user has not specified them.  */
    1599                 :     200477 :   if (debug_info_level < DINFO_LEVEL_NORMAL
    1600                 :      40467 :       || debug_hooks->var_location == do_nothing_debug_hooks.var_location)
    1601                 :            :     {
    1602                 :     162198 :       if (flag_var_tracking == 1
    1603                 :     162150 :           || flag_var_tracking_uninit == 1)
    1604                 :            :         {
    1605                 :         48 :           if (debug_info_level < DINFO_LEVEL_NORMAL)
    1606                 :         36 :             warning_at (UNKNOWN_LOCATION, 0,
    1607                 :            :                         "variable tracking requested, but useless unless "
    1608                 :            :                         "producing debug info");
    1609                 :            :           else
    1610                 :         12 :             warning_at (UNKNOWN_LOCATION, 0,
    1611                 :            :                         "variable tracking requested, but not supported "
    1612                 :            :                         "by this debug format");
    1613                 :            :         }
    1614                 :     162198 :       flag_var_tracking = 0;
    1615                 :     162198 :       flag_var_tracking_uninit = 0;
    1616                 :            :     }
    1617                 :            : 
    1618                 :            :   /* The debug hooks are used to implement -fdump-go-spec because it
    1619                 :            :      gives a simple and stable API for all the information we need to
    1620                 :            :      dump.  */
    1621                 :     200477 :   if (flag_dump_go_spec != NULL)
    1622                 :          3 :     debug_hooks = dump_go_spec_init (flag_dump_go_spec, debug_hooks);
    1623                 :            : 
    1624                 :            :   /* If the user specifically requested variable tracking with tagging
    1625                 :            :      uninitialized variables, we need to turn on variable tracking.
    1626                 :            :      (We already determined above that variable tracking is feasible.)  */
    1627                 :     200477 :   if (flag_var_tracking_uninit == 1)
    1628                 :          0 :     flag_var_tracking = 1;
    1629                 :            : 
    1630                 :     200477 :   if (flag_var_tracking == AUTODETECT_VALUE)
    1631                 :      38271 :     flag_var_tracking = optimize >= 1;
    1632                 :            : 
    1633                 :     200477 :   if (flag_var_tracking_uninit == AUTODETECT_VALUE)
    1634                 :          0 :     flag_var_tracking_uninit = flag_var_tracking;
    1635                 :            : 
    1636                 :     200477 :   if (flag_var_tracking_assignments == AUTODETECT_VALUE)
    1637                 :     200409 :     flag_var_tracking_assignments
    1638                 :     400818 :       = (flag_var_tracking
    1639                 :     365312 :          && !(flag_selective_scheduling || flag_selective_scheduling2));
    1640                 :            : 
    1641                 :     200477 :   if (flag_var_tracking_assignments_toggle)
    1642                 :          0 :     flag_var_tracking_assignments = !flag_var_tracking_assignments;
    1643                 :            : 
    1644                 :     200477 :   if (flag_var_tracking_assignments && !flag_var_tracking)
    1645                 :         10 :     flag_var_tracking = flag_var_tracking_assignments = -1;
    1646                 :            : 
    1647                 :     200477 :   if (flag_var_tracking_assignments
    1648                 :      35523 :       && (flag_selective_scheduling || flag_selective_scheduling2))
    1649                 :         12 :     warning_at (UNKNOWN_LOCATION, 0,
    1650                 :            :                 "var-tracking-assignments changes selective scheduling");
    1651                 :            : 
    1652                 :     200477 :   if (debug_nonbind_markers_p == AUTODETECT_VALUE)
    1653                 :     200477 :     debug_nonbind_markers_p
    1654                 :     400954 :       = (optimize
    1655                 :     126720 :          && debug_info_level >= DINFO_LEVEL_NORMAL
    1656                 :      36916 :          && (write_symbols == DWARF2_DEBUG
    1657                 :      36916 :              || write_symbols == VMS_AND_DWARF2_DEBUG)
    1658                 :     400963 :          && !(flag_selective_scheduling || flag_selective_scheduling2));
    1659                 :            : 
    1660                 :     200477 :   if (dwarf2out_as_loc_support == AUTODETECT_VALUE)
    1661                 :     200477 :     dwarf2out_as_loc_support
    1662                 :     200477 :       = dwarf2out_default_as_loc_support ();
    1663                 :     200477 :   if (dwarf2out_as_locview_support == AUTODETECT_VALUE)
    1664                 :     200477 :     dwarf2out_as_locview_support
    1665                 :     200477 :       = dwarf2out_default_as_locview_support ();
    1666                 :            : 
    1667                 :     200477 :   if (debug_variable_location_views == AUTODETECT_VALUE)
    1668                 :            :     {
    1669                 :     200477 :       debug_variable_location_views
    1670                 :     400954 :         = (flag_var_tracking
    1671                 :      35544 :            && debug_info_level >= DINFO_LEVEL_NORMAL
    1672                 :      35535 :            && (write_symbols == DWARF2_DEBUG
    1673                 :      35535 :                || write_symbols == VMS_AND_DWARF2_DEBUG)
    1674                 :      35535 :            && !dwarf_strict
    1675                 :      35534 :            && dwarf2out_as_loc_support
    1676                 :     400954 :            && dwarf2out_as_locview_support);
    1677                 :            :     }
    1678                 :          0 :   else if (debug_variable_location_views == -1 && dwarf_version != 5)
    1679                 :            :     {
    1680                 :          0 :       warning_at (UNKNOWN_LOCATION, 0,
    1681                 :            :                   "without %<-gdwarf-5%>, "
    1682                 :            :                   "%<-gvariable-location-views=incompat5%> "
    1683                 :            :                   "is equivalent to %<-gvariable-location-views%>");
    1684                 :          0 :       debug_variable_location_views = 1;
    1685                 :            :     }
    1686                 :            : 
    1687                 :     200477 :   if (debug_internal_reset_location_views == 2)
    1688                 :            :     {
    1689                 :     200477 :       debug_internal_reset_location_views
    1690                 :     400954 :         = (debug_variable_location_views
    1691                 :     400954 :            && targetm.reset_location_view);
    1692                 :            :     }
    1693                 :          0 :   else if (debug_internal_reset_location_views
    1694                 :          0 :            && !debug_variable_location_views)
    1695                 :            :     {
    1696                 :          0 :       warning_at (UNKNOWN_LOCATION, 0,
    1697                 :            :                   "%<-ginternal-reset-location-views%> is forced disabled "
    1698                 :            :                   "without %<-gvariable-location-views%>");
    1699                 :          0 :       debug_internal_reset_location_views = 0;
    1700                 :            :     }
    1701                 :            : 
    1702                 :     200477 :   if (debug_inline_points == AUTODETECT_VALUE)
    1703                 :     200477 :     debug_inline_points = debug_variable_location_views;
    1704                 :          0 :   else if (debug_inline_points && !debug_nonbind_markers_p)
    1705                 :            :     {
    1706                 :          0 :       warning_at (UNKNOWN_LOCATION, 0,
    1707                 :            :                   "%<-ginline-points%> is forced disabled without "
    1708                 :            :                   "%<-gstatement-frontiers%>");
    1709                 :          0 :       debug_inline_points = 0;
    1710                 :            :     }
    1711                 :            : 
    1712                 :     200477 :   if (flag_tree_cselim == AUTODETECT_VALUE)
    1713                 :            :     {
    1714                 :     200461 :       if (HAVE_conditional_move)
    1715                 :     200461 :         flag_tree_cselim = 1;
    1716                 :            :       else
    1717                 :            :         flag_tree_cselim = 0;
    1718                 :            :     }
    1719                 :            : 
    1720                 :            :   /* If auxiliary info generation is desired, open the output file.
    1721                 :            :      This goes in the same directory as the source file--unlike
    1722                 :            :      all the other output files.  */
    1723                 :     200477 :   if (flag_gen_aux_info)
    1724                 :            :     {
    1725                 :          0 :       aux_info_file = fopen (aux_info_file_name, "w");
    1726                 :          0 :       if (aux_info_file == 0)
    1727                 :          0 :         fatal_error (UNKNOWN_LOCATION,
    1728                 :            :                      "cannot open %s: %m", aux_info_file_name);
    1729                 :            :     }
    1730                 :            : 
    1731                 :     200477 :   if (!targetm_common.have_named_sections)
    1732                 :            :     {
    1733                 :          0 :       if (flag_function_sections)
    1734                 :            :         {
    1735                 :          0 :           warning_at (UNKNOWN_LOCATION, 0,
    1736                 :            :                       "%<-ffunction-sections%> not supported for this target");
    1737                 :          0 :           flag_function_sections = 0;
    1738                 :            :         }
    1739                 :          0 :       if (flag_data_sections)
    1740                 :            :         {
    1741                 :          0 :           warning_at (UNKNOWN_LOCATION, 0,
    1742                 :            :                       "%<-fdata-sections%> not supported for this target");
    1743                 :          0 :           flag_data_sections = 0;
    1744                 :            :         }
    1745                 :            :     }
    1746                 :            : 
    1747                 :     200477 :   if (flag_prefetch_loop_arrays > 0 && !targetm.code_for_prefetch)
    1748                 :            :     {
    1749                 :          0 :       warning_at (UNKNOWN_LOCATION, 0,
    1750                 :            :                   "%<-fprefetch-loop-arrays%> not supported for this target");
    1751                 :          0 :       flag_prefetch_loop_arrays = 0;
    1752                 :            :     }
    1753                 :     200477 :   else if (flag_prefetch_loop_arrays > 0 && !targetm.have_prefetch ())
    1754                 :            :     {
    1755                 :          0 :       warning_at (UNKNOWN_LOCATION, 0,
    1756                 :            :                   "%<-fprefetch-loop-arrays%> not supported for this target "
    1757                 :            :                   "(try %<-march%> switches)");
    1758                 :          0 :       flag_prefetch_loop_arrays = 0;
    1759                 :            :     }
    1760                 :            : 
    1761                 :            :   /* This combination of options isn't handled for i386 targets and doesn't
    1762                 :            :      make much sense anyway, so don't allow it.  */
    1763                 :     200477 :   if (flag_prefetch_loop_arrays > 0 && optimize_size)
    1764                 :            :     {
    1765                 :          2 :       warning_at (UNKNOWN_LOCATION, 0,
    1766                 :            :                   "%<-fprefetch-loop-arrays%> is not supported with %<-Os%>");
    1767                 :          2 :       flag_prefetch_loop_arrays = 0;
    1768                 :            :     }
    1769                 :            : 
    1770                 :            :   /* The presence of IEEE signaling NaNs, implies all math can trap.  */
    1771                 :     200477 :   if (flag_signaling_nans)
    1772                 :        200 :     flag_trapping_math = 1;
    1773                 :            : 
    1774                 :            :   /* We cannot reassociate if we want traps or signed zeros.  */
    1775                 :     200477 :   if (flag_associative_math && (flag_trapping_math || flag_signed_zeros))
    1776                 :            :     {
    1777                 :         11 :       warning_at (UNKNOWN_LOCATION, 0,
    1778                 :            :                   "%<-fassociative-math%> disabled; other options take "
    1779                 :            :                   "precedence");
    1780                 :         11 :       flag_associative_math = 0;
    1781                 :            :     }
    1782                 :            : 
    1783                 :            :   /* -fstack-clash-protection is not currently supported on targets
    1784                 :            :      where the stack grows up.  */
    1785                 :     200477 :   if (flag_stack_clash_protection && !STACK_GROWS_DOWNWARD)
    1786                 :            :     {
    1787                 :            :       warning_at (UNKNOWN_LOCATION, 0,
    1788                 :            :                   "%<-fstack-clash-protection%> is not supported on targets "
    1789                 :            :                   "where the stack grows from lower to higher addresses");
    1790                 :            :       flag_stack_clash_protection = 0;
    1791                 :            :     }
    1792                 :            : 
    1793                 :            :   /* We cannot support -fstack-check= and -fstack-clash-protection at
    1794                 :            :      the same time.  */
    1795                 :     200477 :   if (flag_stack_check != NO_STACK_CHECK && flag_stack_clash_protection)
    1796                 :            :     {
    1797                 :          0 :       warning_at (UNKNOWN_LOCATION, 0,
    1798                 :            :                   "%<-fstack-check=%> and %<-fstack-clash_protection%> are "
    1799                 :            :                   "mutually exclusive; disabling %<-fstack-check=%>");
    1800                 :          0 :       flag_stack_check = NO_STACK_CHECK;
    1801                 :            :     }
    1802                 :            : 
    1803                 :            :   /* With -fcx-limited-range, we do cheap and quick complex arithmetic.  */
    1804                 :     200477 :   if (flag_cx_limited_range)
    1805                 :       1301 :     flag_complex_method = 0;
    1806                 :            : 
    1807                 :            :   /* With -fcx-fortran-rules, we do something in-between cheap and C99.  */
    1808                 :     200477 :   if (flag_cx_fortran_rules)
    1809                 :       2241 :     flag_complex_method = 1;
    1810                 :            : 
    1811                 :            :   /* Targets must be able to place spill slots at lower addresses.  If the
    1812                 :            :      target already uses a soft frame pointer, the transition is trivial.  */
    1813                 :     200477 :   if (!FRAME_GROWS_DOWNWARD && flag_stack_protect)
    1814                 :            :     {
    1815                 :            :       warning_at (UNKNOWN_LOCATION, 0,
    1816                 :            :                   "%<-fstack-protector%> not supported for this target");
    1817                 :            :       flag_stack_protect = 0;
    1818                 :            :     }
    1819                 :     200477 :   if (!flag_stack_protect)
    1820                 :     200346 :     warn_stack_protect = 0;
    1821                 :            : 
    1822                 :            :   /* Address Sanitizer needs porting to each target architecture.  */
    1823                 :            : 
    1824                 :     200477 :   if ((flag_sanitize & SANITIZE_ADDRESS)
    1825                 :       2168 :       && (!FRAME_GROWS_DOWNWARD || targetm.asan_shadow_offset == NULL))
    1826                 :            :     {
    1827                 :          0 :       warning_at (UNKNOWN_LOCATION, 0,
    1828                 :            :                   "%<-fsanitize=address%> and %<-fsanitize=kernel-address%> "
    1829                 :            :                   "are not supported for this target");
    1830                 :          0 :       flag_sanitize &= ~SANITIZE_ADDRESS;
    1831                 :            :     }
    1832                 :            : 
    1833                 :            :  /* Do not use IPA optimizations for register allocation if profiler is active
    1834                 :            :     or patchable function entries are inserted for run-time instrumentation
    1835                 :            :     or port does not emit prologue and epilogue as RTL.  */
    1836                 :     200277 :   if (profile_flag || function_entry_patch_area_size
    1837                 :     400739 :       || !targetm.have_prologue () || !targetm.have_epilogue ())
    1838                 :        215 :     flag_ipa_ra = 0;
    1839                 :            : 
    1840                 :            :   /* Enable -Werror=coverage-mismatch when -Werror and -Wno-error
    1841                 :            :      have not been set.  */
    1842                 :     200477 :   if (!global_options_set.x_warnings_are_errors
    1843                 :     198179 :       && warn_coverage_mismatch
    1844                 :     198173 :       && (global_dc->classify_diagnostic[OPT_Wcoverage_mismatch] ==
    1845                 :            :           DK_UNSPECIFIED))
    1846                 :     198173 :     diagnostic_classify_diagnostic (global_dc, OPT_Wcoverage_mismatch,
    1847                 :            :                                     DK_ERROR, UNKNOWN_LOCATION);
    1848                 :            : 
    1849                 :            :   /* Save the current optimization options.  */
    1850                 :     200477 :   optimization_default_node = build_optimization_node (&global_options);
    1851                 :     200477 :   optimization_current_node = optimization_default_node;
    1852                 :            : 
    1853                 :     200477 :   if (flag_checking >= 2)
    1854                 :     200437 :     hash_table_sanitize_eq_limit
    1855                 :     200437 :       = param_hash_table_verification_limit;
    1856                 :            : 
    1857                 :            :   /* Please don't change global_options after this point, those changes won't
    1858                 :            :      be reflected in optimization_{default,current}_node.  */
    1859                 :     200477 : }
    1860                 :            : 
    1861                 :            : /* This function can be called multiple times to reinitialize the compiler
    1862                 :            :    back end when register classes or instruction sets have changed,
    1863                 :            :    before each function.  */
    1864                 :            : static void
    1865                 :     151582 : backend_init_target (void)
    1866                 :            : {
    1867                 :            :   /* This depends on stack_pointer_rtx.  */
    1868                 :     151582 :   init_fake_stack_mems ();
    1869                 :            : 
    1870                 :            :   /* Sets static_base_value[HARD_FRAME_POINTER_REGNUM], which is
    1871                 :            :      mode-dependent.  */
    1872                 :     151582 :   init_alias_target ();
    1873                 :            : 
    1874                 :            :   /* Depends on HARD_FRAME_POINTER_REGNUM.  */
    1875                 :     151582 :   if (!ira_use_lra_p)
    1876                 :          0 :     init_reload ();
    1877                 :            : 
    1878                 :            :   /* Depends on the enabled attribute.  */
    1879                 :     151582 :   recog_init ();
    1880                 :            : 
    1881                 :            :   /* The following initialization functions need to generate rtl, so
    1882                 :            :      provide a dummy function context for them.  */
    1883                 :     151582 :   init_dummy_function_start ();
    1884                 :            : 
    1885                 :            :   /* rtx_cost is mode-dependent, so cached values need to be recomputed
    1886                 :            :      on a mode change.  */
    1887                 :     151582 :   init_expmed ();
    1888                 :     151582 :   init_lower_subreg ();
    1889                 :     151582 :   init_set_costs ();
    1890                 :            : 
    1891                 :     151582 :   init_expr_target ();
    1892                 :     151582 :   ira_init ();
    1893                 :            : 
    1894                 :            :   /* We may need to recompute regno_save_code[] and regno_restore_code[]
    1895                 :            :      after a mode change as well.  */
    1896                 :     151582 :   caller_save_initialized_p = false;
    1897                 :            : 
    1898                 :     151582 :   expand_dummy_function_end ();
    1899                 :     151582 : }
    1900                 :            : 
    1901                 :            : /* Initialize the compiler back end.  This function is called only once,
    1902                 :            :    when starting the compiler.  */
    1903                 :            : static void
    1904                 :     198351 : backend_init (void)
    1905                 :            : {
    1906                 :     198351 :   init_emit_once ();
    1907                 :            : 
    1908                 :     198351 :   init_rtlanal ();
    1909                 :     198351 :   init_inline_once ();
    1910                 :     198351 :   init_varasm_once ();
    1911                 :     198351 :   save_register_info ();
    1912                 :            : 
    1913                 :            :   /* Middle end needs this initialization for default mem attributes
    1914                 :            :      used by early calls to make_decl_rtl.  */
    1915                 :     198351 :   init_emit_regs ();
    1916                 :            : 
    1917                 :            :   /* Middle end needs this initialization for mode tables used to assign
    1918                 :            :      modes to vector variables.  */
    1919                 :     198351 :   init_regs ();
    1920                 :     198351 : }
    1921                 :            : 
    1922                 :            : /* Initialize things that are both lang-dependent and target-dependent.
    1923                 :            :    This function can be called more than once if target parameters change.  */
    1924                 :            : static void
    1925                 :     448615 : lang_dependent_init_target (void)
    1926                 :            : {
    1927                 :            :   /* This creates various _DECL nodes, so needs to be called after the
    1928                 :            :      front end is initialized.  It also depends on the HAVE_xxx macros
    1929                 :            :      generated from the target machine description.  */
    1930                 :     448615 :   init_optabs ();
    1931                 :            : 
    1932                 :     448615 :   gcc_assert (!this_target_rtl->target_specific_initialized);
    1933                 :     448615 : }
    1934                 :            : 
    1935                 :            : /* Perform initializations that are lang-dependent or target-dependent.
    1936                 :            :    but matters only for late optimizations and RTL generation.  */
    1937                 :            : 
    1938                 :            : static int rtl_initialized;
    1939                 :            : 
    1940                 :            : void
    1941                 :     948632 : initialize_rtl (void)
    1942                 :            : {
    1943                 :     948632 :   auto_timevar tv (g_timer, TV_INITIALIZE_RTL);
    1944                 :            : 
    1945                 :            :   /* Initialization done just once per compilation, but delayed
    1946                 :            :      till code generation.  */
    1947                 :     948632 :   if (!rtl_initialized)
    1948                 :     149492 :     ira_init_once ();
    1949                 :     948632 :   rtl_initialized = true;
    1950                 :            : 
    1951                 :            :   /* Target specific RTL backend initialization.  */
    1952                 :     948632 :   if (!this_target_rtl->target_specific_initialized)
    1953                 :            :     {
    1954                 :     151582 :       backend_init_target ();
    1955                 :     151582 :       this_target_rtl->target_specific_initialized = true;
    1956                 :            :     }
    1957                 :     948632 : }
    1958                 :            : 
    1959                 :            : /* Language-dependent initialization.  Returns nonzero on success.  */
    1960                 :            : static int
    1961                 :     200291 : lang_dependent_init (const char *name)
    1962                 :            : {
    1963                 :     200291 :   location_t save_loc = input_location;
    1964                 :     200291 :   if (dump_base_name == 0)
    1965                 :       2832 :     dump_base_name = name && name[0] ? name : "gccdump";
    1966                 :            : 
    1967                 :            :   /* Other front-end initialization.  */
    1968                 :     200291 :   input_location = BUILTINS_LOCATION;
    1969                 :     200291 :   if (lang_hooks.init () == 0)
    1970                 :            :     return 0;
    1971                 :     198350 :   input_location = save_loc;
    1972                 :            : 
    1973                 :     198350 :   if (!flag_wpa)
    1974                 :            :     {
    1975                 :     193317 :       init_asm_output (name);
    1976                 :            : 
    1977                 :            :       /* If stack usage information is desired, open the output file.  */
    1978                 :     193317 :       if (flag_stack_usage && !flag_generate_lto)
    1979                 :          4 :         stack_usage_file = open_auxiliary_file ("su");
    1980                 :            : 
    1981                 :            :       /* If call graph information is desired, open the output file.  */
    1982                 :     193317 :       if (flag_callgraph_info && !flag_generate_lto)
    1983                 :            :         {
    1984                 :          0 :           callgraph_info_file = open_auxiliary_file ("ci");
    1985                 :            :           /* Write the file header.  */
    1986                 :          0 :           fprintf (callgraph_info_file,
    1987                 :            :                    "graph: { title: \"%s\"\n", main_input_filename);
    1988                 :          0 :           bitmap_obstack_initialize (NULL);
    1989                 :          0 :           callgraph_info_external_printed = BITMAP_ALLOC (NULL);
    1990                 :            :         }
    1991                 :            :     }
    1992                 :            : 
    1993                 :            :   /* This creates various _DECL nodes, so needs to be called after the
    1994                 :            :      front end is initialized.  */
    1995                 :     198350 :   init_eh ();
    1996                 :            : 
    1997                 :            :   /* Do the target-specific parts of the initialization.  */
    1998                 :     198350 :   lang_dependent_init_target ();
    1999                 :            : 
    2000                 :     198350 :   if (!flag_wpa)
    2001                 :            :     {
    2002                 :            :       /* If dbx symbol table desired, initialize writing it and output the
    2003                 :            :          predefined types.  */
    2004                 :     193317 :       timevar_push (TV_SYMOUT);
    2005                 :            : 
    2006                 :            :       /* Now we have the correct original filename, we can initialize
    2007                 :            :          debug output.  */
    2008                 :     193317 :       (*debug_hooks->init) (name);
    2009                 :            : 
    2010                 :     193317 :       timevar_pop (TV_SYMOUT);
    2011                 :            :     }
    2012                 :            : 
    2013                 :            :   return 1;
    2014                 :            : }
    2015                 :            : 
    2016                 :            : 
    2017                 :            : /* Reinitialize everything when target parameters, such as register usage,
    2018                 :            :    have changed.  */
    2019                 :            : void
    2020                 :     250265 : target_reinit (void)
    2021                 :            : {
    2022                 :     250265 :   struct rtl_data saved_x_rtl;
    2023                 :     250265 :   rtx *saved_regno_reg_rtx;
    2024                 :     250265 :   tree saved_optimization_current_node;
    2025                 :     250265 :   struct target_optabs *saved_this_fn_optabs;
    2026                 :            : 
    2027                 :            :   /* Temporarily switch to the default optimization node, so that
    2028                 :            :      *this_target_optabs is set to the default, not reflecting
    2029                 :            :      whatever a previous function used for the optimize
    2030                 :            :      attribute.  */
    2031                 :     250265 :   saved_optimization_current_node = optimization_current_node;
    2032                 :     250265 :   saved_this_fn_optabs = this_fn_optabs;
    2033                 :     250265 :   if (saved_optimization_current_node != optimization_default_node)
    2034                 :            :     {
    2035                 :          0 :       optimization_current_node = optimization_default_node;
    2036                 :          0 :       cl_optimization_restore
    2037                 :          0 :         (&global_options,
    2038                 :          0 :          TREE_OPTIMIZATION (optimization_default_node));
    2039                 :            :     }
    2040                 :     250265 :   this_fn_optabs = this_target_optabs;
    2041                 :            : 
    2042                 :            :   /* Save *crtl and regno_reg_rtx around the reinitialization
    2043                 :            :      to allow target_reinit being called even after prepare_function_start.  */
    2044                 :     250265 :   saved_regno_reg_rtx = regno_reg_rtx;
    2045                 :     250265 :   if (saved_regno_reg_rtx)
    2046                 :            :     {  
    2047                 :          1 :       saved_x_rtl = *crtl;
    2048                 :          1 :       memset (crtl, '\0', sizeof (*crtl));
    2049                 :          1 :       regno_reg_rtx = NULL;
    2050                 :            :     }
    2051                 :            : 
    2052                 :     250265 :   this_target_rtl->target_specific_initialized = false;
    2053                 :            : 
    2054                 :            :   /* This initializes hard_frame_pointer, and calls init_reg_modes_target()
    2055                 :            :      to initialize reg_raw_mode[].  */
    2056                 :     250265 :   init_emit_regs ();
    2057                 :            : 
    2058                 :            :   /* This invokes target hooks to set fixed_reg[] etc, which is
    2059                 :            :      mode-dependent.  */
    2060                 :     250265 :   init_regs ();
    2061                 :            : 
    2062                 :            :   /* Reinitialize lang-dependent parts.  */
    2063                 :     250265 :   lang_dependent_init_target ();
    2064                 :            : 
    2065                 :            :   /* Restore the original optimization node.  */
    2066                 :     250265 :   if (saved_optimization_current_node != optimization_default_node)
    2067                 :            :     {
    2068                 :          0 :       optimization_current_node = saved_optimization_current_node;
    2069                 :          0 :       cl_optimization_restore (&global_options,
    2070                 :          0 :                                TREE_OPTIMIZATION (optimization_current_node));
    2071                 :            :     }
    2072                 :     250265 :   this_fn_optabs = saved_this_fn_optabs;
    2073                 :            : 
    2074                 :            :   /* Restore regno_reg_rtx at the end, as free_after_compilation from
    2075                 :            :      expand_dummy_function_end clears it.  */
    2076                 :     250265 :   if (saved_regno_reg_rtx)
    2077                 :            :     {
    2078                 :          1 :       *crtl = saved_x_rtl;
    2079                 :          1 :       regno_reg_rtx = saved_regno_reg_rtx;
    2080                 :          1 :       saved_regno_reg_rtx = NULL;
    2081                 :            :     }
    2082                 :     250265 : }
    2083                 :            : 
    2084                 :            : void
    2085                 :          0 : dump_memory_report (const char *header)
    2086                 :            : {
    2087                 :            :   /* Print significant header.  */
    2088                 :          0 :   fputc ('\n', stderr);
    2089                 :          0 :   for (unsigned i = 0; i < 80; i++)
    2090                 :          0 :     fputc ('#', stderr);
    2091                 :          0 :   fprintf (stderr, "\n# %-77s#\n", header);
    2092                 :          0 :   for (unsigned i = 0; i < 80; i++)
    2093                 :          0 :     fputc ('#', stderr);
    2094                 :          0 :   fputs ("\n\n", stderr);
    2095                 :            : 
    2096                 :          0 :   dump_line_table_statistics ();
    2097                 :          0 :   ggc_print_statistics ();
    2098                 :          0 :   stringpool_statistics ();
    2099                 :          0 :   dump_tree_statistics ();
    2100                 :          0 :   dump_gimple_statistics ();
    2101                 :          0 :   dump_rtx_statistics ();
    2102                 :          0 :   dump_alloc_pool_statistics ();
    2103                 :          0 :   dump_bitmap_statistics ();
    2104                 :          0 :   dump_hash_table_loc_statistics ();
    2105                 :          0 :   dump_vec_loc_statistics ();
    2106                 :          0 :   dump_ggc_loc_statistics ();
    2107                 :          0 :   dump_alias_stats (stderr);
    2108                 :          0 :   dump_pta_stats (stderr);
    2109                 :          0 : }
    2110                 :            : 
    2111                 :            : /* Clean up: close opened files, etc.  */
    2112                 :            : 
    2113                 :            : static void
    2114                 :     199964 : finalize (bool no_backend)
    2115                 :            : {
    2116                 :            :   /* Close the dump files.  */
    2117                 :     199964 :   if (flag_gen_aux_info)
    2118                 :            :     {
    2119                 :          0 :       fclose (aux_info_file);
    2120                 :          0 :       aux_info_file = NULL;
    2121                 :          0 :       if (seen_error ())
    2122                 :          0 :         unlink (aux_info_file_name);
    2123                 :            :     }
    2124                 :            : 
    2125                 :            :   /* Close non-debugging input and output files.  Take special care to note
    2126                 :            :      whether fclose returns an error, since the pages might still be on the
    2127                 :            :      buffer chain while the file is open.  */
    2128                 :            : 
    2129                 :     199964 :   if (asm_out_file)
    2130                 :            :     {
    2131                 :     193113 :       if (ferror (asm_out_file) != 0)
    2132                 :          0 :         fatal_error (input_location, "error writing to %s: %m", asm_file_name);
    2133                 :     193113 :       if (fclose (asm_out_file) != 0)
    2134                 :          0 :         fatal_error (input_location, "error closing %s: %m", asm_file_name);
    2135                 :     193113 :       asm_out_file = NULL;
    2136                 :            :     }
    2137                 :            : 
    2138                 :     199964 :   if (stack_usage_file)
    2139                 :            :     {
    2140                 :          4 :       fclose (stack_usage_file);
    2141                 :          4 :       stack_usage_file = NULL;
    2142                 :            :     }
    2143                 :            : 
    2144                 :     199964 :   if (callgraph_info_file)
    2145                 :            :     {
    2146                 :          0 :       fputs ("}\n", callgraph_info_file);
    2147                 :          0 :       fclose (callgraph_info_file);
    2148                 :          0 :       callgraph_info_file = NULL;
    2149                 :          0 :       BITMAP_FREE (callgraph_info_external_printed);
    2150                 :          0 :       bitmap_obstack_release (NULL);
    2151                 :            :     }
    2152                 :            : 
    2153                 :     199964 :   if (seen_error ())
    2154                 :      20929 :     coverage_remove_note_file ();
    2155                 :            : 
    2156                 :     199964 :   if (!no_backend)
    2157                 :            :     {
    2158                 :     198146 :       statistics_fini ();
    2159                 :     198146 :       debuginfo_fini ();
    2160                 :            : 
    2161                 :     198146 :       g->get_passes ()->finish_optimization_passes ();
    2162                 :            : 
    2163                 :     198146 :       lra_finish_once ();
    2164                 :            :     }
    2165                 :            : 
    2166                 :     199964 :   if (mem_report)
    2167                 :          0 :     dump_memory_report ("Final");
    2168                 :            : 
    2169                 :     199964 :   if (profile_report)
    2170                 :          0 :     dump_profile_report ();
    2171                 :            : 
    2172                 :            :   /* Language-specific end of compilation actions.  */
    2173                 :     199964 :   lang_hooks.finish ();
    2174                 :     199964 : }
    2175                 :            : 
    2176                 :            : static bool
    2177                 :     194627 : standard_type_bitsize (int bitsize)
    2178                 :            : {
    2179                 :            :   /* As a special exception, we always want __int128 enabled if possible.  */
    2180                 :     194627 :   if (bitsize == 128)
    2181                 :            :     return false;
    2182                 :          0 :   if (bitsize == CHAR_TYPE_SIZE
    2183                 :          0 :       || bitsize == SHORT_TYPE_SIZE
    2184                 :          0 :       || bitsize == INT_TYPE_SIZE
    2185                 :          0 :       || bitsize == LONG_TYPE_SIZE
    2186                 :          0 :       || bitsize == LONG_LONG_TYPE_SIZE)
    2187                 :          0 :     return true;
    2188                 :            :   return false;
    2189                 :            : }
    2190                 :            : 
    2191                 :            : /* Initialize the compiler, and compile the input file.  */
    2192                 :            : static void
    2193                 :     200477 : do_compile ()
    2194                 :            : {
    2195                 :     200477 :   process_options ();
    2196                 :            : 
    2197                 :            :   /* Don't do any more if an error has already occurred.  */
    2198                 :     200477 :   if (!seen_error ())
    2199                 :            :     {
    2200                 :     200291 :       int i;
    2201                 :            : 
    2202                 :     200291 :       timevar_start (TV_PHASE_SETUP);
    2203                 :            : 
    2204                 :     200291 :       if (flag_save_optimization_record)
    2205                 :            :         {
    2206                 :         40 :           dump_context::get ().set_json_writer (new optrecord_json_writer ());
    2207                 :            :         }
    2208                 :            : 
    2209                 :            :       /* This must be run always, because it is needed to compute the FP
    2210                 :            :          predefined macros, such as __LDBL_MAX__, for targets using non
    2211                 :            :          default FP formats.  */
    2212                 :     200291 :       init_adjust_machine_modes ();
    2213                 :     200291 :       init_derived_machine_modes ();
    2214                 :            : 
    2215                 :            :       /* This must happen after the backend has a chance to process
    2216                 :            :          command line options, but before the parsers are
    2217                 :            :          initialized.  */
    2218                 :     400582 :       for (i = 0; i < NUM_INT_N_ENTS; i ++)
    2219                 :     200291 :         if (targetm.scalar_mode_supported_p (int_n_data[i].m)
    2220                 :     200291 :             && ! standard_type_bitsize (int_n_data[i].bitsize))
    2221                 :     194627 :           int_n_enabled_p[i] = true;
    2222                 :            :         else
    2223                 :       5664 :           int_n_enabled_p[i] = false;
    2224                 :            : 
    2225                 :            :       /* Initialize mpfrs exponent range.  This is important to get
    2226                 :            :          underflow/overflow in a reasonable timeframe.  */
    2227                 :     200291 :       machine_mode mode;
    2228                 :     200291 :       int min_exp = -1;
    2229                 :     200291 :       int max_exp = 1;
    2230                 :    1001460 :       FOR_EACH_MODE_IN_CLASS (mode, MODE_FLOAT)
    2231                 :     801164 :         if (SCALAR_FLOAT_MODE_P (mode))
    2232                 :            :           {
    2233                 :     801164 :             const real_format *fmt = REAL_MODE_FORMAT (mode);
    2234                 :     801164 :             if (fmt)
    2235                 :            :               {
    2236                 :            :                 /* fmt->emin - fmt->p + 1 should be enough but the
    2237                 :            :                    back-and-forth dance in real_to_decimal_for_mode we
    2238                 :            :                    do for checking fails due to rounding effects then.  */
    2239                 :     801164 :                 if ((fmt->emin - fmt->p) < min_exp)
    2240                 :            :                   min_exp = fmt->emin - fmt->p;
    2241                 :     801164 :                 if (fmt->emax > max_exp)
    2242                 :            :                   max_exp = fmt->emax;
    2243                 :            :               }
    2244                 :            :           }
    2245                 :            :       /* E.g. mpc_norm assumes it can square a number without bothering with
    2246                 :            :          with range scaling, so until that is fixed, double the minimum
    2247                 :            :          and maximum exponents, plus add some buffer for arithmetics
    2248                 :            :          on the squared numbers.  */
    2249                 :     200291 :       if (mpfr_set_emin (2 * (min_exp - 1))
    2250                 :     200291 :           || mpfr_set_emax (2 * (max_exp + 1)))
    2251                 :          0 :         sorry ("mpfr not configured to handle all floating modes");
    2252                 :            : 
    2253                 :            :       /* Set up the back-end if requested.  */
    2254                 :     200291 :       if (!no_backend)
    2255                 :     198351 :         backend_init ();
    2256                 :            : 
    2257                 :            :       /* Language-dependent initialization.  Returns true on success.  */
    2258                 :     200291 :       if (lang_dependent_init (main_input_filename))
    2259                 :            :         {
    2260                 :            :           /* Initialize yet another pass.  */
    2261                 :            : 
    2262                 :     198350 :           ggc_protect_identifiers = true;
    2263                 :            : 
    2264                 :     198350 :           symtab->initialize ();
    2265                 :     198350 :           init_final (main_input_filename);
    2266                 :     198350 :           coverage_init (aux_base_name);
    2267                 :     198350 :           statistics_init ();
    2268                 :     198350 :           debuginfo_init ();
    2269                 :     198350 :           invoke_plugin_callbacks (PLUGIN_START_UNIT, NULL);
    2270                 :            : 
    2271                 :     198350 :           timevar_stop (TV_PHASE_SETUP);
    2272                 :            : 
    2273                 :     198350 :           compile_file ();
    2274                 :            :         }
    2275                 :            :       else
    2276                 :            :         {
    2277                 :       1818 :           timevar_stop (TV_PHASE_SETUP);
    2278                 :            :         }
    2279                 :            : 
    2280                 :     199964 :       timevar_start (TV_PHASE_FINALIZE);
    2281                 :            : 
    2282                 :     199964 :       finalize (no_backend);
    2283                 :            : 
    2284                 :     199964 :       timevar_stop (TV_PHASE_FINALIZE);
    2285                 :            :     }
    2286                 :     200150 : }
    2287                 :            : 
    2288                 :     200540 : toplev::toplev (timer *external_timer,
    2289                 :     200540 :                 bool init_signals)
    2290                 :     200540 :   : m_use_TV_TOTAL (external_timer == NULL),
    2291                 :     200540 :     m_init_signals (init_signals)
    2292                 :            : {
    2293                 :     200540 :   if (external_timer)
    2294                 :        400 :     g_timer = external_timer;
    2295                 :     200540 : }
    2296                 :            : 
    2297                 :     400416 : toplev::~toplev ()
    2298                 :            : {
    2299                 :     200208 :   if (g_timer && m_use_TV_TOTAL)
    2300                 :            :     {
    2301                 :          8 :       g_timer->stop (TV_TOTAL);
    2302                 :          8 :       g_timer->print (stderr);
    2303                 :          8 :       delete g_timer;
    2304                 :          8 :       g_timer = NULL;
    2305                 :            :     }
    2306                 :     200208 : }
    2307                 :            : 
    2308                 :            : /* Potentially call timevar_init (which will create g_timevars if it
    2309                 :            :    doesn't already exist).  */
    2310                 :            : 
    2311                 :            : void
    2312                 :     200077 : toplev::start_timevars ()
    2313                 :            : {
    2314                 :     200077 :   if (time_report || !quiet_flag  || flag_detailed_statistics)
    2315                 :          8 :     timevar_init ();
    2316                 :            : 
    2317                 :     200077 :   timevar_start (TV_TOTAL);
    2318                 :     200077 : }
    2319                 :            : 
    2320                 :            : /* Handle -fself-test.   */
    2321                 :            : 
    2322                 :            : void
    2323                 :          3 : toplev::run_self_tests ()
    2324                 :            : {
    2325                 :          3 :   if (no_backend)
    2326                 :            :     {
    2327                 :          1 :       error_at (UNKNOWN_LOCATION, "self-tests incompatible with %<-E%>");
    2328                 :          1 :       return;
    2329                 :            :     }
    2330                 :            : #if CHECKING_P
    2331                 :            :   /* Reset some state.  */
    2332                 :          2 :   input_location = UNKNOWN_LOCATION;
    2333                 :          2 :   bitmap_obstack_initialize (NULL);
    2334                 :            : 
    2335                 :            :   /* Run the tests; any failures will lead to an abort of the process.
    2336                 :            :      Use "make selftests-gdb" to run under the debugger.  */
    2337                 :          2 :   ::selftest::run_tests ();
    2338                 :            : 
    2339                 :            :   /* Cleanup.  */
    2340                 :          2 :   bitmap_obstack_release (NULL);
    2341                 :            : #else
    2342                 :            :   inform (UNKNOWN_LOCATION, "self-tests are not enabled in this build");
    2343                 :            : #endif /* #if CHECKING_P */
    2344                 :            : }
    2345                 :            : 
    2346                 :            : /* Entry point of cc1, cc1plus, jc1, f771, etc.
    2347                 :            :    Exit code is FATAL_EXIT_CODE if can't open files or if there were
    2348                 :            :    any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
    2349                 :            : 
    2350                 :            :    It is not safe to call this function more than once.  */
    2351                 :            : 
    2352                 :            : int
    2353                 :     200540 : toplev::main (int argc, char **argv)
    2354                 :            : {
    2355                 :            :   /* Parsing and gimplification sometimes need quite large stack.
    2356                 :            :      Increase stack size limits if possible.  */
    2357                 :     200540 :   stack_limit_increase (64 * 1024 * 1024);
    2358                 :            : 
    2359                 :     200540 :   expandargv (&argc, &argv);
    2360                 :            : 
    2361                 :            :   /* Initialization of GCC's environment, and diagnostics.  */
    2362                 :     200540 :   general_init (argv[0], m_init_signals);
    2363                 :            : 
    2364                 :            :   /* One-off initialization of options that does not need to be
    2365                 :            :      repeated when options are added for particular functions.  */
    2366                 :     200540 :   init_options_once ();
    2367                 :     200540 :   init_opts_obstack ();
    2368                 :            : 
    2369                 :            :   /* Initialize global options structures; this must be repeated for
    2370                 :            :      each structure used for parsing options.  */
    2371                 :     200540 :   init_options_struct (&global_options, &global_options_set);
    2372                 :     200540 :   lang_hooks.init_options_struct (&global_options);
    2373                 :            : 
    2374                 :            :   /* Init GGC heuristics must be caller after we initialize
    2375                 :            :      options.  */
    2376                 :     200540 :   init_ggc_heuristics ();
    2377                 :            : 
    2378                 :            :   /* Convert the options to an array.  */
    2379                 :     200540 :   decode_cmdline_options_to_array_default_mask (argc,
    2380                 :            :                                                 CONST_CAST2 (const char **,
    2381                 :            :                                                              char **, argv),
    2382                 :            :                                                 &save_decoded_options,
    2383                 :            :                                                 &save_decoded_options_count);
    2384                 :            : 
    2385                 :            :   /* Perform language-specific options initialization.  */
    2386                 :     200540 :   lang_hooks.init_options (save_decoded_options_count, save_decoded_options);
    2387                 :            : 
    2388                 :            :   /* Parse the options and do minimal processing; basically just
    2389                 :            :      enough to default flags appropriately.  */
    2390                 :     200540 :   decode_options (&global_options, &global_options_set,
    2391                 :            :                   save_decoded_options, save_decoded_options_count,
    2392                 :            :                   UNKNOWN_LOCATION, global_dc,
    2393                 :            :                   targetm.target_option.override);
    2394                 :            : 
    2395                 :     200539 :   handle_common_deferred_options ();
    2396                 :            : 
    2397                 :     200535 :   init_local_tick ();
    2398                 :            : 
    2399                 :     200535 :   initialize_plugins ();
    2400                 :            : 
    2401                 :     200535 :   if (version_flag)
    2402                 :        112 :     print_version (stderr, "", true);
    2403                 :            : 
    2404                 :     200535 :   if (help_flag)
    2405                 :          3 :     print_plugins_help (stderr, "");
    2406                 :            : 
    2407                 :            :   /* Exit early if we can (e.g. -help).  */
    2408                 :     200535 :   if (!exit_after_options)
    2409                 :            :     {
    2410                 :     200477 :       if (m_use_TV_TOTAL)
    2411                 :     200077 :         start_timevars ();
    2412                 :     200477 :       do_compile ();
    2413                 :            :     }
    2414                 :            : 
    2415                 :     200208 :   if (warningcount || errorcount || werrorcount)
    2416                 :      28595 :     print_ignored_options ();
    2417                 :            : 
    2418                 :     200208 :   if (flag_self_test)
    2419                 :          3 :     run_self_tests ();
    2420                 :            : 
    2421                 :            :   /* Invoke registered plugin callbacks if any.  Some plugins could
    2422                 :            :      emit some diagnostics here.  */
    2423                 :     200208 :   invoke_plugin_callbacks (PLUGIN_FINISH, NULL);
    2424                 :            : 
    2425                 :     200208 :   if (flag_diagnostics_generate_patch)
    2426                 :            :     {
    2427                 :         18 :       gcc_assert (global_dc->edit_context_ptr);
    2428                 :            : 
    2429                 :         36 :       pretty_printer pp;
    2430                 :         18 :       pp_show_color (&pp) = pp_show_color (global_dc->printer);
    2431                 :         18 :       global_dc->edit_context_ptr->print_diff (&pp, true);
    2432                 :         18 :       pp_flush (&pp);
    2433                 :            :     }
    2434                 :            : 
    2435                 :     200208 :   diagnostic_finish (global_dc);
    2436                 :            : 
    2437                 :     200208 :   finalize_plugins ();
    2438                 :            : 
    2439                 :     200208 :   after_memory_report = true;
    2440                 :            : 
    2441                 :     200208 :   if (seen_error () || werrorcount)
    2442                 :      21244 :     return (FATAL_EXIT_CODE);
    2443                 :            : 
    2444                 :            :   return (SUCCESS_EXIT_CODE);
    2445                 :            : }
    2446                 :            : 
    2447                 :            : /* For those that want to, this function aims to clean up enough state that
    2448                 :            :    you can call toplev::main again. */
    2449                 :            : void
    2450                 :        888 : toplev::finalize (void)
    2451                 :            : {
    2452                 :        888 :   rtl_initialized = false;
    2453                 :        888 :   this_target_rtl->target_specific_initialized = false;
    2454                 :            : 
    2455                 :            :   /* Needs to be called before cgraph_c_finalize since it uses symtab.  */
    2456                 :        888 :   ipa_reference_c_finalize ();
    2457                 :        888 :   ipa_fnsummary_c_finalize ();
    2458                 :            : 
    2459                 :        888 :   cgraph_c_finalize ();
    2460                 :        888 :   cgraphunit_c_finalize ();
    2461                 :        888 :   dwarf2out_c_finalize ();
    2462                 :        888 :   gcse_c_finalize ();
    2463                 :        888 :   ipa_cp_c_finalize ();
    2464                 :        888 :   ira_costs_c_finalize ();
    2465                 :            : 
    2466                 :            :   /* save_decoded_options uses opts_obstack, so these must
    2467                 :            :      be cleaned up together.  */
    2468                 :        888 :   obstack_free (&opts_obstack, NULL);
    2469                 :        888 :   XDELETEVEC (save_decoded_options);
    2470                 :        888 :   save_decoded_options = NULL;
    2471                 :        888 :   save_decoded_options_count = 0;
    2472                 :            : 
    2473                 :            :   /* Clean up the context (and pass_manager etc). */
    2474                 :        888 :   delete g;
    2475                 :        888 :   g = NULL;
    2476                 :            : 
    2477                 :        888 : }

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.