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

Generated by: LCOV version 2.0-1

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,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.