LCOV - code coverage report
Current view: top level - gcc - langhooks.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 220 297 74.1 %
Date: 2020-04-04 11:58:09 Functions: 45 60 75.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Default language-specific hooks.
       2                 :            :    Copyright (C) 2001-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Alexandre Oliva  <aoliva@redhat.com>
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify
       8                 :            : it under the terms of the GNU General Public License as published by
       9                 :            : the Free Software Foundation; either version 3, or (at your option)
      10                 :            : any later version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful,
      13                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 :            : GNU General Public License for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : #include "config.h"
      22                 :            : #include "system.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "target.h"
      25                 :            : #include "rtl.h"
      26                 :            : #include "tree.h"
      27                 :            : #include "timevar.h"
      28                 :            : #include "stringpool.h"
      29                 :            : #include "diagnostic.h"
      30                 :            : #include "intl.h"
      31                 :            : #include "toplev.h"
      32                 :            : #include "attribs.h"
      33                 :            : #include "gimplify.h"
      34                 :            : #include "langhooks.h"
      35                 :            : #include "tree-diagnostic.h"
      36                 :            : #include "output.h"
      37                 :            : #include "timevar.h"
      38                 :            : #include "stor-layout.h"
      39                 :            : 
      40                 :            : /* Do nothing; in many cases the default hook.  */
      41                 :            : 
      42                 :            : void
      43                 :      22532 : lhd_do_nothing (void)
      44                 :            : {
      45                 :      22532 : }
      46                 :            : 
      47                 :            : /* Do nothing (tree).  */
      48                 :            : 
      49                 :            : void
      50                 :    8618970 : lhd_do_nothing_t (tree ARG_UNUSED (t))
      51                 :            : {
      52                 :    8618970 : }
      53                 :            : 
      54                 :            : /* Pass through (tree).  */
      55                 :            : tree
      56                 :        132 : lhd_pass_through_t (tree t)
      57                 :            : {
      58                 :        132 :   return t;
      59                 :            : }
      60                 :            : 
      61                 :            : /* Do nothing (int, int, int).  Return NULL_TREE.  */
      62                 :            : 
      63                 :            : tree
      64                 :          0 : lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i),
      65                 :            :                                      int ARG_UNUSED (j),
      66                 :            :                                      int ARG_UNUSED (k))
      67                 :            : {
      68                 :          0 :   return NULL_TREE;
      69                 :            : }
      70                 :            : 
      71                 :            : /* Do nothing (function).  */
      72                 :            : 
      73                 :            : void
      74                 :          0 : lhd_do_nothing_f (struct function * ARG_UNUSED (f))
      75                 :            : {
      76                 :          0 : }
      77                 :            : 
      78                 :            : /* Do nothing (return NULL_TREE).  */
      79                 :            : 
      80                 :            : tree
      81                 :          0 : lhd_return_null_tree (tree ARG_UNUSED (t))
      82                 :            : {
      83                 :          0 :   return NULL_TREE;
      84                 :            : }
      85                 :            : 
      86                 :            : /* Do nothing (return NULL_TREE).  */
      87                 :            : 
      88                 :            : tree
      89                 :       8459 : lhd_return_null_const_tree (const_tree ARG_UNUSED (t))
      90                 :            : {
      91                 :       8459 :   return NULL_TREE;
      92                 :            : }
      93                 :            : 
      94                 :            : /* The default post options hook.  */
      95                 :            : 
      96                 :            : bool
      97                 :        903 : lhd_post_options (const char ** ARG_UNUSED (pfilename))
      98                 :            : {
      99                 :            :   /* Excess precision other than "fast" requires front-end
     100                 :            :      support.  */
     101                 :        903 :   flag_excess_precision = EXCESS_PRECISION_FAST;
     102                 :        903 :   return false;
     103                 :            : }
     104                 :            : 
     105                 :            : /* Called from by print-tree.c.  */
     106                 :            : 
     107                 :            : void
     108                 :         16 : lhd_print_tree_nothing (FILE * ARG_UNUSED (file),
     109                 :            :                         tree ARG_UNUSED (node),
     110                 :            :                         int ARG_UNUSED (indent))
     111                 :            : {
     112                 :         16 : }
     113                 :            : 
     114                 :            : /* Called from check_global_declaration.  */
     115                 :            : 
     116                 :            : bool
     117                 :          6 : lhd_warn_unused_global_decl (const_tree decl)
     118                 :            : {
     119                 :            :   /* This is what used to exist in check_global_declaration.  Probably
     120                 :            :      not many of these actually apply to non-C languages.  */
     121                 :            : 
     122                 :          6 :   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
     123                 :            :     return false;
     124                 :          6 :   if (VAR_P (decl) && TREE_READONLY (decl))
     125                 :            :     return false;
     126                 :          6 :   if (DECL_IN_SYSTEM_HEADER (decl))
     127                 :          0 :     return false;
     128                 :            : 
     129                 :            :   return true;
     130                 :            : }
     131                 :            : 
     132                 :            : /* Set the DECL_ASSEMBLER_NAME for DECL.  */
     133                 :            : void
     134                 :    5082300 : lhd_set_decl_assembler_name (tree decl)
     135                 :            : {
     136                 :    5082300 :   tree id;
     137                 :            : 
     138                 :            :   /* set_decl_assembler_name may be called on TYPE_DECL to record ODR
     139                 :            :      name for C++ types.  By default types have no ODR names.  */
     140                 :    5082300 :   if (TREE_CODE (decl) == TYPE_DECL)
     141                 :            :     return;
     142                 :            : 
     143                 :            :   /* The language-independent code should never use the
     144                 :            :      DECL_ASSEMBLER_NAME for lots of DECLs.  Only FUNCTION_DECLs and
     145                 :            :      VAR_DECLs for variables with static storage duration need a real
     146                 :            :      DECL_ASSEMBLER_NAME.  */
     147                 :    5200290 :   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
     148                 :            :               || (VAR_P (decl)
     149                 :            :                   && (TREE_STATIC (decl)
     150                 :            :                       || DECL_EXTERNAL (decl)
     151                 :            :                       || TREE_PUBLIC (decl))));
     152                 :            : 
     153                 :            :   /* By default, assume the name to use in assembly code is the same
     154                 :            :      as that used in the source language.  (That's correct for C, and
     155                 :            :      GCC used to set DECL_ASSEMBLER_NAME to the same value as
     156                 :            :      DECL_NAME in build_decl, so this choice provides backwards
     157                 :            :      compatibility with existing front-ends.  This assumption is wrapped
     158                 :            :      in a target hook, to allow for target-specific modification of the
     159                 :            :      identifier.
     160                 :            : 
     161                 :            :      Can't use just the variable's own name for a variable whose scope
     162                 :            :      is less than the whole compilation.  Concatenate a distinguishing
     163                 :            :      number.  */
     164                 :            : 
     165                 :    6469300 :   if (TREE_PUBLIC (decl) || DECL_FILE_SCOPE_P (decl))
     166                 :    4833410 :     id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl));
     167                 :            :   else
     168                 :            :     {
     169                 :     167173 :       const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
     170                 :     167173 :       static unsigned long num;
     171                 :     167173 :       char *label;
     172                 :            : 
     173                 :     167173 :       ASM_FORMAT_PRIVATE_NAME (label, name, num++);
     174                 :     167173 :       id = get_identifier (label);
     175                 :            :     }
     176                 :            : 
     177                 :    5000580 :   SET_DECL_ASSEMBLER_NAME (decl, id);
     178                 :            : }
     179                 :            : 
     180                 :            : /* Forcibly overwrite the DECL_ASSEMBLER_NAME for DECL to NAME.  */
     181                 :            : void
     182                 :   75850300 : lhd_overwrite_decl_assembler_name (tree decl, tree name)
     183                 :            : {
     184                 :   75850300 :   DECL_ASSEMBLER_NAME_RAW (decl) = name;
     185                 :   75850300 : }
     186                 :            : 
     187                 :            : /* Type promotion for variable arguments.  */
     188                 :            : tree
     189                 :          0 : lhd_type_promotes_to (tree ARG_UNUSED (type))
     190                 :            : {
     191                 :          0 :   gcc_unreachable ();
     192                 :            : }
     193                 :            : 
     194                 :            : /* Registration of machine- or os-specific builtin types.  */
     195                 :            : void
     196                 :      50320 : lhd_register_builtin_type (tree ARG_UNUSED (type),
     197                 :            :                            const char * ARG_UNUSED (name))
     198                 :            : {
     199                 :      50320 : }
     200                 :            : 
     201                 :            : /* Invalid use of an incomplete type.  */
     202                 :            : void
     203                 :          0 : lhd_incomplete_type_error (location_t ARG_UNUSED (loc),
     204                 :            :                            const_tree ARG_UNUSED (value), const_tree type)
     205                 :            : {
     206                 :          0 :   gcc_assert (TREE_CODE (type) == ERROR_MARK);
     207                 :          0 :   return;
     208                 :            : }
     209                 :            : 
     210                 :            : /* Provide a default routine for alias sets that always returns -1.  This
     211                 :            :    is used by languages that don't need to do anything special.  */
     212                 :            : 
     213                 :            : alias_set_type
     214                 :  891546000 : lhd_get_alias_set (tree ARG_UNUSED (t))
     215                 :            : {
     216                 :  891546000 :   return -1;
     217                 :            : }
     218                 :            : 
     219                 :            : /* This is the default decl_printable_name function.  */
     220                 :            : 
     221                 :            : const char *
     222                 :    5545140 : lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity))
     223                 :            : {
     224                 :   11090300 :   gcc_assert (decl && DECL_NAME (decl));
     225                 :    5545140 :   return IDENTIFIER_POINTER (DECL_NAME (decl));
     226                 :            : }
     227                 :            : 
     228                 :            : /* This is the default dwarf_name function.  */
     229                 :            : 
     230                 :            : const char *
     231                 :    5346840 : lhd_dwarf_name (tree t, int verbosity)
     232                 :            : {
     233                 :    5346840 :   gcc_assert (DECL_P (t));
     234                 :            : 
     235                 :    5346840 :   return lang_hooks.decl_printable_name (t, verbosity);
     236                 :            : }
     237                 :            : 
     238                 :            : /* This compares two types for equivalence ("compatible" in C-based languages).
     239                 :            :    This routine should only return 1 if it is sure.  It should not be used
     240                 :            :    in contexts where erroneously returning 0 causes problems.  */
     241                 :            : 
     242                 :            : int
     243                 :          0 : lhd_types_compatible_p (tree x, tree y)
     244                 :            : {
     245                 :          0 :   return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y);
     246                 :            : }
     247                 :            : 
     248                 :            : /* lang_hooks.tree_dump.dump_tree:  Dump language-specific parts of tree
     249                 :            :    nodes.  Returns nonzero if it does not want the usual dumping of the
     250                 :            :    second argument.  */
     251                 :            : 
     252                 :            : bool
     253                 :          0 : lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
     254                 :            : {
     255                 :          0 :   return false;
     256                 :            : }
     257                 :            : 
     258                 :            : /* lang_hooks.tree_dump.type_qual:  Determine type qualifiers in a
     259                 :            :    language-specific way.  */
     260                 :            : 
     261                 :            : int
     262                 :          4 : lhd_tree_dump_type_quals (const_tree t)
     263                 :            : {
     264                 :          4 :   return TYPE_QUALS (t);
     265                 :            : }
     266                 :            : 
     267                 :            : /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form.  */
     268                 :            : 
     269                 :            : int
     270                 :   44671500 : lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED,
     271                 :            :                    gimple_seq *pre_p ATTRIBUTE_UNUSED,
     272                 :            :                    gimple_seq *post_p ATTRIBUTE_UNUSED)
     273                 :            : {
     274                 :   44671500 :   return GS_UNHANDLED;
     275                 :            : }
     276                 :            : 
     277                 :            : /* lang_hooks.tree_size: Determine the size of a tree with code C,
     278                 :            :    which is a language-specific tree code in category tcc_constant,
     279                 :            :    tcc_exceptional or tcc_type.  The default expects never to be called.  */
     280                 :            : size_t
     281                 :          0 : lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
     282                 :            : {
     283                 :          0 :   gcc_unreachable ();
     284                 :            : }
     285                 :            : 
     286                 :            : /* Return true if decl, which is a function decl, may be called by a
     287                 :            :    sibcall.  */
     288                 :            : 
     289                 :            : bool
     290                 :      91160 : lhd_decl_ok_for_sibcall (const_tree decl ATTRIBUTE_UNUSED)
     291                 :            : {
     292                 :      91160 :   return true;
     293                 :            : }
     294                 :            : 
     295                 :            : /* Generic global declaration processing.  This is meant to be called
     296                 :            :    by the front-ends at the end of parsing.  C/C++ do their own thing,
     297                 :            :    but other front-ends may call this.  */
     298                 :            : 
     299                 :            : void
     300                 :      25149 : global_decl_processing (void)
     301                 :            : {
     302                 :      25149 :   tree globals, decl, *vec;
     303                 :      25149 :   int len, i;
     304                 :            : 
     305                 :      25149 :   timevar_stop (TV_PHASE_PARSING);
     306                 :      25149 :   timevar_start (TV_PHASE_DEFERRED);
     307                 :            :   /* Really define vars that have had only a tentative definition.
     308                 :            :      Really output inline functions that must actually be callable
     309                 :            :      and have not been output so far.  */
     310                 :            : 
     311                 :      25149 :   globals = lang_hooks.decls.getdecls ();
     312                 :      25149 :   len = list_length (globals);
     313                 :      25149 :   vec = XNEWVEC (tree, len);
     314                 :            : 
     315                 :            :   /* Process the decls in reverse order--earliest first.
     316                 :            :      Put them into VEC from back to front, then take out from front.  */
     317                 :            : 
     318                 :   93348000 :   for (i = 0, decl = globals; i < len; i++, decl = DECL_CHAIN (decl))
     319                 :   93322800 :     vec[len - i - 1] = decl;
     320                 :            : 
     321                 :      25149 :   wrapup_global_declarations (vec, len);
     322                 :      25149 :   timevar_stop (TV_PHASE_DEFERRED);
     323                 :            : 
     324                 :      25149 :   timevar_start (TV_PHASE_PARSING);
     325                 :      25149 :   free (vec);
     326                 :      25149 : }
     327                 :            : 
     328                 :            : /* Called to perform language-specific initialization of CTX.  */
     329                 :            : void
     330                 :      43446 : lhd_initialize_diagnostics (diagnostic_context *ctx ATTRIBUTE_UNUSED)
     331                 :            : {
     332                 :      43446 : }
     333                 :            : 
     334                 :            : /* Called to register dumps.  */
     335                 :            : void
     336                 :     108266 : lhd_register_dumps (gcc::dump_manager *)
     337                 :            : {
     338                 :     108266 : }
     339                 :            : 
     340                 :            : /* Called to perform language-specific options initialization.  */
     341                 :            : void
     342                 :      18262 : lhd_init_options (unsigned int decoded_options_count ATTRIBUTE_UNUSED,
     343                 :            :                   struct cl_decoded_option *decoded_options ATTRIBUTE_UNUSED)
     344                 :            : {
     345                 :      18262 : }
     346                 :            : 
     347                 :            : /* By default, always complain about options for the wrong language.  */
     348                 :            : bool
     349                 :          6 : lhd_complain_wrong_lang_p (const struct cl_option *option ATTRIBUTE_UNUSED)
     350                 :            : {
     351                 :          6 :   return true;
     352                 :            : }
     353                 :            : 
     354                 :            : /* By default, no language-specific options are valid.  */
     355                 :            : bool
     356                 :          0 : lhd_handle_option (size_t code ATTRIBUTE_UNUSED,
     357                 :            :                    const char *arg ATTRIBUTE_UNUSED,
     358                 :            :                    HOST_WIDE_INT value ATTRIBUTE_UNUSED,
     359                 :            :                    int kind ATTRIBUTE_UNUSED,
     360                 :            :                    location_t loc ATTRIBUTE_UNUSED,
     361                 :            :                    const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
     362                 :            : {
     363                 :          0 :   return false;
     364                 :            : }
     365                 :            : 
     366                 :            : /* The default function to print out name of current function that caused
     367                 :            :    an error.  */
     368                 :            : void
     369                 :      62222 : lhd_print_error_function (diagnostic_context *context, const char *file,
     370                 :            :                           diagnostic_info *diagnostic)
     371                 :            : {
     372                 :      62222 :   if (diagnostic_last_function_changed (context, diagnostic))
     373                 :            :     {
     374                 :      10866 :       char *old_prefix = pp_take_prefix (context->printer);
     375                 :      10866 :       tree abstract_origin = diagnostic_abstract_origin (diagnostic);
     376                 :      10866 :       char *new_prefix = (file && abstract_origin == NULL)
     377                 :      10866 :                          ? file_name_as_prefix (context, file) : NULL;
     378                 :            : 
     379                 :      10866 :       pp_set_prefix (context->printer, new_prefix);
     380                 :            : 
     381                 :      10866 :       if (current_function_decl == NULL)
     382                 :        452 :         pp_printf (context->printer, _("At top level:"));
     383                 :            :       else
     384                 :            :         {
     385                 :      10414 :           tree fndecl, ao;
     386                 :            : 
     387                 :      10414 :           if (abstract_origin)
     388                 :            :             {
     389                 :         47 :               ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
     390                 :         47 :               gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
     391                 :            :               fndecl = ao;
     392                 :            :             }
     393                 :            :           else
     394                 :            :             fndecl = current_function_decl;
     395                 :            : 
     396                 :      10414 :           if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
     397                 :          8 :             pp_printf
     398                 :          8 :               (context->printer, _("In member function %qs"),
     399                 :          8 :                identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)));
     400                 :            :           else
     401                 :      10406 :             pp_printf
     402                 :      10406 :               (context->printer, _("In function %qs"),
     403                 :      10406 :                identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)));
     404                 :            : 
     405                 :      10469 :           while (abstract_origin)
     406                 :            :             {
     407                 :         55 :               location_t *locus;
     408                 :         55 :               tree block = abstract_origin;
     409                 :            : 
     410                 :         55 :               locus = &BLOCK_SOURCE_LOCATION (block);
     411                 :         55 :               fndecl = NULL;
     412                 :         55 :               block = BLOCK_SUPERCONTEXT (block);
     413                 :         63 :               while (block && TREE_CODE (block) == BLOCK
     414                 :        126 :                      && BLOCK_ABSTRACT_ORIGIN (block))
     415                 :            :                 {
     416                 :         16 :                   ao = BLOCK_ABSTRACT_ORIGIN (block);
     417                 :         16 :                   if (TREE_CODE (ao) == FUNCTION_DECL)
     418                 :            :                     {
     419                 :            :                       fndecl = ao;
     420                 :            :                       break;
     421                 :            :                     }
     422                 :          8 :                   else if (TREE_CODE (ao) != BLOCK)
     423                 :            :                     break;
     424                 :            : 
     425                 :          8 :                   block = BLOCK_SUPERCONTEXT (block);
     426                 :            :                 }
     427                 :         55 :               if (fndecl)
     428                 :            :                 abstract_origin = block;
     429                 :            :               else
     430                 :            :                 {
     431                 :         94 :                   while (block && TREE_CODE (block) == BLOCK)
     432                 :         47 :                     block = BLOCK_SUPERCONTEXT (block);
     433                 :            : 
     434                 :         47 :                   if (block && TREE_CODE (block) == FUNCTION_DECL)
     435                 :         47 :                     fndecl = block;
     436                 :            :                   abstract_origin = NULL;
     437                 :            :                 }
     438                 :         55 :               if (fndecl)
     439                 :            :                 {
     440                 :         55 :                   expanded_location s = expand_location (*locus);
     441                 :         55 :                   pp_comma (context->printer);
     442                 :         55 :                   pp_newline (context->printer);
     443                 :         55 :                   if (s.file != NULL)
     444                 :            :                     {
     445                 :         55 :                       if (context->show_column)
     446                 :         55 :                         pp_printf (context->printer,
     447                 :         55 :                                    _("    inlined from %qs at %r%s:%d:%d%R"),
     448                 :         55 :                                    identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)),
     449                 :            :                                    "locus", s.file, s.line, s.column);
     450                 :            :                       else
     451                 :          0 :                         pp_printf (context->printer,
     452                 :          0 :                                    _("    inlined from %qs at %r%s:%d%R"),
     453                 :          0 :                                    identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)),
     454                 :            :                                    "locus", s.file, s.line);
     455                 :            : 
     456                 :            :                     }
     457                 :            :                   else
     458                 :          0 :                     pp_printf (context->printer, _("    inlined from %qs"),
     459                 :          0 :                                identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)));
     460                 :            :                 }
     461                 :            :             }
     462                 :      10414 :           pp_colon (context->printer);
     463                 :            :         }
     464                 :            : 
     465                 :      10866 :       diagnostic_set_last_function (context, diagnostic);
     466                 :      10866 :       pp_newline_and_flush (context->printer);
     467                 :      10866 :       context->printer->prefix = old_prefix;
     468                 :      10866 :       free ((char*) new_prefix);
     469                 :            :     }
     470                 :      62222 : }
     471                 :            : 
     472                 :            : tree
     473                 :     144521 : lhd_make_node (enum tree_code code)
     474                 :            : {
     475                 :     144521 :   return make_node (code);
     476                 :            : }
     477                 :            : 
     478                 :            : /* Default implementation of LANG_HOOKS_SIMULATE_ENUM_DECL.  Assume a
     479                 :            :    simple int-based enumerator (which is all the hook can be used for
     480                 :            :    at present) and push each decl individually without any decoration.
     481                 :            : 
     482                 :            :    This definition is suitable for LTO and is generic enough that it
     483                 :            :    might be reusable elsewhere.  */
     484                 :            : tree
     485                 :          0 : lhd_simulate_enum_decl (location_t loc, const char *name,
     486                 :            :                         vec<string_int_pair> values)
     487                 :            : {
     488                 :          0 :   tree enumtype = lang_hooks.types.make_type (ENUMERAL_TYPE);
     489                 :          0 :   tree enumdecl = build_decl (loc, TYPE_DECL, get_identifier (name), enumtype);
     490                 :          0 :   TYPE_STUB_DECL (enumtype) = enumdecl;
     491                 :            : 
     492                 :          0 :   tree value_chain = NULL_TREE;
     493                 :          0 :   string_int_pair *value;
     494                 :          0 :   unsigned int i;
     495                 :          0 :   FOR_EACH_VEC_ELT (values, i, value)
     496                 :            :     {
     497                 :          0 :       tree value_decl = build_decl (loc, CONST_DECL,
     498                 :            :                                     get_identifier (value->first), enumtype);
     499                 :          0 :       DECL_INITIAL (value_decl) = build_int_cst (integer_type_node,
     500                 :          0 :                                                  value->second);
     501                 :          0 :       lang_hooks.decls.pushdecl (value_decl);
     502                 :          0 :       value_chain = tree_cons (value_decl, DECL_INITIAL (value_decl),
     503                 :            :                                value_chain);
     504                 :            :     }
     505                 :            : 
     506                 :          0 :   TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (integer_type_node);
     507                 :          0 :   TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (integer_type_node);
     508                 :          0 :   SET_TYPE_ALIGN (enumtype, TYPE_ALIGN (integer_type_node));
     509                 :          0 :   TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
     510                 :          0 :   layout_type (enumtype);
     511                 :          0 :   lang_hooks.decls.pushdecl (enumdecl);
     512                 :            : 
     513                 :          0 :   return enumtype;
     514                 :            : }
     515                 :            : 
     516                 :            : /* Default implementation of LANG_HOOKS_TYPE_FOR_SIZE.
     517                 :            :    Return an integer type with PRECISION bits of precision,
     518                 :            :    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
     519                 :            : 
     520                 :            : tree
     521                 :      73463 : lhd_type_for_size (unsigned precision, int unsignedp)
     522                 :            : {
     523                 :      73463 :   int i;
     524                 :            : 
     525                 :      73463 :   if (precision == TYPE_PRECISION (integer_type_node))
     526                 :      14027 :     return unsignedp ? unsigned_type_node : integer_type_node;
     527                 :            : 
     528                 :      59436 :   if (precision == TYPE_PRECISION (signed_char_type_node))
     529                 :      13992 :     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
     530                 :            : 
     531                 :      45444 :   if (precision == TYPE_PRECISION (short_integer_type_node))
     532                 :      13996 :     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
     533                 :            : 
     534                 :      31448 :   if (precision == TYPE_PRECISION (long_integer_type_node))
     535                 :      17458 :     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
     536                 :            : 
     537                 :      13990 :   if (precision == TYPE_PRECISION (long_long_integer_type_node))
     538                 :          0 :     return unsignedp
     539                 :          0 :            ? long_long_unsigned_type_node
     540                 :          0 :            : long_long_integer_type_node;
     541                 :            : 
     542                 :      13990 :   for (i = 0; i < NUM_INT_N_ENTS; i ++)
     543                 :      13990 :     if (int_n_enabled_p[i]
     544                 :      13990 :         && precision == int_n_data[i].bitsize)
     545                 :      13990 :       return (unsignedp ? int_n_trees[i].unsigned_type
     546                 :      13990 :               : int_n_trees[i].signed_type);
     547                 :            : 
     548                 :          0 :   if (precision <= TYPE_PRECISION (intQI_type_node))
     549                 :          0 :     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
     550                 :            : 
     551                 :          0 :   if (precision <= TYPE_PRECISION (intHI_type_node))
     552                 :          0 :     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
     553                 :            : 
     554                 :          0 :   if (precision <= TYPE_PRECISION (intSI_type_node))
     555                 :          0 :     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
     556                 :            : 
     557                 :          0 :   if (precision <= TYPE_PRECISION (intDI_type_node))
     558                 :          0 :     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
     559                 :            : 
     560                 :          0 :   if (precision <= TYPE_PRECISION (intTI_type_node))
     561                 :          0 :     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
     562                 :            : 
     563                 :            :   return NULL_TREE;
     564                 :            : }
     565                 :            : 
     566                 :            : HOST_WIDE_INT
     567                 :    2997350 : lhd_to_target_charset (HOST_WIDE_INT c)
     568                 :            : {
     569                 :    2997350 :   return c;
     570                 :            : }
     571                 :            : 
     572                 :            : tree
     573                 :  486225000 : lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED)
     574                 :            : {
     575                 :  486225000 :   return expr;
     576                 :            : }
     577                 :            : 
     578                 :            : /* Return sharing kind if OpenMP sharing attribute of DECL is
     579                 :            :    predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise.  */
     580                 :            : 
     581                 :            : enum omp_clause_default_kind
     582                 :          0 : lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED)
     583                 :            : {
     584                 :          0 :   if (DECL_ARTIFICIAL (decl))
     585                 :          0 :     return OMP_CLAUSE_DEFAULT_SHARED;
     586                 :            :   return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
     587                 :            : }
     588                 :            : 
     589                 :            : /* Generate code to copy SRC to DST.  */
     590                 :            : 
     591                 :            : tree
     592                 :          0 : lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src)
     593                 :            : {
     594                 :          0 :   return build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
     595                 :            : }
     596                 :            : 
     597                 :            : /* Finalize clause C.  */
     598                 :            : 
     599                 :            : void
     600                 :      45449 : lhd_omp_finish_clause (tree, gimple_seq *)
     601                 :            : {
     602                 :      45449 : }
     603                 :            : 
     604                 :            : /* Return true if DECL is a scalar variable (for the purpose of
     605                 :            :    implicit firstprivatization).  */
     606                 :            : 
     607                 :            : bool
     608                 :      11438 : lhd_omp_scalar_p (tree decl)
     609                 :            : {
     610                 :      11438 :   tree type = TREE_TYPE (decl);
     611                 :      11438 :   if (TREE_CODE (type) == REFERENCE_TYPE)
     612                 :         69 :     type = TREE_TYPE (type);
     613                 :      11438 :   if (TREE_CODE (type) == COMPLEX_TYPE)
     614                 :          0 :     type = TREE_TYPE (type);
     615                 :      11438 :   if (INTEGRAL_TYPE_P (type)
     616                 :            :       || SCALAR_FLOAT_TYPE_P (type)
     617                 :      11438 :       || TREE_CODE (type) == POINTER_TYPE)
     618                 :      11208 :     return true;
     619                 :            :   return false;
     620                 :            : }
     621                 :            : 
     622                 :            : /* Register language specific type size variables as potentially OpenMP
     623                 :            :    firstprivate variables.  */
     624                 :            : 
     625                 :            : void
     626                 :       7679 : lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *c ATTRIBUTE_UNUSED,
     627                 :            :                                    tree t ATTRIBUTE_UNUSED)
     628                 :            : {
     629                 :       7679 : }
     630                 :            : 
     631                 :            : /* Return true if TYPE is an OpenMP mappable type.  */
     632                 :            : 
     633                 :            : bool
     634                 :      15095 : lhd_omp_mappable_type (tree type)
     635                 :            : {
     636                 :            :   /* Mappable type has to be complete.  */
     637                 :      30188 :   if (type == error_mark_node || !COMPLETE_TYPE_P (type))
     638                 :         19 :     return false;
     639                 :            :   return true;
     640                 :            : }
     641                 :            : 
     642                 :            : /* Common function for add_builtin_function, add_builtin_function_ext_scope
     643                 :            :    and simulate_builtin_function_decl.  */
     644                 :            : 
     645                 :            : static tree
     646                 :  442582000 : build_builtin_function (location_t location, const char *name, tree type,
     647                 :            :                         int function_code, enum built_in_class cl,
     648                 :            :                         const char *library_name, tree attrs)
     649                 :            : {
     650                 :  442582000 :   tree   id = get_identifier (name);
     651                 :  442582000 :   tree decl = build_decl (location, FUNCTION_DECL, id, type);
     652                 :            : 
     653                 :  442582000 :   TREE_PUBLIC (decl)         = 1;
     654                 :  442582000 :   DECL_EXTERNAL (decl)       = 1;
     655                 :            : 
     656                 :  442582000 :   set_decl_built_in_function (decl, cl, function_code);
     657                 :            : 
     658                 :  442582000 :   if (library_name)
     659                 :            :     {
     660                 :  114841000 :       tree libname = get_identifier (library_name);
     661                 :            : 
     662                 :  114841000 :       libname = targetm.mangle_decl_assembler_name (decl, libname);
     663                 :  114841000 :       SET_DECL_ASSEMBLER_NAME (decl, libname);
     664                 :            :     }
     665                 :            : 
     666                 :            :   /* Possibly apply some default attributes to this built-in function.  */
     667                 :  442582000 :   if (attrs)
     668                 :  232704000 :     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
     669                 :            :   else
     670                 :  209879000 :     decl_attributes (&decl, NULL_TREE, 0);
     671                 :            : 
     672                 :  442582000 :   return decl;
     673                 :            : }
     674                 :            : 
     675                 :            : /* Create a builtin function.  */
     676                 :            : 
     677                 :            : tree
     678                 :  436416000 : add_builtin_function (const char *name,
     679                 :            :                       tree type,
     680                 :            :                       int function_code,
     681                 :            :                       enum built_in_class cl,
     682                 :            :                       const char *library_name,
     683                 :            :                       tree attrs)
     684                 :            : {
     685                 :  436416000 :   tree decl = build_builtin_function (BUILTINS_LOCATION, name, type,
     686                 :            :                                       function_code, cl, library_name, attrs);
     687                 :  436416000 :   return lang_hooks.builtin_function (decl);
     688                 :            : }
     689                 :            : 
     690                 :            : /* Like add_builtin_function, but make sure the scope is the external scope.
     691                 :            :    This is used to delay putting in back end builtin functions until the ISA
     692                 :            :    that defines the builtin is declared via function specific target options,
     693                 :            :    which can save memory for machines like the x86_64 that have multiple ISAs.
     694                 :            :    If this points to the same function as builtin_function, the backend must
     695                 :            :    add all of the builtins at program initialization time.  */
     696                 :            : 
     697                 :            : tree
     698                 :    6166090 : add_builtin_function_ext_scope (const char *name,
     699                 :            :                                 tree type,
     700                 :            :                                 int function_code,
     701                 :            :                                 enum built_in_class cl,
     702                 :            :                                 const char *library_name,
     703                 :            :                                 tree attrs)
     704                 :            : {
     705                 :    6166090 :   tree decl = build_builtin_function (BUILTINS_LOCATION, name, type,
     706                 :            :                                       function_code, cl, library_name, attrs);
     707                 :    6166090 :   return lang_hooks.builtin_function_ext_scope (decl);
     708                 :            : }
     709                 :            : 
     710                 :            : /* Simulate a declaration of a target-specific built-in function at
     711                 :            :    location LOCATION, as though it had been declared directly in the
     712                 :            :    source language.  NAME is the name of the function, TYPE is its function
     713                 :            :    type, FUNCTION_CODE is the target-specific function code, LIBRARY_NAME
     714                 :            :    is the name of the underlying library function (NULL if none) and
     715                 :            :    ATTRS is a list of function attributes.
     716                 :            : 
     717                 :            :    Return the decl of the declared function.  */
     718                 :            : 
     719                 :            : tree
     720                 :          0 : simulate_builtin_function_decl (location_t location, const char *name,
     721                 :            :                                 tree type, int function_code,
     722                 :            :                                 const char *library_name, tree attrs)
     723                 :            : {
     724                 :          0 :   tree decl = build_builtin_function (location, name, type,
     725                 :            :                                       function_code, BUILT_IN_MD,
     726                 :            :                                       library_name, attrs);
     727                 :          0 :   tree new_decl = lang_hooks.simulate_builtin_function_decl (decl);
     728                 :            : 
     729                 :            :   /* Give the front end a chance to create a new decl if necessary,
     730                 :            :      but if the front end discards the decl in favour of a conflicting
     731                 :            :      (erroneous) previous definition, return the decl that we tried but
     732                 :            :      failed to add.  This allows the caller to process the returned decl
     733                 :            :      normally, even though the source code won't be able to use it.  */
     734                 :          0 :   if (TREE_CODE (new_decl) == FUNCTION_DECL
     735                 :          0 :       && fndecl_built_in_p (new_decl, function_code, BUILT_IN_MD))
     736                 :          0 :     return new_decl;
     737                 :            : 
     738                 :            :   return decl;
     739                 :            : }
     740                 :            : 
     741                 :            : tree
     742                 :          0 : lhd_builtin_function (tree decl)
     743                 :            : {
     744                 :          0 :   lang_hooks.decls.pushdecl (decl);
     745                 :          0 :   return decl;
     746                 :            : }
     747                 :            : 
     748                 :            : /* Create a builtin type.  */
     749                 :            : 
     750                 :            : tree
     751                 :          0 : add_builtin_type (const char *name, tree type)
     752                 :            : {
     753                 :          0 :   tree   id = get_identifier (name);
     754                 :          0 :   tree decl = build_decl (BUILTINS_LOCATION, TYPE_DECL, id, type);
     755                 :          0 :   return lang_hooks.decls.pushdecl (decl);
     756                 :            : }
     757                 :            : 
     758                 :            : /* LTO hooks.  */
     759                 :            : 
     760                 :            : /* Used to save and restore any previously active section.  */
     761                 :            : static section *saved_section;
     762                 :            : 
     763                 :            : 
     764                 :            : /* Begin a new LTO output section named NAME.  This default implementation
     765                 :            :    saves the old section and emits assembly code to switch to the new
     766                 :            :    section.  */
     767                 :            : 
     768                 :            : void
     769                 :     306923 : lhd_begin_section (const char *name)
     770                 :            : {
     771                 :     306923 :   section *section;
     772                 :            : 
     773                 :            :   /* Save the old section so we can restore it in lto_end_asm_section.  */
     774                 :     306923 :   gcc_assert (!saved_section);
     775                 :     306923 :   saved_section = in_section;
     776                 :     306923 :   if (!saved_section)
     777                 :      15520 :     saved_section = text_section;
     778                 :            : 
     779                 :            :   /* Create a new section and switch to it.  */
     780                 :     306923 :   section = get_section (name, SECTION_DEBUG | SECTION_EXCLUDE, NULL);
     781                 :     306923 :   switch_to_section (section);
     782                 :     306923 : }
     783                 :            : 
     784                 :            : 
     785                 :            : /* Write DATA of length LEN to the current LTO output section.  This default
     786                 :            :    implementation just calls assemble_string.  */
     787                 :            : 
     788                 :            : void
     789                 :    4417000 : lhd_append_data (const void *data, size_t len, void *)
     790                 :            : {
     791                 :    4417000 :   if (data)
     792                 :            :     {
     793                 :    4417000 :       timevar_push (TV_IPA_LTO_OUTPUT);
     794                 :    4417000 :       assemble_string ((const char *)data, len);
     795                 :    4417000 :       timevar_pop (TV_IPA_LTO_OUTPUT);
     796                 :            :     }
     797                 :    4417000 : }
     798                 :            : 
     799                 :            : 
     800                 :            : /* Finish the current LTO output section.  This default implementation emits
     801                 :            :    assembly code to switch to any section previously saved by
     802                 :            :    lhd_begin_section.  */
     803                 :            : 
     804                 :            : void
     805                 :     306923 : lhd_end_section (void)
     806                 :            : {
     807                 :     306923 :   if (saved_section)
     808                 :            :     {
     809                 :     306923 :       switch_to_section (saved_section);
     810                 :     306923 :       saved_section = NULL;
     811                 :            :     }
     812                 :     306923 : }
     813                 :            : 
     814                 :            : /* Default implementation of enum_underlying_base_type using type_for_size.  */
     815                 :            : 
     816                 :            : tree
     817                 :      80133 : lhd_enum_underlying_base_type (const_tree enum_type)
     818                 :            : {
     819                 :      80133 :   return lang_hooks.types.type_for_size (TYPE_PRECISION (enum_type),
     820                 :      80133 :                                          TYPE_UNSIGNED (enum_type));
     821                 :            : }
     822                 :            : 
     823                 :            : /* Default implementation of LANG_HOOKS_GET_SUBSTRING_LOCATION.  */
     824                 :            : 
     825                 :            : const char *
     826                 :        854 : lhd_get_substring_location (const substring_loc &, location_t *)
     827                 :            : {
     828                 :        854 :   return "unimplemented";
     829                 :            : }
     830                 :            : 
     831                 :            : /* Default implementation of LANG_HOOKS_DECL_DWARF_ATTRIBUTE.  Don't add
     832                 :            :    any attributes.  */
     833                 :            : 
     834                 :            : int
     835                 :    4223720 : lhd_decl_dwarf_attribute (const_tree, int)
     836                 :            : {
     837                 :    4223720 :   return -1;
     838                 :            : }
     839                 :            : 
     840                 :            : /* Default implementation of LANG_HOOKS_TYPE_DWARF_ATTRIBUTE.  Don't add
     841                 :            :    any attributes.  */
     842                 :            : 
     843                 :            : int
     844                 :     132786 : lhd_type_dwarf_attribute (const_tree, int)
     845                 :            : {
     846                 :     132786 :   return -1;
     847                 :            : }
     848                 :            : 
     849                 :            : /* Default implementation of LANG_HOOKS_UNIT_SIZE_WITHOUT_REUSABLE_PADDING.
     850                 :            :    Just return TYPE_SIZE_UNIT unadjusted.  */
     851                 :            : 
     852                 :            : tree
     853                 :       5264 : lhd_unit_size_without_reusable_padding (tree t)
     854                 :            : {
     855                 :       5264 :   return TYPE_SIZE_UNIT (t);
     856                 :            : }
     857                 :            : 
     858                 :            : /* Returns true if the current lang_hooks represents the GNU C frontend.  */
     859                 :            : 
     860                 :            : bool
     861                 :     178588 : lang_GNU_C (void)
     862                 :            : {
     863                 :     178588 :   return (strncmp (lang_hooks.name, "GNU C", 5) == 0
     864                 :     178588 :           && (lang_hooks.name[5] == '\0' || ISDIGIT (lang_hooks.name[5])));
     865                 :            : }
     866                 :            : 
     867                 :            : /* Returns true if the current lang_hooks represents the GNU C++ frontend.  */
     868                 :            : 
     869                 :            : bool
     870                 :      14664 : lang_GNU_CXX (void)
     871                 :            : {
     872                 :      14664 :   return strncmp (lang_hooks.name, "GNU C++", 7) == 0;
     873                 :            : }
     874                 :            : 
     875                 :            : /* Returns true if the current lang_hooks represents the GNU Fortran frontend.  */
     876                 :            : 
     877                 :            : bool
     878                 :     131916 : lang_GNU_Fortran (void)
     879                 :            : {
     880                 :     131916 :   return strncmp (lang_hooks.name, "GNU Fortran", 11) == 0;
     881                 :            : }
     882                 :            : 
     883                 :            : /* Returns true if the current lang_hooks represents the GNU Objective-C
     884                 :            :    frontend.  */
     885                 :            : 
     886                 :            : bool
     887                 :      92570 : lang_GNU_OBJC (void)
     888                 :            : {
     889                 :      92570 :   return strncmp (lang_hooks.name, "GNU Objective-C", 15) == 0;
     890                 :            : }

Generated by: LCOV version 1.0

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