LCOV - code coverage report
Current view: top level - gcc - gimple-expr.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 340 366 92.9 %
Date: 2020-03-28 11:57:23 Functions: 32 33 97.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Gimple decl, type, and expression support functions.
       2                 :            : 
       3                 :            :    Copyright (C) 2007-2020 Free Software Foundation, Inc.
       4                 :            :    Contributed by Aldy Hernandez <aldyh@redhat.com>
       5                 :            : 
       6                 :            : This file is part of GCC.
       7                 :            : 
       8                 :            : GCC is free software; you can redistribute it and/or modify it under
       9                 :            : the terms of the GNU General Public License as published by the Free
      10                 :            : Software Foundation; either version 3, or (at your option) any later
      11                 :            : version.
      12                 :            : 
      13                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      14                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      15                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      16                 :            : 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                 :            : #include "config.h"
      23                 :            : #include "system.h"
      24                 :            : #include "coretypes.h"
      25                 :            : #include "backend.h"
      26                 :            : #include "tree.h"
      27                 :            : #include "gimple.h"
      28                 :            : #include "stringpool.h"
      29                 :            : #include "gimple-ssa.h"
      30                 :            : #include "fold-const.h"
      31                 :            : #include "tree-eh.h"
      32                 :            : #include "gimplify.h"
      33                 :            : #include "stor-layout.h"
      34                 :            : #include "demangle.h"
      35                 :            : #include "hash-set.h"
      36                 :            : #include "rtl.h"
      37                 :            : #include "tree-pass.h"
      38                 :            : #include "stringpool.h"
      39                 :            : #include "attribs.h"
      40                 :            : #include "target.h"
      41                 :            : 
      42                 :            : /* ----- Type related -----  */
      43                 :            : 
      44                 :            : /* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
      45                 :            :    useless type conversion, otherwise return false.
      46                 :            : 
      47                 :            :    This function implicitly defines the middle-end type system.  With
      48                 :            :    the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
      49                 :            :    holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
      50                 :            :    the following invariants shall be fulfilled:
      51                 :            : 
      52                 :            :      1) useless_type_conversion_p is transitive.
      53                 :            :         If a < b and b < c then a < c.
      54                 :            : 
      55                 :            :      2) useless_type_conversion_p is not symmetric.
      56                 :            :         From a < b does not follow a > b.
      57                 :            : 
      58                 :            :      3) Types define the available set of operations applicable to values.
      59                 :            :         A type conversion is useless if the operations for the target type
      60                 :            :         is a subset of the operations for the source type.  For example
      61                 :            :         casts to void* are useless, casts from void* are not (void* can't
      62                 :            :         be dereferenced or offsetted, but copied, hence its set of operations
      63                 :            :         is a strict subset of that of all other data pointer types).  Casts
      64                 :            :         to const T* are useless (can't be written to), casts from const T*
      65                 :            :         to T* are not.  */
      66                 :            : 
      67                 :            : bool
      68                 : 7340940000 : useless_type_conversion_p (tree outer_type, tree inner_type)
      69                 :            : {
      70                 :            :   /* Do the following before stripping toplevel qualifiers.  */
      71                 : 7341210000 :   if (POINTER_TYPE_P (inner_type)
      72                 : 1742010000 :       && POINTER_TYPE_P (outer_type))
      73                 :            :     {
      74                 :            :       /* Do not lose casts between pointers to different address spaces.  */
      75                 : 1729640000 :       if (TYPE_ADDR_SPACE (TREE_TYPE (outer_type))
      76                 : 1729640000 :           != TYPE_ADDR_SPACE (TREE_TYPE (inner_type)))
      77                 :            :         return false;
      78                 :            :       /* Do not lose casts to function pointer types.  */
      79                 : 1729640000 :       if ((TREE_CODE (TREE_TYPE (outer_type)) == FUNCTION_TYPE
      80                 : 1684560000 :            || TREE_CODE (TREE_TYPE (outer_type)) == METHOD_TYPE)
      81                 : 1734060000 :           && !(TREE_CODE (TREE_TYPE (inner_type)) == FUNCTION_TYPE
      82                 :    6232370 :                || TREE_CODE (TREE_TYPE (inner_type)) == METHOD_TYPE))
      83                 :            :         return false;
      84                 :            :     }
      85                 :            : 
      86                 :            :   /* From now on qualifiers on value types do not matter.  */
      87                 : 7339440000 :   inner_type = TYPE_MAIN_VARIANT (inner_type);
      88                 : 7339440000 :   outer_type = TYPE_MAIN_VARIANT (outer_type);
      89                 :            : 
      90                 : 7339440000 :   if (inner_type == outer_type)
      91                 :            :     return true;
      92                 :            : 
      93                 :            :   /* Changes in machine mode are never useless conversions because the RTL
      94                 :            :      middle-end expects explicit conversions between modes.  */
      95                 :  970957000 :   if (TYPE_MODE (inner_type) != TYPE_MODE (outer_type))
      96                 :            :     return false;
      97                 :            : 
      98                 :            :   /* If both the inner and outer types are integral types, then the
      99                 :            :      conversion is not necessary if they have the same mode and
     100                 :            :      signedness and precision, and both or neither are boolean.  */
     101                 :  425615000 :   if (INTEGRAL_TYPE_P (inner_type)
     102                 :   94453800 :       && INTEGRAL_TYPE_P (outer_type))
     103                 :            :     {
     104                 :            :       /* Preserve changes in signedness or precision.  */
     105                 :   87954100 :       if (TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type)
     106                 :   87954100 :           || TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
     107                 :            :         return false;
     108                 :            : 
     109                 :            :       /* Preserve conversions to/from BOOLEAN_TYPE if types are not
     110                 :            :          of precision one.  */
     111                 :   28597400 :       if (((TREE_CODE (inner_type) == BOOLEAN_TYPE)
     112                 :   28597400 :            != (TREE_CODE (outer_type) == BOOLEAN_TYPE))
     113                 :   28597400 :           && TYPE_PRECISION (outer_type) != 1)
     114                 :       1177 :         return false;
     115                 :            : 
     116                 :            :       /* We don't need to preserve changes in the types minimum or
     117                 :            :          maximum value in general as these do not generate code
     118                 :            :          unless the types precisions are different.  */
     119                 :            :       return true;
     120                 :            :     }
     121                 :            : 
     122                 :            :   /* Scalar floating point types with the same mode are compatible.  */
     123                 :  337661000 :   else if (SCALAR_FLOAT_TYPE_P (inner_type)
     124                 :      16504 :            && SCALAR_FLOAT_TYPE_P (outer_type))
     125                 :            :     return true;
     126                 :            : 
     127                 :            :   /* Fixed point types with the same mode are compatible.  */
     128                 :  337645000 :   else if (FIXED_POINT_TYPE_P (inner_type)
     129                 :          0 :            && FIXED_POINT_TYPE_P (outer_type))
     130                 :          0 :     return TYPE_SATURATING (inner_type) == TYPE_SATURATING (outer_type);
     131                 :            : 
     132                 :            :   /* We need to take special care recursing to pointed-to types.  */
     133                 :  337645000 :   else if (POINTER_TYPE_P (inner_type)
     134                 :  320275000 :            && POINTER_TYPE_P (outer_type))
     135                 :            :     {
     136                 :            :       /* We do not care for const qualification of the pointed-to types
     137                 :            :          as const qualification has no semantic value to the middle-end.  */
     138                 :            : 
     139                 :            :       /* Otherwise pointers/references are equivalent.  */
     140                 :            :       return true;
     141                 :            :     }
     142                 :            : 
     143                 :            :   /* Recurse for complex types.  */
     144                 :   26774400 :   else if (TREE_CODE (inner_type) == COMPLEX_TYPE
     145                 :      23754 :            && TREE_CODE (outer_type) == COMPLEX_TYPE)
     146                 :      23263 :     return useless_type_conversion_p (TREE_TYPE (outer_type),
     147                 :      23263 :                                       TREE_TYPE (inner_type));
     148                 :            : 
     149                 :            :   /* Recurse for vector types with the same number of subparts.  */
     150                 :   26751200 :   else if (TREE_CODE (inner_type) == VECTOR_TYPE
     151                 :    5786070 :            && TREE_CODE (outer_type) == VECTOR_TYPE)
     152                 :   11512200 :     return (known_eq (TYPE_VECTOR_SUBPARTS (inner_type),
     153                 :            :                       TYPE_VECTOR_SUBPARTS (outer_type))
     154                 :    5753870 :             && useless_type_conversion_p (TREE_TYPE (outer_type),
     155                 :    5753870 :                                           TREE_TYPE (inner_type))
     156                 :   11428000 :             && targetm.compatible_vector_types_p (inner_type, outer_type));
     157                 :            : 
     158                 :   20992800 :   else if (TREE_CODE (inner_type) == ARRAY_TYPE
     159                 :     445095 :            && TREE_CODE (outer_type) == ARRAY_TYPE)
     160                 :            :     {
     161                 :            :       /* Preserve various attributes.  */
     162                 :     373118 :       if (TYPE_REVERSE_STORAGE_ORDER (inner_type)
     163                 :     373118 :           != TYPE_REVERSE_STORAGE_ORDER (outer_type))
     164                 :            :         return false;
     165                 :     373070 :       if (TYPE_STRING_FLAG (inner_type) != TYPE_STRING_FLAG (outer_type))
     166                 :            :         return false;
     167                 :            : 
     168                 :            :       /* Conversions from array types with unknown extent to
     169                 :            :          array types with known extent are not useless.  */
     170                 :     340422 :       if (!TYPE_DOMAIN (inner_type) && TYPE_DOMAIN (outer_type))
     171                 :            :         return false;
     172                 :            : 
     173                 :            :       /* Nor are conversions from array types with non-constant size to
     174                 :            :          array types with constant size or to different size.  */
     175                 :     340367 :       if (TYPE_SIZE (outer_type)
     176                 :     328523 :           && TREE_CODE (TYPE_SIZE (outer_type)) == INTEGER_CST
     177                 :     653411 :           && (!TYPE_SIZE (inner_type)
     178                 :     312520 :               || TREE_CODE (TYPE_SIZE (inner_type)) != INTEGER_CST
     179                 :     312378 :               || !tree_int_cst_equal (TYPE_SIZE (outer_type),
     180                 :     312378 :                                       TYPE_SIZE (inner_type))))
     181                 :      37038 :         return false;
     182                 :            : 
     183                 :            :       /* Check conversions between arrays with partially known extents.
     184                 :            :          If the array min/max values are constant they have to match.
     185                 :            :          Otherwise allow conversions to unknown and variable extents.
     186                 :            :          In particular this declares conversions that may change the
     187                 :            :          mode to BLKmode as useless.  */
     188                 :     303329 :       if (TYPE_DOMAIN (inner_type)
     189                 :     303329 :           && TYPE_DOMAIN (outer_type)
     190                 :     606651 :           && TYPE_DOMAIN (inner_type) != TYPE_DOMAIN (outer_type))
     191                 :            :         {
     192                 :      74110 :           tree inner_min = TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type));
     193                 :      74110 :           tree outer_min = TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type));
     194                 :      74110 :           tree inner_max = TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type));
     195                 :      74110 :           tree outer_max = TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type));
     196                 :            : 
     197                 :            :           /* After gimplification a variable min/max value carries no
     198                 :            :              additional information compared to a NULL value.  All that
     199                 :            :              matters has been lowered to be part of the IL.  */
     200                 :      74110 :           if (inner_min && TREE_CODE (inner_min) != INTEGER_CST)
     201                 :          0 :             inner_min = NULL_TREE;
     202                 :      74110 :           if (outer_min && TREE_CODE (outer_min) != INTEGER_CST)
     203                 :          0 :             outer_min = NULL_TREE;
     204                 :      74110 :           if (inner_max && TREE_CODE (inner_max) != INTEGER_CST)
     205                 :      15277 :             inner_max = NULL_TREE;
     206                 :      74110 :           if (outer_max && TREE_CODE (outer_max) != INTEGER_CST)
     207                 :      15479 :             outer_max = NULL_TREE;
     208                 :            : 
     209                 :            :           /* Conversions NULL / variable <- cst are useless, but not
     210                 :            :              the other way around.  */
     211                 :      74110 :           if (outer_min
     212                 :      74110 :               && (!inner_min
     213                 :      74110 :                   || !tree_int_cst_equal (inner_min, outer_min)))
     214                 :       8911 :             return false;
     215                 :      65199 :           if (outer_max
     216                 :      65199 :               && (!inner_max
     217                 :      48993 :                   || !tree_int_cst_equal (inner_max, outer_max)))
     218                 :      48544 :             return false;
     219                 :            :         }
     220                 :            : 
     221                 :            :       /* Recurse on the element check.  */
     222                 :     245874 :       return useless_type_conversion_p (TREE_TYPE (outer_type),
     223                 :     245874 :                                         TREE_TYPE (inner_type));
     224                 :            :     }
     225                 :            : 
     226                 :   20619700 :   else if ((TREE_CODE (inner_type) == FUNCTION_TYPE
     227                 :   20619700 :             || TREE_CODE (inner_type) == METHOD_TYPE)
     228                 :      72549 :            && TREE_CODE (inner_type) == TREE_CODE (outer_type))
     229                 :            :     {
     230                 :      65748 :       tree outer_parm, inner_parm;
     231                 :            : 
     232                 :            :       /* If the return types are not compatible bail out.  */
     233                 :     131496 :       if (!useless_type_conversion_p (TREE_TYPE (outer_type),
     234                 :      65748 :                                       TREE_TYPE (inner_type)))
     235                 :            :         return false;
     236                 :            : 
     237                 :            :       /* Method types should belong to a compatible base class.  */
     238                 :      59925 :       if (TREE_CODE (inner_type) == METHOD_TYPE
     239                 :      66377 :           && !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type),
     240                 :       6452 :                                          TYPE_METHOD_BASETYPE (inner_type)))
     241                 :            :         return false;
     242                 :            : 
     243                 :            :       /* A conversion to an unprototyped argument list is ok.  */
     244                 :      57664 :       if (!prototype_p (outer_type))
     245                 :            :         return true;
     246                 :            : 
     247                 :            :       /* If the unqualified argument types are compatible the conversion
     248                 :            :          is useless.  */
     249                 :      65514 :       if (TYPE_ARG_TYPES (outer_type) == TYPE_ARG_TYPES (inner_type))
     250                 :            :         return true;
     251                 :            : 
     252                 :     171458 :       for (outer_parm = TYPE_ARG_TYPES (outer_type),
     253                 :     167267 :            inner_parm = TYPE_ARG_TYPES (inner_type);
     254                 :     167267 :            outer_parm && inner_parm;
     255                 :     111349 :            outer_parm = TREE_CHAIN (outer_parm),
     256                 :     111349 :            inner_parm = TREE_CHAIN (inner_parm))
     257                 :     229084 :         if (!useless_type_conversion_p
     258                 :     114542 :                (TYPE_MAIN_VARIANT (TREE_VALUE (outer_parm)),
     259                 :     114542 :                 TYPE_MAIN_VARIANT (TREE_VALUE (inner_parm))))
     260                 :            :           return false;
     261                 :            : 
     262                 :            :       /* If there is a mismatch in the number of arguments the functions
     263                 :            :          are not compatible.  */
     264                 :      52725 :       if (outer_parm || inner_parm)
     265                 :            :         return false;
     266                 :            : 
     267                 :            :       /* Defer to the target if necessary.  */
     268                 :      53410 :       if (TYPE_ATTRIBUTES (inner_type) || TYPE_ATTRIBUTES (outer_type))
     269                 :      39170 :         return comp_type_attributes (outer_type, inner_type) != 0;
     270                 :            : 
     271                 :            :       return true;
     272                 :            :     }
     273                 :            : 
     274                 :            :   /* For aggregates we rely on TYPE_CANONICAL exclusively and require
     275                 :            :      explicit conversions for types involving to be structurally
     276                 :            :      compared types.  */
     277                 :   20553900 :   else if (AGGREGATE_TYPE_P (inner_type)
     278                 :    4605490 :            && TREE_CODE (inner_type) == TREE_CODE (outer_type))
     279                 :    4046220 :     return TYPE_CANONICAL (inner_type)
     280                 :    4046220 :            && TYPE_CANONICAL (inner_type) == TYPE_CANONICAL (outer_type);
     281                 :            : 
     282                 :   16507700 :   else if (TREE_CODE (inner_type) == OFFSET_TYPE
     283                 :       7844 :            && TREE_CODE (outer_type) == OFFSET_TYPE)
     284                 :       2884 :     return useless_type_conversion_p (TREE_TYPE (outer_type),
     285                 :       1442 :                                       TREE_TYPE (inner_type))
     286                 :       2820 :            && useless_type_conversion_p
     287                 :       1378 :                 (TYPE_OFFSET_BASETYPE (outer_type),
     288                 :       1378 :                  TYPE_OFFSET_BASETYPE (inner_type));
     289                 :            : 
     290                 :            :   return false;
     291                 :            : }
     292                 :            : 
     293                 :            : 
     294                 :            : /* ----- Decl related -----  */
     295                 :            : 
     296                 :            : /* Set sequence SEQ to be the GIMPLE body for function FN.  */
     297                 :            : 
     298                 :            : void
     299                 :   55362800 : gimple_set_body (tree fndecl, gimple_seq seq)
     300                 :            : {
     301                 :   55362800 :   struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
     302                 :   55362800 :   if (fn == NULL)
     303                 :            :     {
     304                 :            :       /* If FNDECL still does not have a function structure associated
     305                 :            :          with it, then it does not make sense for it to receive a
     306                 :            :          GIMPLE body.  */
     307                 :          0 :       gcc_assert (seq == NULL);
     308                 :            :     }
     309                 :            :   else
     310                 :   55362800 :     fn->gimple_body = seq;
     311                 :   55362800 : }
     312                 :            : 
     313                 :            : 
     314                 :            : /* Return the body of GIMPLE statements for function FN.  After the
     315                 :            :    CFG pass, the function body doesn't exist anymore because it has
     316                 :            :    been split up into basic blocks.  In this case, it returns
     317                 :            :    NULL.  */
     318                 :            : 
     319                 :            : gimple_seq
     320                 :  311814000 : gimple_body (tree fndecl)
     321                 :            : {
     322                 :  311814000 :   struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
     323                 :  311814000 :   return fn ? fn->gimple_body : NULL;
     324                 :            : }
     325                 :            : 
     326                 :            : /* Return true when FNDECL has Gimple body either in unlowered
     327                 :            :    or CFG form.  */
     328                 :            : bool
     329                 :  290948000 : gimple_has_body_p (tree fndecl)
     330                 :            : {
     331                 :  290948000 :   struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
     332                 :  290948000 :   return (gimple_body (fndecl) || (fn && fn->cfg && !(fn->curr_properties & PROP_rtl)));
     333                 :            : }
     334                 :            : 
     335                 :            : /* Return a printable name for symbol DECL.  */
     336                 :            : 
     337                 :            : const char *
     338                 :      14591 : gimple_decl_printable_name (tree decl, int verbosity)
     339                 :            : {
     340                 :      14591 :   if (!DECL_NAME (decl))
     341                 :            :     return NULL;
     342                 :            : 
     343                 :      14591 :   if (HAS_DECL_ASSEMBLER_NAME_P (decl) && DECL_ASSEMBLER_NAME_SET_P (decl))
     344                 :            :     {
     345                 :      14535 :       int dmgl_opts = DMGL_NO_OPTS;
     346                 :            : 
     347                 :      14535 :       if (verbosity >= 2)
     348                 :            :         {
     349                 :       1820 :           dmgl_opts = DMGL_VERBOSE
     350                 :            :                       | DMGL_ANSI
     351                 :            :                       | DMGL_GNU_V3
     352                 :            :                       | DMGL_RET_POSTFIX;
     353                 :       1820 :           if (TREE_CODE (decl) == FUNCTION_DECL)
     354                 :       1751 :             dmgl_opts |= DMGL_PARAMS;
     355                 :            :         }
     356                 :            : 
     357                 :      14535 :       const char *mangled_str
     358                 :      14535 :         = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME_RAW (decl));
     359                 :      14535 :       const char *str = cplus_demangle_v3 (mangled_str, dmgl_opts);
     360                 :      28799 :       return str ? str : mangled_str;
     361                 :            :     }
     362                 :            : 
     363                 :         56 :   return IDENTIFIER_POINTER (DECL_NAME (decl));
     364                 :            : }
     365                 :            : 
     366                 :            : 
     367                 :            : /* Create a new VAR_DECL and copy information from VAR to it.  */
     368                 :            : 
     369                 :            : tree
     370                 :    1095420 : copy_var_decl (tree var, tree name, tree type)
     371                 :            : {
     372                 :    1095420 :   tree copy = build_decl (DECL_SOURCE_LOCATION (var), VAR_DECL, name, type);
     373                 :            : 
     374                 :    1095420 :   TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (var);
     375                 :    1095420 :   TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (var);
     376                 :    1095420 :   DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (var);
     377                 :    1095420 :   DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (var);
     378                 :    1095420 :   DECL_IGNORED_P (copy) = DECL_IGNORED_P (var);
     379                 :    1095420 :   DECL_CONTEXT (copy) = DECL_CONTEXT (var);
     380                 :    1095420 :   TREE_NO_WARNING (copy) = TREE_NO_WARNING (var);
     381                 :    1095420 :   TREE_USED (copy) = 1;
     382                 :    1095420 :   DECL_SEEN_IN_BIND_EXPR_P (copy) = 1;
     383                 :    1095420 :   DECL_ATTRIBUTES (copy) = DECL_ATTRIBUTES (var);
     384                 :    1095420 :   if (DECL_USER_ALIGN (var))
     385                 :            :     {
     386                 :         49 :       SET_DECL_ALIGN (copy, DECL_ALIGN (var));
     387                 :         49 :       DECL_USER_ALIGN (copy) = 1;
     388                 :            :     }
     389                 :            : 
     390                 :    1095420 :   return copy;
     391                 :            : }
     392                 :            : 
     393                 :            : /* Strip off a legitimate source ending from the input string NAME of
     394                 :            :    length LEN.  Rather than having to know the names used by all of
     395                 :            :    our front ends, we strip off an ending of a period followed by
     396                 :            :    up to four characters.  (like ".cpp".)  */
     397                 :            : 
     398                 :            : static inline void
     399                 :   15620700 : remove_suffix (char *name, int len)
     400                 :            : {
     401                 :   15620700 :   int i;
     402                 :            : 
     403                 :   56332800 :   for (i = 2;  i < 7 && len > i;  i++)
     404                 :            :     {
     405                 :   41485100 :       if (name[len - i] == '.')
     406                 :            :         {
     407                 :     773090 :           name[len - i] = '\0';
     408                 :     773090 :           break;
     409                 :            :         }
     410                 :            :     }
     411                 :            : }
     412                 :            : 
     413                 :            : /* Create a new temporary name with PREFIX.  Return an identifier.  */
     414                 :            : 
     415                 :            : static GTY(()) unsigned int tmp_var_id_num;
     416                 :            : 
     417                 :            : tree
     418                 :   15620700 : create_tmp_var_name (const char *prefix)
     419                 :            : {
     420                 :   15620700 :   char *tmp_name;
     421                 :            : 
     422                 :   15620700 :   if (prefix)
     423                 :            :     {
     424                 :   15620700 :       char *preftmp = ASTRDUP (prefix);
     425                 :            : 
     426                 :   15620700 :       remove_suffix (preftmp, strlen (preftmp));
     427                 :   15620700 :       clean_symbol_name (preftmp);
     428                 :            : 
     429                 :   15620700 :       prefix = preftmp;
     430                 :            :     }
     431                 :            : 
     432                 :   15620700 :   ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++);
     433                 :   15620700 :   return get_identifier (tmp_name);
     434                 :            : }
     435                 :            : 
     436                 :            : /* Create a new temporary variable declaration of type TYPE.
     437                 :            :    Do NOT push it into the current binding.  */
     438                 :            : 
     439                 :            : tree
     440                 :   17966400 : create_tmp_var_raw (tree type, const char *prefix)
     441                 :            : {
     442                 :   17966400 :   tree tmp_var;
     443                 :            : 
     444                 :   31275700 :   tmp_var = build_decl (input_location,
     445                 :   13309300 :                         VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL,
     446                 :            :                         type);
     447                 :            : 
     448                 :            :   /* The variable was declared by the compiler.  */
     449                 :   17966400 :   DECL_ARTIFICIAL (tmp_var) = 1;
     450                 :            :   /* And we don't want debug info for it.  */
     451                 :   17966400 :   DECL_IGNORED_P (tmp_var) = 1;
     452                 :            :   /* And we don't want even the fancy names of those printed in
     453                 :            :      -fdump-final-insns= dumps.  */
     454                 :   17966400 :   DECL_NAMELESS (tmp_var) = 1;
     455                 :            : 
     456                 :            :   /* Make the variable writable.  */
     457                 :   17966400 :   TREE_READONLY (tmp_var) = 0;
     458                 :            : 
     459                 :   17966400 :   DECL_EXTERNAL (tmp_var) = 0;
     460                 :   17966400 :   TREE_STATIC (tmp_var) = 0;
     461                 :   17966400 :   TREE_USED (tmp_var) = 1;
     462                 :            : 
     463                 :   17966400 :   return tmp_var;
     464                 :            : }
     465                 :            : 
     466                 :            : /* Create a new temporary variable declaration of type TYPE.  DO push the
     467                 :            :    variable into the current binding.  Further, assume that this is called
     468                 :            :    only from gimplification or optimization, at which point the creation of
     469                 :            :    certain types are bugs.  */
     470                 :            : 
     471                 :            : tree
     472                 :   10940200 : create_tmp_var (tree type, const char *prefix)
     473                 :            : {
     474                 :   10940200 :   tree tmp_var;
     475                 :            : 
     476                 :            :   /* We don't allow types that are addressable (meaning we can't make copies),
     477                 :            :      or incomplete.  We also used to reject every variable size objects here,
     478                 :            :      but now support those for which a constant upper bound can be obtained.
     479                 :            :      The processing for variable sizes is performed in gimple_add_tmp_var,
     480                 :            :      point at which it really matters and possibly reached via paths not going
     481                 :            :      through this function, e.g. after direct calls to create_tmp_var_raw.  */
     482                 :   21880400 :   gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type));
     483                 :            : 
     484                 :   10940200 :   tmp_var = create_tmp_var_raw (type, prefix);
     485                 :   10940200 :   gimple_add_tmp_var (tmp_var);
     486                 :   10940200 :   return tmp_var;
     487                 :            : }
     488                 :            : 
     489                 :            : /* Create a new temporary variable declaration of type TYPE by calling
     490                 :            :    create_tmp_var and if TYPE is a vector or a complex number, mark the new
     491                 :            :    temporary as gimple register.  */
     492                 :            : 
     493                 :            : tree
     494                 :    1579720 : create_tmp_reg (tree type, const char *prefix)
     495                 :            : {
     496                 :    1579720 :   tree tmp;
     497                 :            : 
     498                 :    1579720 :   tmp = create_tmp_var (type, prefix);
     499                 :    1579720 :   if (TREE_CODE (type) == COMPLEX_TYPE
     500                 :    1579720 :       || TREE_CODE (type) == VECTOR_TYPE)
     501                 :     342023 :     DECL_GIMPLE_REG_P (tmp) = 1;
     502                 :            : 
     503                 :    1579720 :   return tmp;
     504                 :            : }
     505                 :            : 
     506                 :            : /* Create a new temporary variable declaration of type TYPE by calling
     507                 :            :    create_tmp_var and if TYPE is a vector or a complex number, mark the new
     508                 :            :    temporary as gimple register.  */
     509                 :            : 
     510                 :            : tree
     511                 :       4969 : create_tmp_reg_fn (struct function *fn, tree type, const char *prefix)
     512                 :            : {
     513                 :       4969 :   tree tmp;
     514                 :            : 
     515                 :       4969 :   tmp = create_tmp_var_raw (type, prefix);
     516                 :       4969 :   gimple_add_tmp_var_fn (fn, tmp);
     517                 :       4969 :   if (TREE_CODE (type) == COMPLEX_TYPE
     518                 :       4969 :       || TREE_CODE (type) == VECTOR_TYPE)
     519                 :          0 :     DECL_GIMPLE_REG_P (tmp) = 1;
     520                 :            : 
     521                 :       4969 :   return tmp;
     522                 :            : }
     523                 :            : 
     524                 :            : 
     525                 :            : /* ----- Expression related -----  */
     526                 :            : 
     527                 :            : /* Extract the operands and code for expression EXPR into *SUBCODE_P,
     528                 :            :    *OP1_P, *OP2_P and *OP3_P respectively.  */
     529                 :            : 
     530                 :            : void
     531                 :   91996200 : extract_ops_from_tree (tree expr, enum tree_code *subcode_p, tree *op1_p,
     532                 :            :                        tree *op2_p, tree *op3_p)
     533                 :            : {
     534                 :   91996200 :   *subcode_p = TREE_CODE (expr);
     535                 :   91996200 :   switch (get_gimple_rhs_class (*subcode_p))
     536                 :            :     {
     537                 :      52198 :     case GIMPLE_TERNARY_RHS:
     538                 :      52198 :       {
     539                 :      52198 :         *op1_p = TREE_OPERAND (expr, 0);
     540                 :      52198 :         *op2_p = TREE_OPERAND (expr, 1);
     541                 :      52198 :         *op3_p = TREE_OPERAND (expr, 2);
     542                 :      52198 :         break;
     543                 :            :       }
     544                 :   12109300 :     case GIMPLE_BINARY_RHS:
     545                 :   12109300 :       {
     546                 :   12109300 :         *op1_p = TREE_OPERAND (expr, 0);
     547                 :   12109300 :         *op2_p = TREE_OPERAND (expr, 1);
     548                 :   12109300 :         *op3_p = NULL_TREE;
     549                 :   12109300 :         break;
     550                 :            :       }
     551                 :    5972630 :     case GIMPLE_UNARY_RHS:
     552                 :    5972630 :       {
     553                 :    5972630 :         *op1_p = TREE_OPERAND (expr, 0);
     554                 :    5972630 :         *op2_p = NULL_TREE;
     555                 :    5972630 :         *op3_p = NULL_TREE;
     556                 :    5972630 :         break;
     557                 :            :       }
     558                 :   73862100 :     case GIMPLE_SINGLE_RHS:
     559                 :   73862100 :       {
     560                 :   73862100 :         *op1_p = expr;
     561                 :   73862100 :         *op2_p = NULL_TREE;
     562                 :   73862100 :         *op3_p = NULL_TREE;
     563                 :   73862100 :         break;
     564                 :            :       }
     565                 :          0 :     default:
     566                 :          0 :       gcc_unreachable ();
     567                 :            :     }
     568                 :   91996200 : }
     569                 :            : 
     570                 :            : /* Extract operands for a GIMPLE_COND statement out of COND_EXPR tree COND.  */
     571                 :            : 
     572                 :            : void
     573                 :    4210140 : gimple_cond_get_ops_from_tree (tree cond, enum tree_code *code_p,
     574                 :            :                                tree *lhs_p, tree *rhs_p)
     575                 :            : {
     576                 :    4210140 :   gcc_assert (COMPARISON_CLASS_P (cond)
     577                 :            :               || TREE_CODE (cond) == TRUTH_NOT_EXPR
     578                 :            :               || is_gimple_min_invariant (cond)
     579                 :            :               || SSA_VAR_P (cond));
     580                 :    4210140 :   gcc_checking_assert (!tree_could_throw_p (cond));
     581                 :            : 
     582                 :    4210140 :   extract_ops_from_tree (cond, code_p, lhs_p, rhs_p);
     583                 :            : 
     584                 :            :   /* Canonicalize conditionals of the form 'if (!VAL)'.  */
     585                 :    4210140 :   if (*code_p == TRUTH_NOT_EXPR)
     586                 :            :     {
     587                 :          0 :       *code_p = EQ_EXPR;
     588                 :          0 :       gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
     589                 :          0 :       *rhs_p = build_zero_cst (TREE_TYPE (*lhs_p));
     590                 :            :     }
     591                 :            :   /* Canonicalize conditionals of the form 'if (VAL)'  */
     592                 :    4210140 :   else if (TREE_CODE_CLASS (*code_p) != tcc_comparison)
     593                 :            :     {
     594                 :    1069440 :       *code_p = NE_EXPR;
     595                 :    1069440 :       gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
     596                 :    1069440 :       *rhs_p = build_zero_cst (TREE_TYPE (*lhs_p));
     597                 :            :     }
     598                 :    4210140 : }
     599                 :            : 
     600                 :            : /*  Return true if T is a valid LHS for a GIMPLE assignment expression.  */
     601                 :            : 
     602                 :            : bool
     603                 :  357501000 : is_gimple_lvalue (tree t)
     604                 :            : {
     605                 :  357501000 :   return (is_gimple_addressable (t)
     606                 :    7487520 :           || TREE_CODE (t) == WITH_SIZE_EXPR
     607                 :            :           /* These are complex lvalues, but don't have addresses, so they
     608                 :            :              go here.  */
     609                 :  364967000 :           || TREE_CODE (t) == BIT_FIELD_REF);
     610                 :            : }
     611                 :            : 
     612                 :            : /* Helper for is_gimple_condexpr and is_gimple_condexpr_for_cond.  */
     613                 :            : 
     614                 :            : static bool
     615                 :    8793210 : is_gimple_condexpr_1 (tree t, bool allow_traps)
     616                 :            : {
     617                 :    8793210 :   return (is_gimple_val (t) || (COMPARISON_CLASS_P (t)
     618                 :    6630450 :                                 && (allow_traps || !tree_could_throw_p (t))
     619                 :    6625660 :                                 && is_gimple_val (TREE_OPERAND (t, 0))
     620                 :    5662490 :                                 && is_gimple_val (TREE_OPERAND (t, 1))));
     621                 :            : }
     622                 :            : 
     623                 :            : /* Return true if T is a GIMPLE condition.  */
     624                 :            : 
     625                 :            : bool
     626                 :    4354230 : is_gimple_condexpr (tree t)
     627                 :            : {
     628                 :    4354230 :   return is_gimple_condexpr_1 (t, true);
     629                 :            : }
     630                 :            : 
     631                 :            : /* Like is_gimple_condexpr, but does not allow T to trap.  */
     632                 :            : 
     633                 :            : bool
     634                 :    4438990 : is_gimple_condexpr_for_cond (tree t)
     635                 :            : {
     636                 :    4438990 :   return is_gimple_condexpr_1 (t, false);
     637                 :            : }
     638                 :            : 
     639                 :            : /* Return true if T is a gimple address.  */
     640                 :            : 
     641                 :            : bool
     642                 :          0 : is_gimple_address (const_tree t)
     643                 :            : {
     644                 :          0 :   tree op;
     645                 :            : 
     646                 :          0 :   if (TREE_CODE (t) != ADDR_EXPR)
     647                 :            :     return false;
     648                 :            : 
     649                 :          0 :   op = TREE_OPERAND (t, 0);
     650                 :          0 :   while (handled_component_p (op))
     651                 :            :     {
     652                 :          0 :       if ((TREE_CODE (op) == ARRAY_REF
     653                 :          0 :            || TREE_CODE (op) == ARRAY_RANGE_REF)
     654                 :          0 :           && !is_gimple_val (TREE_OPERAND (op, 1)))
     655                 :            :             return false;
     656                 :            : 
     657                 :          0 :       op = TREE_OPERAND (op, 0);
     658                 :            :     }
     659                 :            : 
     660                 :          0 :   if (CONSTANT_CLASS_P (op)
     661                 :          0 :       || TREE_CODE (op) == TARGET_MEM_REF
     662                 :          0 :       || TREE_CODE (op) == MEM_REF)
     663                 :            :     return true;
     664                 :            : 
     665                 :          0 :   switch (TREE_CODE (op))
     666                 :            :     {
     667                 :            :     case PARM_DECL:
     668                 :            :     case RESULT_DECL:
     669                 :            :     case LABEL_DECL:
     670                 :            :     case FUNCTION_DECL:
     671                 :            :     case VAR_DECL:
     672                 :            :     case CONST_DECL:
     673                 :            :       return true;
     674                 :            : 
     675                 :          0 :     default:
     676                 :          0 :       return false;
     677                 :            :     }
     678                 :            : }
     679                 :            : 
     680                 :            : /* Return true if T is a gimple invariant address.  */
     681                 :            : 
     682                 :            : bool
     683                 : 2882210000 : is_gimple_invariant_address (const_tree t)
     684                 :            : {
     685                 : 2882210000 :   const_tree op;
     686                 :            : 
     687                 : 2882210000 :   if (TREE_CODE (t) != ADDR_EXPR)
     688                 :            :     return false;
     689                 :            : 
     690                 : 2882210000 :   op = strip_invariant_refs (TREE_OPERAND (t, 0));
     691                 : 2882210000 :   if (!op)
     692                 :            :     return false;
     693                 :            : 
     694                 : 2876660000 :   if (TREE_CODE (op) == MEM_REF)
     695                 :            :     {
     696                 :  238288000 :       const_tree op0 = TREE_OPERAND (op, 0);
     697                 :  238288000 :       return (TREE_CODE (op0) == ADDR_EXPR
     698                 :  238288000 :               && (CONSTANT_CLASS_P (TREE_OPERAND (op0, 0))
     699                 :   70658200 :                   || decl_address_invariant_p (TREE_OPERAND (op0, 0))));
     700                 :            :     }
     701                 :            : 
     702                 : 2638370000 :   return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
     703                 :            : }
     704                 :            : 
     705                 :            : /* Return true if T is a gimple invariant address at IPA level
     706                 :            :    (so addresses of variables on stack are not allowed).  */
     707                 :            : 
     708                 :            : bool
     709                 :     935328 : is_gimple_ip_invariant_address (const_tree t)
     710                 :            : {
     711                 :     935328 :   const_tree op;
     712                 :            : 
     713                 :     935328 :   if (TREE_CODE (t) != ADDR_EXPR)
     714                 :            :     return false;
     715                 :            : 
     716                 :     935328 :   op = strip_invariant_refs (TREE_OPERAND (t, 0));
     717                 :     935328 :   if (!op)
     718                 :            :     return false;
     719                 :            : 
     720                 :     934805 :   if (TREE_CODE (op) == MEM_REF)
     721                 :            :     {
     722                 :      47554 :       const_tree op0 = TREE_OPERAND (op, 0);
     723                 :      47554 :       return (TREE_CODE (op0) == ADDR_EXPR
     724                 :      47554 :               && (CONSTANT_CLASS_P (TREE_OPERAND (op0, 0))
     725                 :      36870 :                   || decl_address_ip_invariant_p (TREE_OPERAND (op0, 0))));
     726                 :            :     }
     727                 :            : 
     728                 :     887251 :   return CONSTANT_CLASS_P (op) || decl_address_ip_invariant_p (op);
     729                 :            : }
     730                 :            : 
     731                 :            : /* Return true if T is a GIMPLE minimal invariant.  It's a restricted
     732                 :            :    form of function invariant.  */
     733                 :            : 
     734                 :            : bool
     735                 :13801800000 : is_gimple_min_invariant (const_tree t)
     736                 :            : {
     737                 :13801800000 :   if (TREE_CODE (t) == ADDR_EXPR)
     738                 : 2881300000 :     return is_gimple_invariant_address (t);
     739                 :            : 
     740                 :10920500000 :   return is_gimple_constant (t);
     741                 :            : }
     742                 :            : 
     743                 :            : /* Return true if T is a GIMPLE interprocedural invariant.  It's a restricted
     744                 :            :    form of gimple minimal invariant.  */
     745                 :            : 
     746                 :            : bool
     747                 :   15043100 : is_gimple_ip_invariant (const_tree t)
     748                 :            : {
     749                 :   15043100 :   if (TREE_CODE (t) == ADDR_EXPR)
     750                 :     935115 :     return is_gimple_ip_invariant_address (t);
     751                 :            : 
     752                 :   14108000 :   return is_gimple_constant (t);
     753                 :            : }
     754                 :            : 
     755                 :            : /* Return true if T is a non-aggregate register variable.  */
     756                 :            : 
     757                 :            : bool
     758                 :21651800000 : is_gimple_reg (tree t)
     759                 :            : {
     760                 :38557800000 :   if (virtual_operand_p (t))
     761                 :            :     return false;
     762                 :            : 
     763                 :21422000000 :   if (TREE_CODE (t) == SSA_NAME)
     764                 :            :     return true;
     765                 :            : 
     766                 : 6927740000 :   if (!is_gimple_variable (t))
     767                 :            :     return false;
     768                 :            : 
     769                 : 2414820000 :   if (!is_gimple_reg_type (TREE_TYPE (t)))
     770                 :            :     return false;
     771                 :            : 
     772                 :            :   /* A volatile decl is not acceptable because we can't reuse it as
     773                 :            :      needed.  We need to copy it into a temp first.  */
     774                 : 1319020000 :   if (TREE_THIS_VOLATILE (t))
     775                 :            :     return false;
     776                 :            : 
     777                 :            :   /* We define "registers" as things that can be renamed as needed,
     778                 :            :      which with our infrastructure does not apply to memory.  */
     779                 : 1123170000 :   if (needs_to_live_in_memory (t))
     780                 :            :     return false;
     781                 :            : 
     782                 :            :   /* Hard register variables are an interesting case.  For those that
     783                 :            :      are call-clobbered, we don't know where all the calls are, since
     784                 :            :      we don't (want to) take into account which operations will turn
     785                 :            :      into libcalls at the rtl level.  For those that are call-saved,
     786                 :            :      we don't currently model the fact that calls may in fact change
     787                 :            :      global hard registers, nor do we examine ASM_CLOBBERS at the tree
     788                 :            :      level, and so miss variable changes that might imply.  All around,
     789                 :            :      it seems safest to not do too much optimization with these at the
     790                 :            :      tree level at all.  We'll have to rely on the rtl optimizers to
     791                 :            :      clean this up, as there we've got all the appropriate bits exposed.  */
     792                 :  691289000 :   if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
     793                 :            :     return false;
     794                 :            : 
     795                 :            :   /* Complex and vector values must have been put into SSA-like form.
     796                 :            :      That is, no assignments to the individual components.  */
     797                 :  690541000 :   if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
     798                 :  690541000 :       || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
     799                 :   12453500 :     return DECL_GIMPLE_REG_P (t);
     800                 :            : 
     801                 :            :   return true;
     802                 :            : }
     803                 :            : 
     804                 :            : 
     805                 :            : /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant.  */
     806                 :            : 
     807                 :            : bool
     808                 : 5489050000 : is_gimple_val (tree t)
     809                 :            : {
     810                 :            :   /* Make loads from volatiles and memory vars explicit.  */
     811                 : 8307010000 :   if (is_gimple_variable (t)
     812                 : 3032010000 :       && is_gimple_reg_type (TREE_TYPE (t))
     813                 : 3018850000 :       && !is_gimple_reg (t))
     814                 :            :     return false;
     815                 :            : 
     816                 : 7939920000 :   return (is_gimple_variable (t) || is_gimple_min_invariant (t));
     817                 :            : }
     818                 :            : 
     819                 :            : /* Similarly, but accept hard registers as inputs to asm statements.  */
     820                 :            : 
     821                 :            : bool
     822                 :      42149 : is_gimple_asm_val (tree t)
     823                 :            : {
     824                 :      42149 :   if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
     825                 :            :     return true;
     826                 :            : 
     827                 :      41487 :   return is_gimple_val (t);
     828                 :            : }
     829                 :            : 
     830                 :            : /* Return true if T is a GIMPLE minimal lvalue.  */
     831                 :            : 
     832                 :            : bool
     833                 :   19648800 : is_gimple_min_lval (tree t)
     834                 :            : {
     835                 :   19648800 :   if (!(t = CONST_CAST_TREE (strip_invariant_refs (t))))
     836                 :            :     return false;
     837                 :   19648700 :   return (is_gimple_id (t) || TREE_CODE (t) == MEM_REF);
     838                 :            : }
     839                 :            : 
     840                 :            : /* Return true if T is a valid function operand of a CALL_EXPR.  */
     841                 :            : 
     842                 :            : bool
     843                 :  584125000 : is_gimple_call_addr (tree t)
     844                 :            : {
     845                 :  584125000 :   return (TREE_CODE (t) == OBJ_TYPE_REF || is_gimple_val (t));
     846                 :            : }
     847                 :            : 
     848                 :            : /* Return true if T is a valid address operand of a MEM_REF.  */
     849                 :            : 
     850                 :            : bool
     851                 :  773875000 : is_gimple_mem_ref_addr (tree t)
     852                 :            : {
     853                 :  773875000 :   return (is_gimple_reg (t)
     854                 :  205048000 :           || TREE_CODE (t) == INTEGER_CST
     855                 :  978578000 :           || (TREE_CODE (t) == ADDR_EXPR
     856                 :  203467000 :               && (CONSTANT_CLASS_P (TREE_OPERAND (t, 0))
     857                 :  202596000 :                   || decl_address_invariant_p (TREE_OPERAND (t, 0)))));
     858                 :            : }
     859                 :            : 
     860                 :            : /* Hold trees marked addressable during expand.  */
     861                 :            : 
     862                 :            : static hash_set<tree> *mark_addressable_queue;
     863                 :            : 
     864                 :            : /* Mark X as addressable or queue it up if called during expand.  We
     865                 :            :    don't want to apply it immediately during expand because decls are
     866                 :            :    made addressable at that point due to RTL-only concerns, such as
     867                 :            :    uses of memcpy for block moves, and TREE_ADDRESSABLE changes
     868                 :            :    is_gimple_reg, which might make it seem like a variable that used
     869                 :            :    to be a gimple_reg shouldn't have been an SSA name.  So we queue up
     870                 :            :    this flag setting and only apply it when we're done with GIMPLE and
     871                 :            :    only RTL issues matter.  */
     872                 :            : 
     873                 :            : static void
     874                 :    6730230 : mark_addressable_1 (tree x)
     875                 :            : {
     876                 :    6730230 :   if (!currently_expanding_to_rtl)
     877                 :            :     {
     878                 :    6724520 :       TREE_ADDRESSABLE (x) = 1;
     879                 :    6724520 :       return;
     880                 :            :     }
     881                 :            : 
     882                 :       5718 :   if (!mark_addressable_queue)
     883                 :       2224 :     mark_addressable_queue = new hash_set<tree>();
     884                 :       5718 :   mark_addressable_queue->add (x);
     885                 :            : }
     886                 :            : 
     887                 :            : /* Adaptor for mark_addressable_1 for use in hash_set traversal.  */
     888                 :            : 
     889                 :            : bool
     890                 :       3870 : mark_addressable_2 (tree const &x, void * ATTRIBUTE_UNUSED = NULL)
     891                 :            : {
     892                 :       3870 :   mark_addressable_1 (x);
     893                 :       3870 :   return false;
     894                 :            : }
     895                 :            : 
     896                 :            : /* Mark all queued trees as addressable, and empty the queue.  To be
     897                 :            :    called right after clearing CURRENTLY_EXPANDING_TO_RTL.  */
     898                 :            : 
     899                 :            : void
     900                 :     943374 : flush_mark_addressable_queue ()
     901                 :            : {
     902                 :     943374 :   gcc_assert (!currently_expanding_to_rtl);
     903                 :     943374 :   if (mark_addressable_queue)
     904                 :            :     {
     905                 :       2224 :       mark_addressable_queue->traverse<void*, mark_addressable_2> (NULL);
     906                 :       4448 :       delete mark_addressable_queue;
     907                 :       2224 :       mark_addressable_queue = NULL;
     908                 :            :     }
     909                 :     943374 : }
     910                 :            : 
     911                 :            : /* Mark X addressable.  Unlike the langhook we expect X to be in gimple
     912                 :            :    form and we don't do any syntax checking.  */
     913                 :            : 
     914                 :            : void
     915                 :   21039600 : mark_addressable (tree x)
     916                 :            : {
     917                 :   24485600 :   while (handled_component_p (x))
     918                 :    3446050 :     x = TREE_OPERAND (x, 0);
     919                 :   21039600 :   if (TREE_CODE (x) == MEM_REF
     920                 :   21039600 :       && TREE_CODE (TREE_OPERAND (x, 0)) == ADDR_EXPR)
     921                 :       6349 :     x = TREE_OPERAND (TREE_OPERAND (x, 0), 0);
     922                 :   21039600 :   if (!VAR_P (x)
     923                 :   14601500 :       && TREE_CODE (x) != PARM_DECL
     924                 :   14322200 :       && TREE_CODE (x) != RESULT_DECL)
     925                 :            :     return;
     926                 :    6726060 :   mark_addressable_1 (x);
     927                 :            : 
     928                 :            :   /* Also mark the artificial SSA_NAME that points to the partition of X.  */
     929                 :    6726060 :   if (TREE_CODE (x) == VAR_DECL
     930                 :    6438060 :       && !DECL_EXTERNAL (x)
     931                 :    5470750 :       && !TREE_STATIC (x)
     932                 :    3176140 :       && cfun->gimple_df != NULL
     933                 :    9868180 :       && cfun->gimple_df->decls_to_pointers != NULL)
     934                 :            :     {
     935                 :        947 :       tree *namep = cfun->gimple_df->decls_to_pointers->get (x);
     936                 :        308 :       if (namep)
     937                 :        308 :         mark_addressable_1 (*namep);
     938                 :            :     }
     939                 :            : }
     940                 :            : 
     941                 :            : /* Returns true iff T is a valid RHS for an assignment to a renamed
     942                 :            :    user -- or front-end generated artificial -- variable.  */
     943                 :            : 
     944                 :            : bool
     945                 :     280628 : is_gimple_reg_rhs (tree t)
     946                 :            : {
     947                 :     280628 :   return get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS;
     948                 :            : }
     949                 :            : 
     950                 :            : #include "gt-gimple-expr.h"

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.