LCOV - code coverage report
Current view: top level - gcc/cp - friend.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 88.1 % 252 222
Test Date: 2024-03-23 14:05:01 Functions: 83.3 % 6 5
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Help friends in C++.
       2                 :             :    Copyright (C) 1997-2024 Free Software Foundation, Inc.
       3                 :             : 
       4                 :             : This file is part of GCC.
       5                 :             : 
       6                 :             : GCC is free software; you can redistribute it and/or modify
       7                 :             : it under the terms of the GNU General Public License as published by
       8                 :             : the Free Software Foundation; either version 3, or (at your option)
       9                 :             : any later version.
      10                 :             : 
      11                 :             : GCC is distributed in the hope that it will be useful,
      12                 :             : but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :             : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 :             : GNU General Public License for more details.
      15                 :             : 
      16                 :             : You should have received a copy of the GNU General Public License
      17                 :             : along with GCC; see the file COPYING3.  If not see
      18                 :             : <http://www.gnu.org/licenses/>.  */
      19                 :             : 
      20                 :             : #include "config.h"
      21                 :             : #include "system.h"
      22                 :             : #include "coretypes.h"
      23                 :             : #include "cp-tree.h"
      24                 :             : 
      25                 :             : /* Friend data structures are described in cp-tree.h.  */
      26                 :             : 
      27                 :             : 
      28                 :             : /* The GLOBAL_FRIEND scope (functions, classes, or templates) is
      29                 :             :    regarded as a friend of every class.  This is only used by libcc1,
      30                 :             :    to enable GDB's code snippets to access private members without
      31                 :             :    disabling access control in general, which could cause different
      32                 :             :    template overload resolution results when accessibility matters
      33                 :             :    (e.g. tests for an accessible member).  */
      34                 :             : 
      35                 :             : static GTY(()) tree global_friend;
      36                 :             : 
      37                 :             : /* Set the GLOBAL_FRIEND for this compilation session.  It might be
      38                 :             :    set multiple times, but always to the same scope.  */
      39                 :             : 
      40                 :             : void
      41                 :           0 : set_global_friend (tree scope)
      42                 :             : {
      43                 :           0 :   gcc_checking_assert (scope != NULL_TREE);
      44                 :           0 :   gcc_assert (!global_friend || global_friend == scope);
      45                 :           0 :   global_friend = scope;
      46                 :           0 : }
      47                 :             : 
      48                 :             : /* Return TRUE if SCOPE is the global friend.  */
      49                 :             : 
      50                 :             : bool
      51                 :    71394847 : is_global_friend (tree scope)
      52                 :             : {
      53                 :    71394847 :   gcc_checking_assert (scope != NULL_TREE);
      54                 :             : 
      55                 :    71394847 :   if (global_friend == scope)
      56                 :             :     return true;
      57                 :             : 
      58                 :    71394847 :   if (!global_friend)
      59                 :             :     return false;
      60                 :             : 
      61                 :           0 :   if (is_specialization_of_friend (global_friend, scope))
      62                 :             :     return true;
      63                 :             : 
      64                 :             :   return false;
      65                 :             : }
      66                 :             : 
      67                 :             : /* Returns nonzero if SUPPLICANT is a friend of TYPE.  */
      68                 :             : 
      69                 :             : int
      70                 :    30076313 : is_friend (tree type, tree supplicant)
      71                 :             : {
      72                 :    57180908 :   int declp;
      73                 :    57180908 :   tree list;
      74                 :    57180908 :   tree context;
      75                 :             : 
      76                 :    57180908 :   if (supplicant == NULL_TREE || type == NULL_TREE)
      77                 :             :     return 0;
      78                 :             : 
      79                 :    57180908 :   if (is_global_friend (supplicant))
      80                 :             :     return 1;
      81                 :             : 
      82                 :    57180908 :   declp = DECL_P (supplicant);
      83                 :             : 
      84                 :    57180908 :   if (declp)
      85                 :             :     /* It's a function decl.  */
      86                 :             :     {
      87                 :    27054631 :       tree list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type));
      88                 :    27054631 :       tree name = DECL_NAME (supplicant);
      89                 :             : 
      90                 :    56494697 :       for (; list ; list = TREE_CHAIN (list))
      91                 :             :         {
      92                 :    30383584 :           if (name == FRIEND_NAME (list))
      93                 :             :             {
      94                 :      943518 :               tree friends = FRIEND_DECLS (list);
      95                 :     1322203 :               for (; friends ; friends = TREE_CHAIN (friends))
      96                 :             :                 {
      97                 :     1032298 :                   tree this_friend = TREE_VALUE (friends);
      98                 :             : 
      99                 :     1032298 :                   if (this_friend == NULL_TREE)
     100                 :           0 :                     continue;
     101                 :             : 
     102                 :     1032298 :                   if (supplicant == this_friend)
     103                 :             :                     return 1;
     104                 :             : 
     105                 :      509446 :                   if (is_specialization_of_friend (supplicant, this_friend))
     106                 :             :                     return 1;
     107                 :             :                 }
     108                 :             :               break;
     109                 :             :             }
     110                 :             :         }
     111                 :             :     }
     112                 :             :   else
     113                 :             :     /* It's a type.  */
     114                 :             :     {
     115                 :    30126277 :       if (same_type_p (supplicant, type))
     116                 :             :         return 1;
     117                 :             : 
     118                 :     1495719 :       list = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_MAIN_DECL (type)));
     119                 :     1932403 :       for (; list ; list = TREE_CHAIN (list))
     120                 :             :         {
     121                 :     1178667 :           tree t = TREE_VALUE (list);
     122                 :             : 
     123                 :     2357334 :           if (TREE_CODE (t) == TEMPLATE_DECL ?
     124                 :      705444 :               is_specialization_of_friend (TYPE_MAIN_DECL (supplicant), t) :
     125                 :      473223 :               same_type_p (supplicant, t))
     126                 :             :             return 1;
     127                 :             :         }
     128                 :             :     }
     129                 :             : 
     130                 :    27154754 :   if (declp)
     131                 :             :     {
     132                 :    26401018 :       if (DECL_FUNCTION_MEMBER_P (supplicant))
     133                 :    26399524 :         context = DECL_CONTEXT (supplicant);
     134                 :        2988 :       else if (tree fc = DECL_FRIEND_CONTEXT (supplicant))
     135                 :             :         context = fc;
     136                 :             :       else
     137                 :             :         context = NULL_TREE;
     138                 :             :     }
     139                 :             :   else
     140                 :             :     {
     141                 :      753736 :       if (TYPE_CLASS_SCOPE_P (supplicant))
     142                 :             :         /* Nested classes get the same access as their enclosing types, as
     143                 :             :            per DR 45 (this is a change from the standard).  */
     144                 :      535683 :         context = TYPE_CONTEXT (supplicant);
     145                 :             :       else
     146                 :             :         /* Local classes have the same access as the enclosing function.  */
     147                 :      218053 :         context = decl_function_context (TYPE_MAIN_DECL (supplicant));
     148                 :             :     }
     149                 :             : 
     150                 :             :   /* A namespace is not friend to anybody.  */
     151                 :    27153341 :   if (context && TREE_CODE (context) == NAMESPACE_DECL)
     152                 :             :     context = NULL_TREE;
     153                 :             : 
     154                 :             :   if (context)
     155                 :             :     return is_friend (type, context);
     156                 :             : 
     157                 :             :   return 0;
     158                 :             : }
     159                 :             : 
     160                 :             : /* Add a new friend to the friends of the aggregate type TYPE.
     161                 :             :    DECL is the FUNCTION_DECL of the friend being added.
     162                 :             : 
     163                 :             :    If COMPLAIN is true, warning about duplicate friend is issued.
     164                 :             :    We want to have this diagnostics during parsing but not
     165                 :             :    when a template is being instantiated.  */
     166                 :             : 
     167                 :             : void
     168                 :     4998833 : add_friend (tree type, tree decl, bool complain)
     169                 :             : {
     170                 :     4998833 :   tree typedecl;
     171                 :     4998833 :   tree list;
     172                 :     4998833 :   tree name;
     173                 :     4998833 :   tree ctx;
     174                 :             : 
     175                 :     4998833 :   if (decl == error_mark_node)
     176                 :             :     return;
     177                 :             : 
     178                 :     4998796 :   typedecl = TYPE_MAIN_DECL (type);
     179                 :     4998796 :   list = DECL_FRIENDLIST (typedecl);
     180                 :     4998796 :   name = DECL_NAME (decl);
     181                 :     4998796 :   type = TREE_TYPE (typedecl);
     182                 :             : 
     183                 :    11015942 :   while (list)
     184                 :             :     {
     185                 :     6736660 :       if (name == FRIEND_NAME (list))
     186                 :             :         {
     187                 :      719514 :           tree friends = FRIEND_DECLS (list);
     188                 :     2043053 :           for (; friends ; friends = TREE_CHAIN (friends))
     189                 :             :             {
     190                 :     1323622 :               if (decl == TREE_VALUE (friends))
     191                 :             :                 {
     192                 :          83 :                   if (complain)
     193                 :          75 :                     warning (OPT_Wredundant_decls,
     194                 :             :                              "%qD is already a friend of class %qT",
     195                 :             :                              decl, type);
     196                 :          83 :                   return;
     197                 :             :                 }
     198                 :             :             }
     199                 :             : 
     200                 :      719431 :           TREE_VALUE (list) = tree_cons (NULL_TREE, decl,
     201                 :      719431 :                                          TREE_VALUE (list));
     202                 :      719431 :           break;
     203                 :             :         }
     204                 :     6017146 :       list = TREE_CHAIN (list);
     205                 :             :     }
     206                 :             : 
     207                 :     4998713 :   ctx = DECL_CONTEXT (decl);
     208                 :     4998713 :   if (ctx && CLASS_TYPE_P (ctx) && !uses_template_parms (ctx))
     209                 :         133 :     perform_or_defer_access_check (TYPE_BINFO (ctx), decl, decl,
     210                 :             :                                    tf_warning_or_error);
     211                 :             : 
     212                 :     4998713 :   maybe_add_class_template_decl_list (type, decl, /*friend_p=*/1);
     213                 :             : 
     214                 :     4998713 :   if (!list)
     215                 :     4279282 :     DECL_FRIENDLIST (typedecl)
     216                 :     8558564 :       = tree_cons (DECL_NAME (decl), build_tree_list (NULL_TREE, decl),
     217                 :     4279282 :                    DECL_FRIENDLIST (typedecl));
     218                 :     4998713 :   if (!uses_template_parms (type))
     219                 :     2794625 :     DECL_BEFRIENDING_CLASSES (decl)
     220                 :     2794625 :       = tree_cons (NULL_TREE, type,
     221                 :     2794625 :                    DECL_BEFRIENDING_CLASSES (decl));
     222                 :             : }
     223                 :             : 
     224                 :             : /* Make FRIEND_TYPE a friend class to TYPE.  If FRIEND_TYPE has already
     225                 :             :    been defined, we make all of its member functions friends of
     226                 :             :    TYPE.  If not, we make it a pending friend, which can later be added
     227                 :             :    when its definition is seen.  If a type is defined, then its TYPE_DECL's
     228                 :             :    DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend
     229                 :             :    classes that are not defined.  If a type has not yet been defined,
     230                 :             :    then the DECL_WAITING_FRIENDS contains a list of types
     231                 :             :    waiting to make it their friend.  Note that these two can both
     232                 :             :    be in use at the same time!
     233                 :             : 
     234                 :             :    If COMPLAIN is true, warning about duplicate friend is issued.
     235                 :             :    We want to have this diagnostics during parsing but not
     236                 :             :    when a template is being instantiated.  */
     237                 :             : 
     238                 :             : void
     239                 :     2359260 : make_friend_class (tree type, tree friend_type, bool complain)
     240                 :             : {
     241                 :     2359260 :   tree classes;
     242                 :             : 
     243                 :             :   /* CLASS_TEMPLATE_DEPTH counts the number of template headers for
     244                 :             :      the enclosing class.  FRIEND_DEPTH counts the number of template
     245                 :             :      headers used for this friend declaration.  TEMPLATE_MEMBER_P,
     246                 :             :      defined inside the `if' block for TYPENAME_TYPE case, is true if
     247                 :             :      a template header in FRIEND_DEPTH is intended for DECLARATOR.
     248                 :             :      For example, the code
     249                 :             : 
     250                 :             :        template <class T> struct A {
     251                 :             :          template <class U> struct B {
     252                 :             :            template <class V> template <class W>
     253                 :             :              friend class C<V>::D;
     254                 :             :          };
     255                 :             :        };
     256                 :             : 
     257                 :             :      will eventually give the following results
     258                 :             : 
     259                 :             :      1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U').
     260                 :             :      2. FRIEND_DEPTH equals 2 (for `V' and `W').
     261                 :             :      3. TEMPLATE_MEMBER_P is true (for `W').
     262                 :             : 
     263                 :             :      The friend is a template friend iff FRIEND_DEPTH is nonzero.  */
     264                 :             : 
     265                 :     2359260 :   int class_template_depth = template_class_depth (type);
     266                 :     2359260 :   int friend_depth = 0;
     267                 :     2359260 :   if (current_template_depth)
     268                 :             :     /* When processing a friend declaration at parse time, just compare the
     269                 :             :        current depth to that of the class template.  */
     270                 :     1082940 :     friend_depth = current_template_depth - class_template_depth;
     271                 :             :   else
     272                 :             :     {
     273                 :             :       /* Otherwise, we got here from instantiate_class_template.  Determine
     274                 :             :          the friend depth by looking at the template parameters used within
     275                 :             :          FRIEND_TYPE.  */
     276                 :     1276320 :       gcc_checking_assert (class_template_depth == 0);
     277                 :     1842480 :       while (uses_template_parms_level (friend_type, friend_depth + 1))
     278                 :             :         ++friend_depth;
     279                 :             :     }
     280                 :             : 
     281                 :     2359260 :   if (! MAYBE_CLASS_TYPE_P (friend_type)
     282                 :          21 :       && TREE_CODE (friend_type) != TEMPLATE_TEMPLATE_PARM)
     283                 :             :     {
     284                 :             :       /* N1791: If the type specifier in a friend declaration designates a
     285                 :             :          (possibly cv-qualified) class type, that class is declared as a
     286                 :             :          friend; otherwise, the friend declaration is ignored.
     287                 :             : 
     288                 :             :          So don't complain in C++11 mode.  */
     289                 :          18 :       if (cxx_dialect < cxx11)
     290                 :           0 :         pedwarn (input_location, complain ? 0 : OPT_Wpedantic,
     291                 :             :                  "invalid type %qT declared %<friend%>", friend_type);
     292                 :          18 :       return;
     293                 :             :     }
     294                 :             : 
     295                 :     2359242 :   friend_type = cv_unqualified (friend_type);
     296                 :             : 
     297                 :     2359242 :   if (check_for_bare_parameter_packs (friend_type))
     298                 :             :     return;
     299                 :             : 
     300                 :     2359239 :   if (friend_depth)
     301                 :             :     {
     302                 :             :       /* [temp.friend] Friend declarations shall not declare partial
     303                 :             :          specializations.  */
     304                 :     1098841 :       if (CLASS_TYPE_P (friend_type)
     305                 :     1098841 :           && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type)
     306                 :     1098930 :           && uses_template_parms (friend_type))
     307                 :             :         {
     308                 :           0 :           error ("partial specialization %qT declared %<friend%>",
     309                 :             :                  friend_type);
     310                 :           0 :           return;
     311                 :             :         }
     312                 :             : 
     313                 :     1098926 :       if (TYPE_TEMPLATE_INFO (friend_type)
     314                 :     1098841 :           && !PRIMARY_TEMPLATE_P (TYPE_TI_TEMPLATE (friend_type)))
     315                 :             :         {
     316                 :           4 :           auto_diagnostic_group d;
     317                 :           4 :           error ("%qT is not a template", friend_type);
     318                 :           4 :           inform (location_of (friend_type), "previous declaration here");
     319                 :           8 :           if (TYPE_CLASS_SCOPE_P (friend_type)
     320                 :           4 :               && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (friend_type))
     321                 :           8 :               && currently_open_class (TYPE_CONTEXT (friend_type)))
     322                 :           4 :             inform (input_location, "perhaps you need explicit template "
     323                 :             :                     "arguments in your nested-name-specifier");
     324                 :           4 :           return;
     325                 :           4 :         }
     326                 :             :     }
     327                 :             : 
     328                 :             :   /* It makes sense for a template class to be friends with itself,
     329                 :             :      that means the instantiations can be friendly.  Other cases are
     330                 :             :      not so meaningful.  */
     331                 :     1260313 :   if (!friend_depth && same_type_p (type, friend_type))
     332                 :             :     {
     333                 :           8 :       if (complain)
     334                 :           0 :         warning (0, "class %qT is implicitly friends with itself",
     335                 :             :                  type);
     336                 :           8 :       return;
     337                 :             :     }
     338                 :             : 
     339                 :             :   /* [temp.friend]
     340                 :             : 
     341                 :             :      A friend of a class or class template can be a function or
     342                 :             :      class template, a specialization of a function template or
     343                 :             :      class template, or an ordinary (nontemplate) function or
     344                 :             :      class.  */
     345                 :     2359227 :   if (!friend_depth)
     346                 :             :     ;/* ok */
     347                 :     1098922 :   else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
     348                 :             :     {
     349                 :          82 :       if (TREE_CODE (TYPENAME_TYPE_FULLNAME (friend_type))
     350                 :             :           == TEMPLATE_ID_EXPR)
     351                 :             :         {
     352                 :             :           /* template <class U> friend class T::X<U>; */
     353                 :             :           /* [temp.friend]
     354                 :             :              Friend declarations shall not declare partial
     355                 :             :              specializations.  */
     356                 :           0 :           error ("partial specialization %qT declared %<friend%>",
     357                 :             :                  friend_type);
     358                 :           0 :           return;
     359                 :             :         }
     360                 :             :       else
     361                 :             :         {
     362                 :             :           /* We will figure this out later.  */
     363                 :          82 :           bool template_member_p = false;
     364                 :             : 
     365                 :          82 :           tree ctype = TYPE_CONTEXT (friend_type);
     366                 :          82 :           tree name = TYPE_IDENTIFIER (friend_type);
     367                 :          82 :           tree decl;
     368                 :             : 
     369                 :             :           /* We need to distinguish a TYPENAME_TYPE for the non-template
     370                 :             :              class B in
     371                 :             :                template<class T> friend class A<T>::B;
     372                 :             :              vs for the class template B in
     373                 :             :                template<class T> template<class U> friend class A<T>::B;  */
     374                 :          82 :           if (current_template_depth
     375                 :          66 :               && !uses_template_parms_level (ctype, current_template_depth))
     376                 :             :             template_member_p = true;
     377                 :             : 
     378                 :          82 :           if (class_template_depth)
     379                 :             :             {
     380                 :             :               /* We rely on tsubst_friend_class to check the
     381                 :             :                  validity of the declaration later.  */
     382                 :          28 :               if (template_member_p)
     383                 :          12 :                 friend_type
     384                 :          12 :                   = make_unbound_class_template (ctype,
     385                 :             :                                                  name,
     386                 :             :                                                  current_template_parms,
     387                 :             :                                                  tf_error);
     388                 :             :               else
     389                 :          16 :                 friend_type
     390                 :          16 :                   = make_typename_type (ctype, name, class_type, tf_error);
     391                 :             :             }
     392                 :             :           else
     393                 :             :             {
     394                 :          54 :               decl = lookup_member (ctype, name, 0, true, tf_warning_or_error);
     395                 :          54 :               if (!decl)
     396                 :             :                 {
     397                 :           0 :                   error ("%qT is not a member of %qT", name, ctype);
     398                 :           0 :                   return;
     399                 :             :                 }
     400                 :          54 :               if (template_member_p && !DECL_CLASS_TEMPLATE_P (decl))
     401                 :             :                 {
     402                 :           0 :                   auto_diagnostic_group d;
     403                 :           0 :                   error ("%qT is not a member class template of %qT",
     404                 :             :                          name, ctype);
     405                 :           0 :                   inform (DECL_SOURCE_LOCATION (decl),
     406                 :             :                           "%qD declared here", decl);
     407                 :           0 :                   return;
     408                 :           0 :                 }
     409                 :          54 :               if (!template_member_p && (TREE_CODE (decl) != TYPE_DECL
     410                 :          42 :                                          || !CLASS_TYPE_P (TREE_TYPE (decl))))
     411                 :             :                 {
     412                 :           0 :                   auto_diagnostic_group d;
     413                 :           0 :                   error ("%qT is not a nested class of %qT",
     414                 :             :                          name, ctype);
     415                 :           0 :                   inform (DECL_SOURCE_LOCATION (decl),
     416                 :             :                           "%qD declared here", decl);
     417                 :           0 :                   return;
     418                 :           0 :                 }
     419                 :             : 
     420                 :          54 :               friend_type = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl));
     421                 :             :             }
     422                 :             :         }
     423                 :             :     }
     424                 :     1098840 :   else if (TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM)
     425                 :             :     {
     426                 :             :       /* template <class T> friend class T; */
     427                 :           0 :       error ("template parameter type %qT declared %<friend%>", friend_type);
     428                 :           0 :       return;
     429                 :             :     }
     430                 :     1098840 :   else if (TREE_CODE (friend_type) == TEMPLATE_TEMPLATE_PARM)
     431                 :           3 :     friend_type = TYPE_NAME (friend_type);
     432                 :     1098837 :   else if (!CLASSTYPE_TEMPLATE_INFO (friend_type))
     433                 :             :     {
     434                 :             :       /* template <class T> friend class A; where A is not a template */
     435                 :           0 :       error ("%q#T is not a template", friend_type);
     436                 :           0 :       return;
     437                 :             :     }
     438                 :             :   else
     439                 :             :     /* template <class T> friend class A; where A is a template */
     440                 :     1098837 :     friend_type = CLASSTYPE_TI_TEMPLATE (friend_type);
     441                 :             : 
     442                 :     2359227 :   if (friend_type == error_mark_node)
     443                 :             :     return;
     444                 :             : 
     445                 :             :   /* See if it is already a friend.  */
     446                 :     2359227 :   for (classes = CLASSTYPE_FRIEND_CLASSES (type);
     447                 :     3709716 :        classes;
     448                 :     1350489 :        classes = TREE_CHAIN (classes))
     449                 :             :     {
     450                 :     1351537 :       tree probe = TREE_VALUE (classes);
     451                 :             : 
     452                 :     1351537 :       if (TREE_CODE (friend_type) == TEMPLATE_DECL)
     453                 :             :         {
     454                 :      677888 :           if (friend_type == probe)
     455                 :             :             {
     456                 :           2 :               if (complain)
     457                 :           0 :                 warning (OPT_Wredundant_decls,
     458                 :             :                          "%qD is already a friend of %qT", probe, type);
     459                 :             :               break;
     460                 :             :             }
     461                 :             :         }
     462                 :      673649 :       else if (TREE_CODE (probe) != TEMPLATE_DECL)
     463                 :             :         {
     464                 :      533876 :           if (same_type_p (probe, friend_type))
     465                 :             :             {
     466                 :        1046 :               if (complain)
     467                 :        1042 :                 warning (OPT_Wredundant_decls,
     468                 :             :                          "%qT is already a friend of %qT", probe, type);
     469                 :             :               break;
     470                 :             :             }
     471                 :             :         }
     472                 :             :     }
     473                 :             : 
     474                 :     2359227 :   if (!classes)
     475                 :             :     {
     476                 :     2358179 :       maybe_add_class_template_decl_list (type, friend_type, /*friend_p=*/1);
     477                 :             : 
     478                 :     2358179 :       CLASSTYPE_FRIEND_CLASSES (type)
     479                 :     2358179 :         = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type));
     480                 :     2358179 :       if (TREE_CODE (friend_type) == TEMPLATE_DECL)
     481                 :     1098892 :         friend_type = TREE_TYPE (friend_type);
     482                 :     2358179 :       if (!uses_template_parms (type))
     483                 :     1338422 :         CLASSTYPE_BEFRIENDING_CLASSES (friend_type)
     484                 :     1338422 :           = tree_cons (NULL_TREE, type,
     485                 :     1338422 :                        CLASSTYPE_BEFRIENDING_CLASSES (friend_type));
     486                 :             :     }
     487                 :             : }
     488                 :             : 
     489                 :             : /* Record DECL (a FUNCTION_DECL) as a friend of the
     490                 :             :    CURRENT_CLASS_TYPE.  If DECL is a member function, SCOPE is the
     491                 :             :    class of which it is a member, as named in the friend declaration.
     492                 :             :    If the friend declaration was explicitly namespace-qualified, SCOPE
     493                 :             :    is that namespace.
     494                 :             :    DECLARATOR is the name of the friend.  FUNCDEF_FLAG is true if the
     495                 :             :    friend declaration is a definition of the function.  FLAGS is as
     496                 :             :    for grokclass fn.  */
     497                 :             : 
     498                 :             : tree
     499                 :     3374459 : do_friend (tree scope, tree declarator, tree decl,
     500                 :             :            enum overload_flags flags,
     501                 :             :            bool funcdef_flag)
     502                 :             : {
     503                 :     3374459 :   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
     504                 :             : 
     505                 :     3374459 :   tree ctype = NULL_TREE;
     506                 :     3374459 :   tree in_namespace = NULL_TREE;
     507                 :     3374459 :   if (!scope)
     508                 :             :     ;
     509                 :       85720 :   else if (MAYBE_CLASS_TYPE_P (scope))
     510                 :             :     ctype = scope;
     511                 :             :   else
     512                 :             :     {
     513                 :       85441 :       gcc_checking_assert (TREE_CODE (scope) == NAMESPACE_DECL);
     514                 :             :       in_namespace = scope;
     515                 :             :     }
     516                 :             : 
     517                 :             :   /* Friend functions are unique, until proved otherwise.  */
     518                 :     3374459 :   DECL_UNIQUE_FRIEND_P (decl) = 1;
     519                 :             : 
     520                 :     6748915 :   if (DECL_OVERRIDE_P (decl) || DECL_FINAL_P (decl))
     521                 :           6 :     error ("friend declaration %qD may not have virt-specifiers",
     522                 :             :            decl);
     523                 :             : 
     524                 :     3374459 :   tree orig_declarator = declarator;
     525                 :     3374459 :   if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
     526                 :             :     {
     527                 :       11117 :       declarator = TREE_OPERAND (declarator, 0);
     528                 :       22231 :       if (!identifier_p (declarator))
     529                 :       11111 :         declarator = OVL_NAME (declarator);
     530                 :             :     }
     531                 :             : 
     532                 :             :   /* CLASS_TEMPLATE_DEPTH counts the number of template headers for
     533                 :             :      the enclosing class.  FRIEND_DEPTH counts the number of template
     534                 :             :      headers used for this friend declaration.  TEMPLATE_MEMBER_P is
     535                 :             :      true if a template header in FRIEND_DEPTH is intended for
     536                 :             :      DECLARATOR.  For example, the code
     537                 :             : 
     538                 :             :      template <class T> struct A {
     539                 :             :        template <class U> struct B {
     540                 :             :          template <class V> template <class W>
     541                 :             :            friend void C<V>::f(W);
     542                 :             :        };
     543                 :             :      };
     544                 :             : 
     545                 :             :      will eventually give the following results
     546                 :             : 
     547                 :             :      1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U').
     548                 :             :      2. FRIEND_DEPTH equals 2 (for `V' and `W').
     549                 :             :      3. CTYPE_DEPTH equals 1 (for `V').
     550                 :             :      4. TEMPLATE_MEMBER_P is true (for `W').  */
     551                 :             : 
     552                 :     3374459 :   int class_template_depth = template_class_depth (current_class_type);
     553                 :     3374459 :   int friend_depth = current_template_depth - class_template_depth;
     554                 :     3374459 :   int ctype_depth = num_template_headers_for_class (ctype);
     555                 :     3374459 :   bool template_member_p = friend_depth > ctype_depth;
     556                 :             : 
     557                 :     3374459 :   if (ctype)
     558                 :             :     {
     559                 :         279 :       tree cname = TYPE_NAME (ctype);
     560                 :         279 :       if (TREE_CODE (cname) == TYPE_DECL)
     561                 :         279 :         cname = DECL_NAME (cname);
     562                 :             : 
     563                 :             :       /* A method friend.  */
     564                 :         279 :       if (flags == NO_SPECIAL && declarator == cname)
     565                 :          28 :         DECL_CXX_CONSTRUCTOR_P (decl) = 1;
     566                 :             : 
     567                 :         279 :       grokclassfn (ctype, decl, flags);
     568                 :             : 
     569                 :             :       /* A nested class may declare a member of an enclosing class
     570                 :             :          to be a friend, so we do lookup here even if CTYPE is in
     571                 :             :          the process of being defined.  */
     572                 :         279 :       if (class_template_depth
     573                 :         279 :           || COMPLETE_OR_OPEN_TYPE_P (ctype))
     574                 :             :         {
     575                 :         268 :           if (DECL_TEMPLATE_INFO (decl))
     576                 :             :             /* DECL is a template specialization.  No need to
     577                 :             :                build a new TEMPLATE_DECL.  */
     578                 :             :             ;
     579                 :         252 :           else if (class_template_depth)
     580                 :             :             /* We rely on tsubst_friend_function to check the
     581                 :             :                validity of the declaration later.  */
     582                 :          97 :             decl = push_template_decl (decl, /*is_friend=*/true);
     583                 :             :           else
     584                 :         190 :             decl = check_classfn (ctype, decl,
     585                 :             :                                   template_member_p
     586                 :          35 :                                   ? current_template_parms
     587                 :             :                                   : NULL_TREE);
     588                 :             : 
     589                 :         268 :           if ((template_member_p
     590                 :             :                /* Always pull out the TEMPLATE_DECL if we have a friend
     591                 :             :                   template in a class template so that it gets tsubsted
     592                 :             :                   properly later on (59956).  tsubst_friend_function knows
     593                 :             :                   how to tell this apart from a member template.  */
     594                 :         225 :                || (class_template_depth && friend_depth))
     595                 :          75 :               && decl && TREE_CODE (decl) == FUNCTION_DECL)
     596                 :          40 :             decl = DECL_TI_TEMPLATE (decl);
     597                 :             :         }
     598                 :             :       else
     599                 :          11 :         error ("member %qD declared as friend before type %qT defined",
     600                 :             :                   decl, ctype);
     601                 :             :     }
     602                 :             :   else
     603                 :             :     {
     604                 :             :       /* Namespace-scope friend function.  */
     605                 :             : 
     606                 :     3374180 :       if (funcdef_flag)
     607                 :     2204676 :         SET_DECL_FRIEND_CONTEXT (decl, current_class_type);
     608                 :             : 
     609                 :     3374180 :       if (! DECL_USE_TEMPLATE (decl))
     610                 :             :         {
     611                 :             :           /* We must check whether the decl refers to template
     612                 :             :              arguments before push_template_decl adds a reference to
     613                 :             :              the containing template class.  */
     614                 :     3363068 :           int warn = (warn_nontemplate_friend
     615                 :     3363013 :                       && ! funcdef_flag && ! friend_depth
     616                 :      186429 :                       && current_template_parms
     617                 :     3374025 :                       && uses_template_parms (decl));
     618                 :             : 
     619                 :     3363068 :           if (friend_depth || class_template_depth)
     620                 :             :             /* We can't call pushdecl for a template class, since in
     621                 :             :                general, such a declaration depends on template
     622                 :             :                parameters.  Instead, we call pushdecl when the class
     623                 :             :                is instantiated.  */
     624                 :     2470303 :             decl = push_template_decl (decl, /*is_friend=*/true);
     625                 :      892765 :           else if (current_function_decl && !in_namespace)
     626                 :             :             /* pushdecl will check there's a local decl already.  */
     627                 :          16 :             decl = pushdecl (decl, /*hiding=*/true);
     628                 :             :           else
     629                 :             :             {
     630                 :             :               /* We can't use pushdecl, as we might be in a template
     631                 :             :                  class specialization, and pushdecl will insert an
     632                 :             :                  unqualified friend decl into the template parameter
     633                 :             :                  scope, rather than the namespace containing it.  */
     634                 :      892749 :               tree ns = decl_namespace_context (decl);
     635                 :             : 
     636                 :      892749 :               push_nested_namespace (ns);
     637                 :      892749 :               decl = pushdecl_namespace_level (decl, /*hiding=*/true);
     638                 :      892749 :               pop_nested_namespace (ns);
     639                 :             :             }
     640                 :             : 
     641                 :     3363068 :           if (warn)
     642                 :             :             {
     643                 :          20 :               static int explained;
     644                 :          20 :               bool warned;
     645                 :             : 
     646                 :          20 :               auto_diagnostic_group d;
     647                 :          20 :               warned = warning (OPT_Wnon_template_friend, "friend declaration "
     648                 :             :                                 "%q#D declares a non-template function", decl);
     649                 :          20 :               if (! explained && warned)
     650                 :             :                 {
     651                 :          16 :                   inform (input_location, "(if this is not what you intended, "
     652                 :             :                           "make sure the function template has already been "
     653                 :             :                           "declared and add %<<>%> after the function name "
     654                 :             :                           "here)");
     655                 :          16 :                   explained = 1;
     656                 :             :                 }
     657                 :          20 :             }
     658                 :             :         }
     659                 :             :     }
     660                 :             : 
     661                 :     3374459 :   if (decl == error_mark_node)
     662                 :             :     return error_mark_node;
     663                 :             : 
     664                 :     1170315 :   if (!class_template_depth && DECL_IMPLICIT_INSTANTIATION (decl)
     665                 :     3374494 :       && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
     666                 :             :     /* "[if no non-template match is found,] each remaining function template
     667                 :             :        is replaced with the specialization chosen by deduction from the
     668                 :             :        friend declaration or discarded if deduction fails."
     669                 :             : 
     670                 :             :        set_decl_namespace or check_classfn set DECL_IMPLICIT_INSTANTIATION to
     671                 :             :        indicate that we need a template match, so ask
     672                 :             :        check_explicit_specialization to find one.  */
     673                 :          83 :     decl = (check_explicit_specialization
     674                 :          83 :             (orig_declarator, decl, ctype_depth,
     675                 :          83 :              2 * funcdef_flag + 4));
     676                 :             : 
     677                 :     8023730 :   add_friend (current_class_type,
     678                 :     3374403 :               (!ctype && friend_depth) ? DECL_TI_TEMPLATE (decl) : decl,
     679                 :             :               /*complain=*/true);
     680                 :             : 
     681                 :     3374403 :   return decl;
     682                 :             : }
     683                 :             : 
     684                 :             : #include "gt-cp-friend.h"
        

Generated by: LCOV version 2.0-1

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