LCOV - code coverage report
Current view: top level - gcc/m2 - gm2-lang.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 72.2 % 662 478
Test Date: 2024-12-21 13:15:12 Functions: 90.3 % 31 28
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* gm2-lang.cc language-dependent hooks for GNU Modula-2.
       2                 :             : 
       3                 :             : Copyright (C) 2002-2024 Free Software Foundation, Inc.
       4                 :             : Contributed by Gaius Mulley <gaius@glam.ac.uk>.
       5                 :             : 
       6                 :             : This file is part of GNU Modula-2.
       7                 :             : 
       8                 :             : GNU Modula-2 is free software; you can redistribute it and/or modify
       9                 :             : it under the terms of the GNU General Public License as published by
      10                 :             : the Free Software Foundation; either version 3, or (at your option)
      11                 :             : any later version.
      12                 :             : 
      13                 :             : GNU Modula-2 is distributed in the hope that it will be useful, but
      14                 :             : WITHOUT ANY WARRANTY; without even the implied warranty of
      15                 :             : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      16                 :             : General Public License for more details.
      17                 :             : 
      18                 :             : You should have received a copy of the GNU General Public License
      19                 :             : along with GCC; see the file COPYING3.  If not see
      20                 :             : <http://www.gnu.org/licenses/>.  */
      21                 :             : 
      22                 :             : #define INCLUDE_VECTOR
      23                 :             : #include "gm2-gcc/gcc-consolidation.h"
      24                 :             : 
      25                 :             : #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name.  */
      26                 :             : #include "tree-pass.h"     /* FIXME: only for PROP_gimple_any.  */
      27                 :             : #include "toplev.h"
      28                 :             : #include "debug.h"
      29                 :             : 
      30                 :             : #include "opts.h"
      31                 :             : 
      32                 :             : #define GM2_LANG_C
      33                 :             : #include "gm2-lang.h"
      34                 :             : #include "m2block.h"
      35                 :             : #include "dynamicstrings.h"
      36                 :             : #include "m2options.h"
      37                 :             : #include "m2convert.h"
      38                 :             : #include "m2linemap.h"
      39                 :             : #include "init.h"
      40                 :             : #include "m2-tree.h"
      41                 :             : #include "convert.h"
      42                 :             : #include "rtegraph.h"
      43                 :             : 
      44                 :             : static void write_globals (void);
      45                 :             : 
      46                 :             : static int insideCppArgs = FALSE;
      47                 :             : 
      48                 :             : /* We default to pim in the absence of fiso.  */
      49                 :             : static bool iso = false;
      50                 :             : 
      51                 :      598564 : typedef struct named_path_s {
      52                 :             :   std::vector<const char*>path;
      53                 :             :   const char *name;
      54                 :             : } named_path;
      55                 :             : 
      56                 :             : 
      57                 :             : /* The language include paths are based on the libraries in use.  */
      58                 :             : static bool allow_libraries = true;
      59                 :             : static const char *flibs = nullptr;
      60                 :             : static const char *iprefix = nullptr;
      61                 :             : static const char *imultilib = nullptr;
      62                 :             : static std::vector<named_path>Ipaths;
      63                 :             : static std::vector<const char*>isystem;
      64                 :             : static std::vector<const char*>iquote;
      65                 :             : 
      66                 :             : #define EXPR_STMT_EXPR(NODE) TREE_OPERAND (EXPR_STMT_CHECK (NODE), 0)
      67                 :             : 
      68                 :             : /* start of new stuff.  */
      69                 :             : 
      70                 :             : /* Language-dependent contents of a type.  */
      71                 :             : 
      72                 :             : struct GTY (()) lang_type
      73                 :             : {
      74                 :             :   char dummy;
      75                 :             : };
      76                 :             : 
      77                 :             : /* Language-dependent contents of a decl.  */
      78                 :             : 
      79                 :             : struct GTY (()) lang_decl
      80                 :             : {
      81                 :             :   char dummy;
      82                 :             : };
      83                 :             : 
      84                 :             : /* Language-dependent contents of an identifier.  This must include a
      85                 :             :    tree_identifier.  */
      86                 :             : 
      87                 :             : struct GTY (()) lang_identifier
      88                 :             : {
      89                 :             :   struct tree_identifier common;
      90                 :             : };
      91                 :             : 
      92                 :             : /* The resulting tree type.  */
      93                 :             : 
      94                 :             : union GTY ((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
      95                 :             :             chain_next ("CODE_CONTAINS_STRUCT (TREE_CODE (&%h.generic), "
      96                 :             :                         "TS_COMMON) ? ((union lang_tree_node *) TREE_CHAIN "
      97                 :             :                         "(&%h.generic)) : NULL"))) lang_tree_node
      98                 :             : {
      99                 :             :   union tree_node GTY ((tag ("0"),
     100                 :             :                         desc ("tree_node_structure (&%h)"))) generic;
     101                 :             :   struct lang_identifier GTY ((tag ("1"))) identifier;
     102                 :             : };
     103                 :             : 
     104                 :             : struct GTY (()) language_function
     105                 :             : {
     106                 :             : 
     107                 :             :   /* While we are parsing the function, this contains information about
     108                 :             :   the statement-tree that we are building.  */
     109                 :             :   /* struct stmt_tree_s stmt_tree;  */
     110                 :             :   tree stmt_tree;
     111                 :             : };
     112                 :             : 
     113                 :             : /* Language hooks.  */
     114                 :             : 
     115                 :             : static void gm2_langhook_parse_file (void);
     116                 :             : 
     117                 :             : bool
     118                 :       14232 : gm2_langhook_init (void)
     119                 :             : {
     120                 :       14232 :   build_common_tree_nodes (false);
     121                 :       14232 :   build_common_builtin_nodes ();
     122                 :             : 
     123                 :             :   /* The default precision for floating point numbers.  This is used
     124                 :             :      for floating point constants with abstract type.  This may eventually
     125                 :             :      be controllable by a command line option.  */
     126                 :       14232 :   mpfr_set_default_prec (256);
     127                 :             : 
     128                 :             :   /* GNU Modula-2 uses exceptions.  */
     129                 :       14232 :   using_eh_for_cleanups ();
     130                 :             : 
     131                 :       14232 :   if (M2Options_GetPPOnly ())
     132                 :             :     {
     133                 :             :       /* Preprocess the file here.  */
     134                 :           0 :       gm2_langhook_parse_file ();
     135                 :           0 :       return false; /* Finish now, no further compilation.  */
     136                 :             :     }
     137                 :             :   return true;
     138                 :             : }
     139                 :             : 
     140                 :             : /* The option mask.  */
     141                 :             : 
     142                 :             : static unsigned int
     143                 :       31421 : gm2_langhook_option_lang_mask (void)
     144                 :             : {
     145                 :       31421 :   return CL_ModulaX2;
     146                 :             : }
     147                 :             : 
     148                 :             : /* Initialize the options structure.  */
     149                 :             : 
     150                 :             : static void
     151                 :       14232 : gm2_langhook_init_options_struct (struct gcc_options *opts)
     152                 :             : {
     153                 :             :   /* Default to avoiding range issues for complex multiply and divide.  */
     154                 :       14232 :   opts->x_flag_complex_method = 2;
     155                 :             : 
     156                 :             :   /* The builtin math functions should not set errno.  */
     157                 :       14232 :   opts->x_flag_errno_math = 0;
     158                 :       14232 :   opts->frontend_set_flag_errno_math = true;
     159                 :             : 
     160                 :             :   /* Exceptions are used.  */
     161                 :       14232 :   opts->x_flag_exceptions = 1;
     162                 :       14232 :   init_FrontEndInit ();
     163                 :       14232 : }
     164                 :             : 
     165                 :             : /* Infrastructure for a VEC of bool values.  */
     166                 :             : 
     167                 :             : /* This array determines whether the filename is associated with the
     168                 :             :    C preprocessor.  */
     169                 :             : 
     170                 :             : static vec<bool> filename_cpp;
     171                 :             : 
     172                 :             : /* Build the C preprocessor command line here, since we need to include
     173                 :             :    options that are not passed to the handle_option function.  */
     174                 :             : 
     175                 :             : void
     176                 :       14232 : gm2_langhook_init_options (unsigned int decoded_options_count,
     177                 :             :                            struct cl_decoded_option *decoded_options)
     178                 :             : {
     179                 :       14232 :   unsigned int i;
     180                 :       14232 :   bool in_cpp_args = false;
     181                 :       14232 :   bool building_cpp_command = false;
     182                 :             : 
     183                 :      709118 :   for (i = 1; i < decoded_options_count; i++)
     184                 :             :     {
     185                 :      694886 :       enum opt_code code = (enum opt_code)decoded_options[i].opt_index;
     186                 :      694886 :       const struct cl_option *option = &cl_options[code];
     187                 :      694886 :       const char *opt = (const char *)option->opt_text;
     188                 :      694886 :       const char *arg = decoded_options[i].arg;
     189                 :      694886 :       HOST_WIDE_INT value = decoded_options[i].value;
     190                 :      694886 :       switch (code)
     191                 :             :         {
     192                 :         510 :         case OPT_fcpp:
     193                 :         510 :           if (value)
     194                 :         510 :             gcc_checking_assert (building_cpp_command);
     195                 :             :           break;
     196                 :         510 :         case OPT_fcpp_begin:
     197                 :         510 :           in_cpp_args = true;
     198                 :         510 :           building_cpp_command = true;
     199                 :         510 :           break;
     200                 :         510 :         case OPT_fcpp_end:
     201                 :         510 :           in_cpp_args = false;
     202                 :         510 :           break;
     203                 :       14742 :         case OPT_SPECIAL_input_file:
     204                 :       14742 :           filename_cpp.safe_push (in_cpp_args);
     205                 :       14742 :           break;
     206                 :             : 
     207                 :             :         /* C and driver opts that are not passed to the preprocessor for
     208                 :             :            modula-2, but that we use internally for building preprocesor
     209                 :             :            command lines.  */
     210                 :       14232 :         case OPT_B:
     211                 :       14232 :           M2Options_SetB (arg);
     212                 :       14232 :           break;
     213                 :       11694 :         case OPT_c:
     214                 :       11694 :           M2Options_Setc (value);
     215                 :       11694 :           break;
     216                 :       12092 :         case OPT_dumpdir:
     217                 :       12092 :           M2Options_SetDumpDir (arg);
     218                 :       12092 :           break;
     219                 :           0 :         case OPT_save_temps:
     220                 :           0 :           if (building_cpp_command)
     221                 :           0 :             M2Options_SetSaveTemps (value);
     222                 :             :           break;
     223                 :           0 :         case OPT_save_temps_:
     224                 :           0 :           if (building_cpp_command)
     225                 :             :             /* Also sets SaveTemps. */
     226                 :           0 :             M2Options_SetSaveTempsDir (arg);
     227                 :             :           break;
     228                 :             : 
     229                 :         510 :         case OPT_E:
     230                 :         510 :           if (!in_cpp_args)
     231                 :             :             {
     232                 :           0 :               M2Options_SetPPOnly (value);
     233                 :           0 :               building_cpp_command = true;
     234                 :             :             }
     235                 :         510 :           M2Options_CppArg (opt, arg, (option->flags & CL_JOINED)
     236                 :         510 :                             && !(option->flags & CL_SEPARATE));
     237                 :         510 :           break;
     238                 :             : 
     239                 :           0 :         case OPT_M:
     240                 :             :           /* Output a rule suitable for make describing the dependencies of the
     241                 :             :              main source file.  */
     242                 :           0 :           if (in_cpp_args)
     243                 :             :             {
     244                 :           0 :               gcc_checking_assert (building_cpp_command);
     245                 :             :               /* This is a preprocessor command.  */
     246                 :           0 :               M2Options_CppArg (opt, arg, (option->flags & CL_JOINED)
     247                 :           0 :                                 && !(option->flags & CL_SEPARATE));
     248                 :             :             }
     249                 :           0 :           M2Options_SetPPOnly (value);
     250                 :           0 :           M2Options_SetM (value);
     251                 :           0 :           break;
     252                 :             : 
     253                 :           0 :         case OPT_MM:
     254                 :           0 :           if (in_cpp_args)
     255                 :             :             {
     256                 :           0 :               gcc_checking_assert (building_cpp_command);
     257                 :             :               /* This is a preprocessor command.  */
     258                 :           0 :               M2Options_CppArg (opt, arg, (option->flags & CL_JOINED)
     259                 :           0 :                                 && !(option->flags & CL_SEPARATE));
     260                 :             :             }
     261                 :           0 :           M2Options_SetPPOnly (value);
     262                 :           0 :           M2Options_SetMM (value);
     263                 :           0 :           break;
     264                 :             : 
     265                 :           0 :         case OPT_MF:
     266                 :           0 :           if (!in_cpp_args)
     267                 :           0 :             M2Options_SetMF (arg);
     268                 :             :           break;
     269                 :             : 
     270                 :           0 :         case OPT_MP:
     271                 :           0 :           M2Options_SetMP (value);
     272                 :           0 :           break;
     273                 :             : 
     274                 :             :         /* We can only use MQ and MT when the command line is either PP-only, or
     275                 :             :            when there is a MD/MMD on it.  */
     276                 :           0 :         case OPT_MQ:
     277                 :           0 :           M2Options_SetMQ (arg);
     278                 :           0 :           break;
     279                 :             : 
     280                 :           0 :         case OPT_MT:
     281                 :           0 :           M2Options_SetMT (arg);
     282                 :           0 :           break;
     283                 :             : 
     284                 :       14232 :         case OPT_o:
     285                 :       14232 :           M2Options_SetObj (arg);
     286                 :       14232 :           break;
     287                 :             : 
     288                 :             :         /* C and driver options that we ignore for the preprocessor lines.  */
     289                 :             :         case OPT_fpch_deps:
     290                 :             :         case OPT_fpch_preprocess:
     291                 :             :           break;
     292                 :             : 
     293                 :             :         case OPT_fplugin_:
     294                 :             :           /* FIXME: We might need to handle this specially, since the modula-2
     295                 :             :              plugin is not usable here, but others might be.
     296                 :             :              For now skip all plugins to avoid fails with the m2 one.  */
     297                 :             :           break;
     298                 :             : 
     299                 :             :         /* Preprocessor arguments with a following filename.  */
     300                 :           0 :         case OPT_MD:
     301                 :           0 :           M2Options_SetMD (value);
     302                 :           0 :           if (value)
     303                 :             :             {
     304                 :           0 :               M2Options_SetM (true);
     305                 :           0 :               M2Options_SetMF (arg);
     306                 :             :             }
     307                 :             :           break;
     308                 :             : 
     309                 :           0 :         case OPT_MMD:
     310                 :           0 :           M2Options_SetMMD (value);
     311                 :           0 :           if (value)
     312                 :             :             {
     313                 :           0 :               M2Options_SetMM (true);
     314                 :           0 :               M2Options_SetMF (arg);
     315                 :             :             }
     316                 :             :           break;
     317                 :             : 
     318                 :             :         /* Modula 2 claimed options we pass to the preprocessor.  */
     319                 :        1020 :         case OPT_ansi:
     320                 :        1020 :         case OPT_traditional_cpp:
     321                 :        1020 :           if (building_cpp_command)
     322                 :        1020 :             M2Options_CppArg (opt, arg, (option->flags & CL_JOINED)
     323                 :        1020 :                               && !(option->flags & CL_SEPARATE));
     324                 :             :           break;
     325                 :             : 
     326                 :             :         /* Options we act on and also pass to the preprocessor.  */
     327                 :        7426 :         case OPT_O:
     328                 :        7426 :           M2Options_SetOptimizing (value);
     329                 :        7426 :           if (building_cpp_command)
     330                 :         340 :             M2Options_CppArg (opt, arg, (option->flags & CL_JOINED)
     331                 :         340 :                               && !(option->flags & CL_SEPARATE));
     332                 :             :           break;
     333                 :       14742 :         case OPT_quiet:
     334                 :       14742 :           M2Options_SetQuiet (value);
     335                 :       14742 :           if (building_cpp_command)
     336                 :        1020 :             M2Options_CppArg (opt, arg, (option->flags & CL_JOINED)
     337                 :        1020 :                               && !(option->flags & CL_SEPARATE));
     338                 :             :           break;
     339                 :           0 :         case OPT_v:
     340                 :           0 :           M2Options_SetVerbose (value);
     341                 :             :           /* FALLTHROUGH */
     342                 :      602560 :         default:
     343                 :             :           /* We handled input files above.  */
     344                 :      602560 :           if (code >= N_OPTS)
     345                 :             :             break;
     346                 :             :           /* Do not pass Modula-2 args to the preprocessor, any that we care
     347                 :             :              about here should already have been handled above.  */
     348                 :      602560 :           if (option->flags & CL_ModulaX2)
     349                 :             :             break;
     350                 :             :           /* Otherwise, add this to the CPP command line.  */
     351                 :      164216 :           if (building_cpp_command)
     352                 :        5100 :             M2Options_CppArg (opt, arg, (option->flags & CL_JOINED)
     353                 :        5100 :                               && !(option->flags & CL_SEPARATE));
     354                 :             :           break;
     355                 :             :         }
     356                 :             :     }
     357                 :       14232 :   filename_cpp.safe_push (false);
     358                 :       14232 : }
     359                 :             : 
     360                 :             : static bool
     361                 :       14742 : is_cpp_filename (unsigned int i)
     362                 :             : {
     363                 :       14742 :   gcc_assert (i < filename_cpp.length ());
     364                 :       14742 :   return filename_cpp[i];
     365                 :             : }
     366                 :             : 
     367                 :             : static void
     368                 :      202082 : push_back_Ipath (const char *arg)
     369                 :             : {
     370                 :      202082 :   if (Ipaths.empty ())
     371                 :             :     {
     372                 :       14232 :       named_path np;
     373                 :       14232 :       np.path.push_back (arg);
     374                 :       14232 :       np.name = xstrdup (M2Options_GetM2PathName ());
     375                 :       14232 :       Ipaths.push_back (np);
     376                 :       14232 :     }
     377                 :             :   else
     378                 :             :     {
     379                 :      187850 :       if (strcmp (Ipaths.back ().name,
     380                 :      187850 :                   M2Options_GetM2PathName ()) == 0)
     381                 :       62778 :         Ipaths.back ().path.push_back (arg);
     382                 :             :       else
     383                 :             :         {
     384                 :      125072 :           named_path np;
     385                 :      125072 :           np.path.push_back (arg);
     386                 :      125072 :           np.name = xstrdup (M2Options_GetM2PathName ());
     387                 :      125072 :           Ipaths.push_back (np);
     388                 :      125072 :         }
     389                 :             :     }
     390                 :      202082 : }
     391                 :             : 
     392                 :             : /* Handle gm2 specific options.  Return 0 if we didn't do anything.  */
     393                 :             : 
     394                 :             : bool
     395                 :      467349 : gm2_langhook_handle_option (
     396                 :             :     size_t scode, const char *arg, HOST_WIDE_INT value, int kind ATTRIBUTE_UNUSED,
     397                 :             :     location_t loc ATTRIBUTE_UNUSED,
     398                 :             :     const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
     399                 :             : {
     400                 :      467349 :   enum opt_code code = (enum opt_code)scode;
     401                 :             : 
     402                 :      467349 :   const struct cl_option *option = &cl_options[scode];
     403                 :             :   /* ignore file names.  */
     404                 :      467349 :   if (code == N_OPTS)
     405                 :             :     return 1;
     406                 :             : 
     407                 :      467349 :   switch (code)
     408                 :             :     {
     409                 :           0 :     case OPT_dumpdir:
     410                 :           0 :       M2Options_SetDumpDir (arg);
     411                 :           0 :       return 1;
     412                 :           0 :     case OPT_I:
     413                 :           0 :       push_back_Ipath (arg);
     414                 :           0 :       return 1;
     415                 :        3965 :     case OPT_fiso:
     416                 :        3965 :       M2Options_SetISO (value);
     417                 :        3965 :       iso = value;
     418                 :        3965 :       return 1;
     419                 :        9815 :     case OPT_fpim:
     420                 :        9815 :       M2Options_SetPIM (value);
     421                 :        9815 :       iso = value ? false : iso;
     422                 :        9815 :       return 1;
     423                 :          86 :     case OPT_fpim2:
     424                 :          86 :       M2Options_SetPIM2 (value);
     425                 :          86 :       iso = value ? false : iso;
     426                 :          86 :       return 1;
     427                 :          12 :     case OPT_fpim3:
     428                 :          12 :       M2Options_SetPIM3 (value);
     429                 :          12 :       iso = value ? false : iso;
     430                 :          12 :       return 1;
     431                 :          66 :     case OPT_fpim4:
     432                 :          66 :       M2Options_SetPIM4 (value);
     433                 :          66 :       iso = value ? false : iso;
     434                 :          66 :       return 1;
     435                 :           0 :     case OPT_fpositive_mod_floor_div:
     436                 :           0 :       M2Options_SetPositiveModFloor (value);
     437                 :           0 :       return 1;
     438                 :       14232 :     case OPT_flibs_:
     439                 :       14232 :       allow_libraries = value;
     440                 :       14232 :       flibs = arg;
     441                 :       14232 :       return 1;
     442                 :        2528 :     case OPT_fgen_module_list_:
     443                 :        2528 :       M2Options_SetGenModuleList (value, arg);
     444                 :        2528 :       return 1;
     445                 :           0 :     case OPT_fnil:
     446                 :           0 :       M2Options_SetNilCheck (value);
     447                 :           0 :       return 1;
     448                 :           0 :     case OPT_fwholediv:
     449                 :           0 :       M2Options_SetWholeDiv (value);
     450                 :           0 :       return 1;
     451                 :           0 :     case OPT_findex:
     452                 :           0 :       M2Options_SetIndex (value);
     453                 :           0 :       return 1;
     454                 :           6 :     case OPT_frange:
     455                 :           6 :       M2Options_SetRange (value);
     456                 :           6 :       return 1;
     457                 :           0 :     case OPT_ffloatvalue:
     458                 :           0 :       M2Options_SetFloatValueCheck (value);
     459                 :           0 :       return 1;
     460                 :           0 :     case OPT_fwholevalue:
     461                 :           0 :       M2Options_SetWholeValueCheck (value);
     462                 :           0 :       return 1;
     463                 :           0 :     case OPT_freturn:
     464                 :           0 :       M2Options_SetReturnCheck (value);
     465                 :           0 :       return 1;
     466                 :         580 :     case OPT_fcase:
     467                 :         580 :       M2Options_SetCaseCheck (value);
     468                 :         580 :       return 1;
     469                 :           0 :     case OPT_fd:
     470                 :           0 :       M2Options_SetCompilerDebugging (value);
     471                 :           0 :       return 1;
     472                 :           0 :     case OPT_fdebug_builtins:
     473                 :           0 :       M2Options_SetDebugBuiltins (value);
     474                 :           0 :       return 1;
     475                 :           0 :     case OPT_fdebug_function_line_numbers:
     476                 :           0 :       M2Options_SetDebugFunctionLineNumbers (value);
     477                 :           0 :       return 1;
     478                 :          12 :     case OPT_fauto_init:
     479                 :          12 :       M2Options_SetAutoInit (value);
     480                 :          12 :       return 1;
     481                 :        1783 :     case OPT_fsoft_check_all:
     482                 :        1783 :       M2Options_SetCheckAll (value);
     483                 :        1783 :       return 1;
     484                 :          18 :     case OPT_fexceptions:
     485                 :          18 :       M2Options_SetExceptions (value);
     486                 :          18 :       return 1;
     487                 :           0 :     case OPT_Wstyle:
     488                 :           0 :       M2Options_SetStyle (value);
     489                 :           0 :       return 1;
     490                 :         354 :     case OPT_Wpedantic:
     491                 :         354 :       M2Options_SetPedantic (value);
     492                 :         354 :       return 1;
     493                 :           6 :     case OPT_Wpedantic_param_names:
     494                 :           6 :       M2Options_SetPedanticParamNames (value);
     495                 :           6 :       return 1;
     496                 :           0 :     case OPT_Wpedantic_cast:
     497                 :           0 :       M2Options_SetPedanticCast (value);
     498                 :           0 :       return 1;
     499                 :         324 :     case OPT_fextended_opaque:
     500                 :         324 :       M2Options_SetExtendedOpaque (value);
     501                 :         324 :       return 1;
     502                 :           0 :     case OPT_Wverbose_unbounded:
     503                 :           0 :       M2Options_SetVerboseUnbounded (value);
     504                 :           0 :       return 1;
     505                 :         342 :     case OPT_Wunused_variable:
     506                 :         342 :       M2Options_SetUnusedVariableChecking (value);
     507                 :         342 :       return 1;
     508                 :           0 :     case OPT_Wunused_parameter:
     509                 :           0 :       M2Options_SetUnusedParameterChecking (value);
     510                 :           0 :       return 1;
     511                 :         198 :     case OPT_Wuninit_variable_checking:
     512                 :         198 :       return M2Options_SetUninitVariableChecking (value, "known");
     513                 :         415 :     case OPT_Wuninit_variable_checking_:
     514                 :         415 :       return M2Options_SetUninitVariableChecking (value, arg);
     515                 :           0 :     case OPT_fm2_strict_type:
     516                 :           0 :       M2Options_SetStrictTypeChecking (value);
     517                 :           0 :       return 1;
     518                 :           0 :     case OPT_fm2_debug_trace_:
     519                 :           0 :       M2Options_SetM2DebugTraceFilter (value, arg);
     520                 :           0 :       return 1;
     521                 :           0 :     case OPT_fm2_dump_:
     522                 :           0 :       return M2Options_SetM2Dump (value, arg);
     523                 :           0 :     case OPT_fm2_dump_decl_:
     524                 :           0 :       M2Options_SetDumpDeclFilename (value, arg);
     525                 :           0 :       return 1;
     526                 :           0 :     case OPT_fm2_dump_gimple_:
     527                 :           0 :       M2Options_SetDumpGimpleFilename (value, arg);
     528                 :           0 :       return 1;
     529                 :           0 :     case OPT_fm2_dump_quad_:
     530                 :           0 :       M2Options_SetDumpQuadFilename (value, arg);
     531                 :           0 :       return 1;
     532                 :           0 :     case OPT_fm2_dump_filter_:
     533                 :           0 :       M2Options_SetM2DumpFilter (value, arg);
     534                 :           0 :       return 1;
     535                 :           0 :     case OPT_Wall:
     536                 :           0 :       M2Options_SetWall (value);
     537                 :           0 :       return 1;
     538                 :         664 :     case OPT_Wcase_enum:
     539                 :         664 :       M2Options_SetCaseEnumChecking (value);
     540                 :         664 :       return 1;
     541                 :             : #if 0
     542                 :             :     /* Not yet implemented.  */
     543                 :             :     case OPT_fxcode:
     544                 :             :       M2Options_SetXCode (value);
     545                 :             :       return 1;
     546                 :             : #endif
     547                 :           0 :     case OPT_fm2_lower_case:
     548                 :           0 :       M2Options_SetLowerCaseKeywords (value);
     549                 :           0 :       return 1;
     550                 :           0 :     case OPT_fuse_list_:
     551                 :           0 :       M2Options_SetUselist (value, arg);
     552                 :           0 :       return 1;
     553                 :           0 :     case OPT_fruntime_modules_:
     554                 :           0 :       M2Options_SetRuntimeModuleOverride (arg);
     555                 :           0 :       return 1;
     556                 :             :     case OPT_fpthread:
     557                 :             :       /* Handled in the driver.  */
     558                 :             :       return 1;
     559                 :             :     case OPT_fm2_plugin:
     560                 :             :       /* Handled in the driver.  */
     561                 :             :       return 1;
     562                 :       14232 :     case OPT_fscaffold_dynamic:
     563                 :       14232 :       M2Options_SetScaffoldDynamic (value);
     564                 :       14232 :       return 1;
     565                 :          22 :     case OPT_fscaffold_static:
     566                 :          22 :       M2Options_SetScaffoldStatic (value);
     567                 :          22 :       return 1;
     568                 :        2558 :     case OPT_fscaffold_main:
     569                 :        2558 :       M2Options_SetScaffoldMain (value);
     570                 :        2558 :       return 1;
     571                 :         510 :     case OPT_fcpp:
     572                 :         510 :       M2Options_SetCpp (value);
     573                 :         510 :       return 1;
     574                 :             :     case OPT_fpreprocessed:
     575                 :             :       /* Provided for compatibility; ignore for now.  */
     576                 :             :       return 1;
     577                 :         510 :     case OPT_fcpp_begin:
     578                 :         510 :       insideCppArgs = TRUE;
     579                 :         510 :       return 1;
     580                 :         510 :     case OPT_fcpp_end:
     581                 :         510 :       insideCppArgs = FALSE;
     582                 :         510 :       return 1;
     583                 :           0 :     case OPT_fq:
     584                 :           0 :       M2Options_SetQuadDebugging (value);
     585                 :           0 :       return 1;
     586                 :           0 :     case OPT_fsources:
     587                 :           0 :       M2Options_SetSources (value);
     588                 :           0 :       return 1;
     589                 :           0 :     case OPT_funbounded_by_reference:
     590                 :           0 :       M2Options_SetUnboundedByReference (value);
     591                 :           0 :       return 1;
     592                 :           6 :     case OPT_fdef_:
     593                 :           6 :       M2Options_setdefextension (arg);
     594                 :           6 :       return 1;
     595                 :           6 :     case OPT_fmod_:
     596                 :           6 :       M2Options_setmodextension (arg);
     597                 :           6 :       return 1;
     598                 :          22 :     case OPT_fdump_system_exports:
     599                 :          22 :       M2Options_SetDumpSystemExports (value);
     600                 :          22 :       return 1;
     601                 :           0 :     case OPT_fswig:
     602                 :           0 :       M2Options_SetSwig (value);
     603                 :           0 :       return 1;
     604                 :           0 :     case OPT_fshared:
     605                 :           0 :       M2Options_SetShared (value);
     606                 :           0 :       return 1;
     607                 :           0 :     case OPT_fm2_statistics:
     608                 :           0 :       M2Options_SetStatistics (value);
     609                 :           0 :       return 1;
     610                 :         484 :     case OPT_fm2_g:
     611                 :         484 :       M2Options_SetM2g (value);
     612                 :         484 :       return 1;
     613                 :      139332 :       break;
     614                 :      139332 :     case OPT_fm2_pathname_:
     615                 :      139332 :       if (strcmp (arg, "-") == 0)
     616                 :       26314 :         M2Options_SetM2PathName ("");
     617                 :             :       else
     618                 :      113018 :         M2Options_SetM2PathName (arg);
     619                 :             :       return 1;
     620                 :      202082 :       break;
     621                 :      202082 :     case OPT_fm2_pathnameI:
     622                 :      202082 :       push_back_Ipath (arg);
     623                 :      202082 :       return 1;
     624                 :         588 :       break;
     625                 :         588 :     case OPT_fm2_prefix_:
     626                 :         588 :       if (strcmp (arg, "-") == 0)
     627                 :           0 :         M2Options_SetM2Prefix ("");
     628                 :             :       else
     629                 :         588 :         M2Options_SetM2Prefix (arg);
     630                 :             :       return 1;
     631                 :       14232 :       break;
     632                 :       14232 :     case OPT_iprefix:
     633                 :       14232 :       iprefix = arg;
     634                 :       14232 :       return 1;
     635                 :         294 :       break;
     636                 :         294 :     case OPT_imultilib:
     637                 :         294 :       imultilib = arg;
     638                 :         294 :       return 1;
     639                 :       28464 :       break;
     640                 :       28464 :     case OPT_isystem:
     641                 :       28464 :       isystem.push_back (arg);
     642                 :       28464 :       return 1;
     643                 :           0 :       break;
     644                 :           0 :     case OPT_iquote:
     645                 :           0 :       iquote.push_back (arg);
     646                 :           0 :       return 1;
     647                 :             :       break;
     648                 :             :     case OPT_isysroot:
     649                 :             :       /* Otherwise, ignored, at least for now. */
     650                 :             :       return 1;
     651                 :          24 :       break;
     652                 :          24 :     case OPT_fm2_whole_program:
     653                 :          24 :       M2Options_SetWholeProgram (value);
     654                 :          24 :       return 1;
     655                 :             : #ifdef OPT_mabi_ibmlongdouble
     656                 :             :     case OPT_mabi_ibmlongdouble:
     657                 :             :       M2Options_SetIBMLongDouble (value);
     658                 :             :       return 1;
     659                 :             : #endif
     660                 :             : #ifdef OPT_mabi_ieeelongdouble
     661                 :             :     case OPT_mabi_ieeelongdouble:
     662                 :             :       M2Options_SetIEEELongDouble (value);
     663                 :             :       return 1;
     664                 :             : #endif
     665                 :           0 :     case OPT_flocation_:
     666                 :           0 :       if (strcmp (arg, "builtins") == 0)
     667                 :             :         {
     668                 :           0 :           M2Options_SetForcedLocation (BUILTINS_LOCATION);
     669                 :           0 :           return 1;
     670                 :             :         }
     671                 :           0 :       else if (strcmp (arg, "unknown") == 0)
     672                 :             :         {
     673                 :           0 :           M2Options_SetForcedLocation (UNKNOWN_LOCATION);
     674                 :           0 :           return 1;
     675                 :             :         }
     676                 :           0 :       else if ((arg != NULL) && (ISDIGIT (arg[0])))
     677                 :             :         {
     678                 :           0 :           M2Options_SetForcedLocation (atoi (arg));
     679                 :           0 :           return 1;
     680                 :             :         }
     681                 :             :       else
     682                 :             :         return 0;
     683                 :       28067 :     default:
     684                 :       28067 :       if (insideCppArgs)
     685                 :             :         /* Handled in gm2_langhook_init_options ().  */
     686                 :             :         return 1;
     687                 :       26525 :       else if (option->flags & CL_DRIVER)
     688                 :             :         /* Driver options (unless specifically claimed above) should be handled
     689                 :             :            in gm2_langhook_init_options ().  */
     690                 :             :         return 1;
     691                 :         599 :       else if (option->flags & CL_C)
     692                 :             :         /* C options (unless specifically claimed above) should be handled
     693                 :             :            in gm2_langhook_init_options ().  */
     694                 :             :         return 1;
     695                 :             :       break;
     696                 :             :     }
     697                 :             :   return 0;
     698                 :           0 : }
     699                 :             : 
     700                 :             : /* This prefixes LIBNAME with the current compiler prefix (if it has been
     701                 :             :    relocated) or the LIBSUBDIR, if not.  */
     702                 :             : static void
     703                 :        2440 : add_one_import_path (const char *libname)
     704                 :             : {
     705                 :        2440 :   const char *libpath = iprefix ? iprefix : LIBSUBDIR;
     706                 :        2440 :   const char dir_sep[] = {DIR_SEPARATOR, (char)0};
     707                 :        2440 :   size_t dir_sep_size = strlen (dir_sep);
     708                 :        2440 :   unsigned int mlib_len = 0;
     709                 :             : 
     710                 :        2440 :   if (imultilib)
     711                 :             :     {
     712                 :        1176 :       mlib_len = strlen (imultilib);
     713                 :        1176 :       mlib_len += strlen (dir_sep);
     714                 :             :     }
     715                 :             : 
     716                 :        2440 :   char *lib = (char *)alloca (strlen (libpath) + dir_sep_size
     717                 :             :                               + strlen ("m2") + dir_sep_size
     718                 :             :                               + strlen (libname) + 1
     719                 :             :                               + mlib_len + 1);
     720                 :        2440 :   strcpy (lib, libpath);
     721                 :             :   /* iprefix has a trailing dir separator, LIBSUBDIR does not.  */
     722                 :        2440 :   if (!iprefix)
     723                 :           0 :     strcat (lib, dir_sep);
     724                 :             : 
     725                 :        2440 :   if (imultilib)
     726                 :             :     {
     727                 :        1176 :       strcat (lib, imultilib);
     728                 :        1176 :       strcat (lib, dir_sep);
     729                 :             :     }
     730                 :        2440 :   strcat (lib, "m2");
     731                 :        2440 :   strcat (lib, dir_sep);
     732                 :        2440 :   strcat (lib, libname);
     733                 :        2440 :   M2Options_SetM2PathName (libname);
     734                 :        2440 :   M2Options_SetSearchPath (lib);
     735                 :        2440 : }
     736                 :             : 
     737                 :             : /* For each comma-separated standard library name in LIBLIST, add the
     738                 :             :    corresponding include path.  */
     739                 :             : static void
     740                 :         610 : add_m2_import_paths (const char *liblist)
     741                 :             : {
     742                 :        3050 :   while (*liblist != 0 && *liblist != '-')
     743                 :             :     {
     744                 :        2440 :       const char *comma = strstr (liblist, ",");
     745                 :        2440 :       size_t len;
     746                 :        2440 :       if (comma)
     747                 :        1830 :         len = comma - liblist;
     748                 :             :       else
     749                 :         610 :         len = strlen (liblist);
     750                 :        2440 :       char *libname = (char *) alloca (len+1);
     751                 :        2440 :       strncpy (libname, liblist, len);
     752                 :        2440 :       libname[len] = 0;
     753                 :        2440 :       add_one_import_path (libname);
     754                 :        2440 :       liblist += len;
     755                 :        2440 :       if (*liblist == ',')
     756                 :        1830 :         liblist++;
     757                 :             :     }
     758                 :         610 : }
     759                 :             : 
     760                 :             : /* Run after parsing options.  */
     761                 :             : 
     762                 :             : static bool
     763                 :       14232 : gm2_langhook_post_options (const char **pfilename)
     764                 :             : {
     765                 :       14232 :   const char *filename = *pfilename;
     766                 :       14232 :   flag_excess_precision = EXCESS_PRECISION_FAST;
     767                 :       14232 :   M2Options_SetCC1Quiet (quiet_flag);
     768                 :       14232 :   M2Options_FinaliseOptions ();
     769                 :       14232 :   main_input_filename = filename;
     770                 :             : 
     771                 :             :   /* Add the include paths as per the libraries specified.
     772                 :             :      NOTE: This assumes that the driver has validated the input and makes
     773                 :             :      no attempt to be defensive of nonsense input in flibs=.  */
     774                 :       14232 :   if (allow_libraries)
     775                 :             :     {
     776                 :         610 :       if (!flibs)
     777                 :             :         {
     778                 :           0 :           if (iso)
     779                 :           0 :             flibs = "m2iso,m2cor,m2pim,m2log";
     780                 :             :           else
     781                 :           0 :             flibs = "m2pim,m2iso,m2cor,m2log";
     782                 :             :         }
     783                 :             :     }
     784                 :             : 
     785                 :             :   /* Add search paths.
     786                 :             :      We are not handling all of the cases yet (e.g idirafter).
     787                 :             :      This (barring the missing cases) is intended to follow the directory
     788                 :             :      search rules used for c-family.  It would be less confusing if the
     789                 :             :      presence of absence of these search paths was not dependent on the
     790                 :             :      flibs= option. */
     791                 :             : 
     792                 :       14232 :   for (auto *s : iquote)
     793                 :           0 :     M2Options_SetSearchPath (s);
     794                 :       14232 :   iquote.clear();
     795                 :      153536 :   for (auto np : Ipaths)
     796                 :             :     {
     797                 :      139304 :       M2Options_SetM2PathName (np.name);
     798                 :      341386 :       for (auto *s : np.path)
     799                 :      202082 :         M2Options_SetSearchPath (s);
     800                 :      139304 :     }
     801                 :       14232 :   Ipaths.clear();
     802                 :       42696 :   for (auto *s : isystem)
     803                 :       28464 :     M2Options_SetSearchPath (s);
     804                 :       14232 :   isystem.clear();
     805                 :             :   /* FIXME: this is not a good way to suppress the addition of the import
     806                 :             :      paths.  */
     807                 :       14232 :   if (allow_libraries)
     808                 :         610 :     add_m2_import_paths (flibs);
     809                 :             : 
     810                 :             :   /* Returning false means that the backend should be used.  */
     811                 :       14232 :   return M2Options_GetPPOnly ();
     812                 :             : }
     813                 :             : 
     814                 :             : /* Call the compiler for every source filename on the command line.  */
     815                 :             : 
     816                 :             : static void
     817                 :       14232 : gm2_parse_input_files (const char **filenames, unsigned int filename_count)
     818                 :             : {
     819                 :       14232 :   unsigned int i;
     820                 :       14232 :   gcc_assert (filename_count > 0);
     821                 :             : 
     822                 :       27649 :   for (i = 0; i < filename_count; i++)
     823                 :       14742 :     if (!is_cpp_filename (i))
     824                 :             :       {
     825                 :       14232 :         main_input_filename = filenames[i];
     826                 :       14232 :         init_PerCompilationInit (filenames[i]);
     827                 :             :       }
     828                 :       12907 : }
     829                 :             : 
     830                 :             : static void
     831                 :       14232 : gm2_langhook_parse_file (void)
     832                 :             : {
     833                 :       14232 :   gm2_parse_input_files (in_fnames, num_in_fnames);
     834                 :       12907 :   if (!M2Options_GetPPOnly ())
     835                 :       12907 :     write_globals ();
     836                 :       12907 : }
     837                 :             : 
     838                 :             : static tree
     839                 :      213232 : gm2_langhook_type_for_size (unsigned int bits, int unsignedp)
     840                 :             : {
     841                 :      119541 :   return gm2_type_for_size (bits, unsignedp);
     842                 :             : }
     843                 :             : 
     844                 :             : static tree
     845                 :      223085 : gm2_langhook_type_for_mode (machine_mode mode, int unsignedp)
     846                 :             : {
     847                 :      223085 :   tree type;
     848                 :             : 
     849                 :      669205 :   for (int i = 0; i < NUM_INT_N_ENTS; i ++)
     850                 :      223085 :     if (int_n_enabled_p[i]
     851                 :      223085 :         && mode == int_n_data[i].m)
     852                 :          50 :       return (unsignedp ? int_n_trees[i].unsigned_type
     853                 :          50 :               : int_n_trees[i].signed_type);
     854                 :             : 
     855                 :      223035 :   if (VECTOR_MODE_P (mode))
     856                 :             :     {
     857                 :          12 :       tree inner;
     858                 :             : 
     859                 :          24 :       inner = gm2_langhook_type_for_mode (GET_MODE_INNER (mode), unsignedp);
     860                 :          12 :       if (inner != NULL_TREE)
     861                 :          12 :         return build_vector_type_for_mode (inner, mode);
     862                 :             :       return NULL_TREE;
     863                 :             :     }
     864                 :             : 
     865                 :      223023 :   scalar_int_mode imode;
     866                 :      223023 :   if (is_int_mode (mode, &imode))
     867                 :      187382 :     return gm2_langhook_type_for_size (GET_MODE_BITSIZE (imode), unsignedp);
     868                 :             : 
     869                 :      129332 :   if (mode == TYPE_MODE (float_type_node))
     870                 :         344 :     return float_type_node;
     871                 :             : 
     872                 :      128988 :   if (mode == TYPE_MODE (double_type_node))
     873                 :         509 :     return double_type_node;
     874                 :             : 
     875                 :      128479 :   if (mode == TYPE_MODE (long_double_type_node))
     876                 :         205 :     return long_double_type_node;
     877                 :             : 
     878                 :      128274 :   if ((float128_type_node != NULL) && (mode == TYPE_MODE (float128_type_node)))
     879                 :       14232 :     return float128_type_node;
     880                 :             : 
     881                 :      114042 :   if (COMPLEX_MODE_P (mode))
     882                 :             :     {
     883                 :       85578 :       machine_mode inner_mode;
     884                 :       85578 :       tree inner_type;
     885                 :             : 
     886                 :       85578 :       if (mode == TYPE_MODE (complex_float_type_node))
     887                 :       14358 :         return complex_float_type_node;
     888                 :       71220 :       if (mode == TYPE_MODE (complex_double_type_node))
     889                 :       14236 :         return complex_double_type_node;
     890                 :       56984 :       if (mode == TYPE_MODE (complex_long_double_type_node))
     891                 :       14288 :         return complex_long_double_type_node;
     892                 :             : 
     893                 :       42696 :       inner_mode = GET_MODE_INNER (mode);
     894                 :       42696 :       inner_type = gm2_langhook_type_for_mode (inner_mode, unsignedp);
     895                 :       42696 :       if (inner_type != NULL_TREE)
     896                 :       14232 :         return build_complex_type (inner_type);
     897                 :             :     }
     898                 :             : 
     899                 :             : #if HOST_BITS_PER_WIDE_INT >= 64
     900                 :             :   /* The middle-end and some backends rely on TImode being supported
     901                 :             :   for 64-bit HWI.  */
     902                 :       56928 :   if (mode == TImode)
     903                 :             :     {
     904                 :           0 :       type = build_nonstandard_integer_type (GET_MODE_BITSIZE (TImode),
     905                 :             :                                              unsignedp);
     906                 :           0 :       if (type && TYPE_MODE (type) == TImode)
     907                 :             :         return type;
     908                 :             :     }
     909                 :             : #endif
     910                 :             :   return NULL_TREE;
     911                 :             : }
     912                 :             : 
     913                 :             : /* Record a builtin function.  We just ignore builtin functions.  */
     914                 :             : 
     915                 :             : static tree
     916                 :     2220192 : gm2_langhook_builtin_function (tree decl)
     917                 :             : {
     918                 :     2220192 :   return decl;
     919                 :             : }
     920                 :             : 
     921                 :             : /* Return true if we are in the global binding level.  */
     922                 :             : 
     923                 :             : static bool
     924                 :       29244 : gm2_langhook_global_bindings_p (void)
     925                 :             : {
     926                 :       29244 :   return current_function_decl == NULL_TREE;
     927                 :             : }
     928                 :             : 
     929                 :             : /* Unused langhook.  */
     930                 :             : 
     931                 :             : static tree
     932                 :           0 : gm2_langhook_pushdecl (tree decl ATTRIBUTE_UNUSED)
     933                 :             : {
     934                 :           0 :   gcc_unreachable ();
     935                 :             : }
     936                 :             : 
     937                 :             : /* This hook is used to get the current list of declarations as trees.
     938                 :             :    We don't support that; instead we use write_globals.  This can't
     939                 :             :    simply crash because it is called by -gstabs.  */
     940                 :             : 
     941                 :             : static tree
     942                 :           0 : gm2_langhook_getdecls (void)
     943                 :             : {
     944                 :           0 :   return NULL;
     945                 :             : }
     946                 :             : 
     947                 :             : /* m2_write_global_declarations writes out globals creating an array
     948                 :             :    of the declarations and calling wrapup_global_declarations.  */
     949                 :             : 
     950                 :             : static void
     951                 :       12907 : m2_write_global_declarations (tree globals)
     952                 :             : {
     953                 :       12907 :   auto_vec<tree> global_decls;
     954                 :       12907 :   tree decl = globals;
     955                 :       12907 :   int n = 0;
     956                 :             : 
     957                 :     5190435 :   while (decl != NULL)
     958                 :             :     {
     959                 :     5177528 :       global_decls.safe_push (decl);
     960                 :     5177528 :       decl = TREE_CHAIN (decl);
     961                 :     5177528 :       n++;
     962                 :             :     }
     963                 :       25814 :   wrapup_global_declarations (global_decls.address (), n);
     964                 :       12907 : }
     965                 :             : 
     966                 :             : /* Write out globals.  */
     967                 :             : 
     968                 :             : static void
     969                 :       12907 : write_globals (void)
     970                 :             : {
     971                 :       12907 :   tree t;
     972                 :       12907 :   unsigned i;
     973                 :             : 
     974                 :       12907 :   m2block_finishGlobals ();
     975                 :             : 
     976                 :             :   /* Process all file scopes in this compilation, and the
     977                 :             :      external_scope, through wrapup_global_declarations and
     978                 :             :      check_global_declarations.  */
     979                 :       38721 :   FOR_EACH_VEC_ELT (*all_translation_units, i, t)
     980                 :       12907 :   m2_write_global_declarations (BLOCK_VARS (DECL_INITIAL (t)));
     981                 :       12907 : }
     982                 :             : 
     983                 :             : 
     984                 :             : /* Gimplify an EXPR_STMT node.  */
     985                 :             : 
     986                 :             : static void
     987                 :        2684 : gimplify_expr_stmt (tree *stmt_p)
     988                 :             : {
     989                 :        2684 :   gcc_assert (EXPR_STMT_EXPR (*stmt_p) != NULL_TREE);
     990                 :        2684 :   *stmt_p = EXPR_STMT_EXPR (*stmt_p);
     991                 :        2684 : }
     992                 :             : 
     993                 :             : /* Genericize a TRY_BLOCK.  */
     994                 :             : 
     995                 :             : static void
     996                 :        2684 : genericize_try_block (tree *stmt_p)
     997                 :             : {
     998                 :        2684 :   tree body = TRY_STMTS (*stmt_p);
     999                 :        2684 :   tree cleanup = TRY_HANDLERS (*stmt_p);
    1000                 :             : 
    1001                 :        2684 :   *stmt_p = build2 (TRY_CATCH_EXPR, void_type_node, body, cleanup);
    1002                 :        2684 : }
    1003                 :             : 
    1004                 :             : /* Genericize a HANDLER by converting to a CATCH_EXPR.  */
    1005                 :             : 
    1006                 :             : static void
    1007                 :        2684 : genericize_catch_block (tree *stmt_p)
    1008                 :             : {
    1009                 :        2684 :   tree type = HANDLER_TYPE (*stmt_p);
    1010                 :        2684 :   tree body = HANDLER_BODY (*stmt_p);
    1011                 :             : 
    1012                 :             :   /* FIXME should the caught type go in TREE_TYPE?  */
    1013                 :        2684 :   *stmt_p = build2 (CATCH_EXPR, void_type_node, type, body);
    1014                 :        2684 : }
    1015                 :             : 
    1016                 :             : /* Convert the tree representation of FNDECL from m2 frontend trees
    1017                 :             :    to GENERIC.  */
    1018                 :             : 
    1019                 :             : extern void pf (tree);
    1020                 :             : 
    1021                 :             : void
    1022                 :       94641 : gm2_genericize (tree fndecl)
    1023                 :             : {
    1024                 :       94641 :   tree t;
    1025                 :       94641 :   struct cgraph_node *cgn;
    1026                 :             : 
    1027                 :             : #if 0
    1028                 :             :   pf (fndecl);
    1029                 :             : #endif
    1030                 :             :   /* Fix up the types of parms passed by invisible reference.  */
    1031                 :      252397 :   for (t = DECL_ARGUMENTS (fndecl); t; t = DECL_CHAIN (t))
    1032                 :      157756 :     if (TREE_ADDRESSABLE (TREE_TYPE (t)))
    1033                 :             :       {
    1034                 :             : 
    1035                 :             :         /* If a function's arguments are copied to create a thunk, then
    1036                 :             :            DECL_BY_REFERENCE will be set -- but the type of the argument will be
    1037                 :             :            a pointer type, so we will never get here.  */
    1038                 :           0 :         gcc_assert (!DECL_BY_REFERENCE (t));
    1039                 :           0 :         gcc_assert (DECL_ARG_TYPE (t) != TREE_TYPE (t));
    1040                 :           0 :         TREE_TYPE (t) = DECL_ARG_TYPE (t);
    1041                 :           0 :         DECL_BY_REFERENCE (t) = 1;
    1042                 :           0 :         TREE_ADDRESSABLE (t) = 0;
    1043                 :           0 :         relayout_decl (t);
    1044                 :             :       }
    1045                 :             : 
    1046                 :             :   /* Dump all nested functions now.  */
    1047                 :       94641 :   cgn = cgraph_node::get_create (fndecl);
    1048                 :       95559 :   for (cgn = first_nested_function (cgn);
    1049                 :       95559 :        cgn != NULL; cgn = next_nested_function (cgn))
    1050                 :         918 :     gm2_genericize (cgn->decl);
    1051                 :       94641 : }
    1052                 :             : 
    1053                 :             : /* gm2 gimplify expression, currently just change THROW in the same
    1054                 :             :    way as C++ */
    1055                 :             : 
    1056                 :             : static int
    1057                 :     8267785 : gm2_langhook_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED,
    1058                 :             :                             gimple_seq *post_p ATTRIBUTE_UNUSED)
    1059                 :             : {
    1060                 :     8267785 :   enum tree_code code = TREE_CODE (*expr_p);
    1061                 :             : 
    1062                 :     8267785 :   switch (code)
    1063                 :             :     {
    1064                 :         284 :     case THROW_EXPR:
    1065                 :             : 
    1066                 :             :       /* FIXME communicate throw type to back end, probably by moving
    1067                 :             :       THROW_EXPR into ../tree.def.  */
    1068                 :         284 :       *expr_p = TREE_OPERAND (*expr_p, 0);
    1069                 :         284 :       return GS_OK;
    1070                 :             : 
    1071                 :        2684 :     case EXPR_STMT:
    1072                 :        2684 :       gimplify_expr_stmt (expr_p);
    1073                 :        2684 :       return GS_OK;
    1074                 :             : 
    1075                 :        2684 :     case TRY_BLOCK:
    1076                 :        2684 :       genericize_try_block (expr_p);
    1077                 :        2684 :       return GS_OK;
    1078                 :             : 
    1079                 :        2684 :     case HANDLER:
    1080                 :        2684 :       genericize_catch_block (expr_p);
    1081                 :        2684 :       return GS_OK;
    1082                 :             : 
    1083                 :             :     default:
    1084                 :             :       return GS_UNHANDLED;
    1085                 :             :     }
    1086                 :             : }
    1087                 :             : 
    1088                 :             : static GTY(()) tree gm2_eh_personality_decl;
    1089                 :             : 
    1090                 :             : static tree
    1091                 :        2719 : gm2_langhook_eh_personality (void)
    1092                 :             : {
    1093                 :        2719 :   if (!gm2_eh_personality_decl)
    1094                 :        2588 :     gm2_eh_personality_decl = build_personality_function ("gxx");
    1095                 :             : 
    1096                 :        2719 :   return gm2_eh_personality_decl;
    1097                 :             : }
    1098                 :             : 
    1099                 :             : /* Functions called directly by the generic backend.  */
    1100                 :             : 
    1101                 :             : tree
    1102                 :     6810195 : convert_loc (location_t location, tree type, tree expr)
    1103                 :             : {
    1104                 :     6810195 :   if (type == error_mark_node || expr == error_mark_node
    1105                 :    13620384 :       || TREE_TYPE (expr) == error_mark_node)
    1106                 :             :     return error_mark_node;
    1107                 :             : 
    1108                 :     6810189 :   if (type == TREE_TYPE (expr))
    1109                 :             :     return expr;
    1110                 :             : 
    1111                 :     3145597 :   gcc_assert (TYPE_MAIN_VARIANT (type) != NULL);
    1112                 :     3145597 :   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr)))
    1113                 :           0 :     return fold_convert (type, expr);
    1114                 :             : 
    1115                 :     3145597 :   expr = m2convert_GenericToType (location, type, expr);
    1116                 :     3145597 :   switch (TREE_CODE (type))
    1117                 :             :     {
    1118                 :       81226 :     case VOID_TYPE:
    1119                 :       81226 :     case BOOLEAN_TYPE:
    1120                 :       81226 :       return fold (convert_to_integer (type, expr));
    1121                 :     2538823 :     case INTEGER_TYPE:
    1122                 :     2538823 :       return fold (convert_to_integer (type, expr));
    1123                 :      479220 :     case POINTER_TYPE:
    1124                 :      479220 :       return fold (convert_to_pointer (type, expr));
    1125                 :        3974 :     case REAL_TYPE:
    1126                 :        3974 :       return fold (convert_to_real (type, expr));
    1127                 :         216 :     case COMPLEX_TYPE:
    1128                 :         216 :       return fold (convert_to_complex (type, expr));
    1129                 :       42126 :     case ENUMERAL_TYPE:
    1130                 :       42126 :       return fold (convert_to_integer (type, expr));
    1131                 :          12 :     default:
    1132                 :          12 :       error_at (location, "cannot convert expression, only base types can be converted");
    1133                 :          12 :       break;
    1134                 :             :     }
    1135                 :          12 :   return error_mark_node;
    1136                 :             : }
    1137                 :             : 
    1138                 :             : /* Functions called directly by the generic backend.  */
    1139                 :             : 
    1140                 :             : tree
    1141                 :      612009 : convert (tree type, tree expr)
    1142                 :             : {
    1143                 :      612009 :   return convert_loc (m2linemap_UnknownLocation (), type, expr);
    1144                 :             : }
    1145                 :             : 
    1146                 :             : /* Mark EXP saying that we need to be able to take the address of it;
    1147                 :             :    it should not be allocated in a register.  Returns true if
    1148                 :             :    successful.  */
    1149                 :             : 
    1150                 :             : bool
    1151                 :     2510605 : gm2_mark_addressable (tree exp)
    1152                 :             : {
    1153                 :     2510605 :   tree x = exp;
    1154                 :             : 
    1155                 :     2556103 :   while (TRUE)
    1156                 :     2556103 :     switch (TREE_CODE (x))
    1157                 :             :       {
    1158                 :        6530 :       case COMPONENT_REF:
    1159                 :        6530 :         if (DECL_PACKED (TREE_OPERAND (x, 1)))
    1160                 :             :           return false;
    1161                 :        6530 :         x = TREE_OPERAND (x, 0);
    1162                 :        6530 :         break;
    1163                 :             : 
    1164                 :       38968 :       case ADDR_EXPR:
    1165                 :       38968 :       case ARRAY_REF:
    1166                 :       38968 :       case REALPART_EXPR:
    1167                 :       38968 :       case IMAGPART_EXPR:
    1168                 :       38968 :         x = TREE_OPERAND (x, 0);
    1169                 :       38968 :         break;
    1170                 :             : 
    1171                 :     2504299 :       case COMPOUND_LITERAL_EXPR:
    1172                 :     2504299 :       case CONSTRUCTOR:
    1173                 :     2504299 :       case STRING_CST:
    1174                 :     2504299 :       case VAR_DECL:
    1175                 :     2504299 :       case CONST_DECL:
    1176                 :     2504299 :       case PARM_DECL:
    1177                 :     2504299 :       case RESULT_DECL:
    1178                 :     2504299 :       case FUNCTION_DECL:
    1179                 :     2504299 :         TREE_ADDRESSABLE (x) = 1;
    1180                 :     2504299 :         return true;
    1181                 :             :       default:
    1182                 :             :         return true;
    1183                 :             :       }
    1184                 :             :   /* Never reach here.  */
    1185                 :             :   gcc_unreachable ();
    1186                 :             : }
    1187                 :             : 
    1188                 :             : /* Return an integer type with BITS bits of precision, that is
    1189                 :             :    unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
    1190                 :             : 
    1191                 :             : tree
    1192                 :      227464 : gm2_type_for_size (unsigned int bits, int unsignedp)
    1193                 :             : {
    1194                 :      227464 :   if (unsignedp)
    1195                 :             :     {
    1196                 :       80409 :       if (bits == INT_TYPE_SIZE)
    1197                 :       25587 :         return unsigned_type_node;
    1198                 :       54822 :       else if (bits == CHAR_TYPE_SIZE)
    1199                 :       20614 :         return unsigned_char_type_node;
    1200                 :       34208 :       else if (bits == SHORT_TYPE_SIZE)
    1201                 :          64 :         return short_unsigned_type_node;
    1202                 :       34538 :       else if (bits == LONG_TYPE_SIZE)
    1203                 :       33744 :         return long_unsigned_type_node;
    1204                 :         400 :       else if (bits == LONG_LONG_TYPE_SIZE)
    1205                 :         394 :         return long_long_unsigned_type_node;
    1206                 :             :       else
    1207                 :           6 :         return build_nonstandard_integer_type (bits,
    1208                 :           6 :                                                unsignedp);
    1209                 :             :     }
    1210                 :             :   else
    1211                 :             :     {
    1212                 :      147055 :       if (bits == INT_TYPE_SIZE)
    1213                 :        3029 :         return integer_type_node;
    1214                 :      144026 :       else if (bits == CHAR_TYPE_SIZE)
    1215                 :          24 :         return signed_char_type_node;
    1216                 :      144002 :       else if (bits == SHORT_TYPE_SIZE)
    1217                 :         138 :         return short_integer_type_node;
    1218                 :      144252 :       else if (bits == LONG_TYPE_SIZE)
    1219                 :      129538 :         return long_integer_type_node;
    1220                 :       14326 :       else if (bits == LONG_LONG_TYPE_SIZE)
    1221                 :         388 :         return long_long_integer_type_node;
    1222                 :             :       else
    1223                 :       13938 :         return build_nonstandard_integer_type (bits,
    1224                 :       13938 :                                                unsignedp);
    1225                 :             :     }
    1226                 :             :   /* Never reach here.  */
    1227                 :             :   gcc_unreachable ();
    1228                 :             : }
    1229                 :             : 
    1230                 :             : /* Allow the analyzer to understand Storage ALLOCATE/DEALLOCATE.  */
    1231                 :             : 
    1232                 :             : bool
    1233                 :           0 : gm2_langhook_new_dispose_storage_substitution (void)
    1234                 :             : {
    1235                 :           0 :   return true;
    1236                 :             : }
    1237                 :             : 
    1238                 :             : #undef LANG_HOOKS_NAME
    1239                 :             : #undef LANG_HOOKS_INIT
    1240                 :             : #undef LANG_HOOKS_INIT_OPTIONS
    1241                 :             : #undef LANG_HOOKS_OPTION_LANG_MASK
    1242                 :             : #undef LANG_HOOKS_INIT_OPTIONS_STRUCT
    1243                 :             : #undef LANG_HOOKS_HANDLE_OPTION
    1244                 :             : #undef LANG_HOOKS_POST_OPTIONS
    1245                 :             : #undef LANG_HOOKS_PARSE_FILE
    1246                 :             : #undef LANG_HOOKS_TYPE_FOR_MODE
    1247                 :             : #undef LANG_HOOKS_TYPE_FOR_SIZE
    1248                 :             : #undef LANG_HOOKS_BUILTIN_FUNCTION
    1249                 :             : #undef LANG_HOOKS_GLOBAL_BINDINGS_P
    1250                 :             : #undef LANG_HOOKS_PUSHDECL
    1251                 :             : #undef LANG_HOOKS_GETDECLS
    1252                 :             : #undef LANG_HOOKS_GIMPLIFY_EXPR
    1253                 :             : #undef LANG_HOOKS_EH_PERSONALITY
    1254                 :             : #undef LANG_HOOKS_NEW_DISPOSE_STORAGE_SUBSTITUTION
    1255                 :             : 
    1256                 :             : #define LANG_HOOKS_NAME "GNU Modula-2"
    1257                 :             : #define LANG_HOOKS_INIT gm2_langhook_init
    1258                 :             : #define LANG_HOOKS_INIT_OPTIONS gm2_langhook_init_options
    1259                 :             : #define LANG_HOOKS_OPTION_LANG_MASK gm2_langhook_option_lang_mask
    1260                 :             : #define LANG_HOOKS_INIT_OPTIONS_STRUCT gm2_langhook_init_options_struct
    1261                 :             : #define LANG_HOOKS_HANDLE_OPTION gm2_langhook_handle_option
    1262                 :             : #define LANG_HOOKS_POST_OPTIONS gm2_langhook_post_options
    1263                 :             : #define LANG_HOOKS_PARSE_FILE gm2_langhook_parse_file
    1264                 :             : #define LANG_HOOKS_TYPE_FOR_MODE gm2_langhook_type_for_mode
    1265                 :             : #define LANG_HOOKS_TYPE_FOR_SIZE gm2_langhook_type_for_size
    1266                 :             : #define LANG_HOOKS_BUILTIN_FUNCTION gm2_langhook_builtin_function
    1267                 :             : #define LANG_HOOKS_GLOBAL_BINDINGS_P gm2_langhook_global_bindings_p
    1268                 :             : #define LANG_HOOKS_PUSHDECL gm2_langhook_pushdecl
    1269                 :             : #define LANG_HOOKS_GETDECLS gm2_langhook_getdecls
    1270                 :             : #define LANG_HOOKS_GIMPLIFY_EXPR gm2_langhook_gimplify_expr
    1271                 :             : #define LANG_HOOKS_EH_PERSONALITY gm2_langhook_eh_personality
    1272                 :             : #define LANG_HOOKS_NEW_DISPOSE_STORAGE_SUBSTITUTION \
    1273                 :             :   gm2_langhook_new_dispose_storage_substitution
    1274                 :             : 
    1275                 :             : struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
    1276                 :             : 
    1277                 :             : #include "gt-m2-gm2-lang.h"
    1278                 :             : #include "gtype-m2.h"
        

Generated by: LCOV version 2.1-beta

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.