LCOV - code coverage report
Current view: top level - gcc/cp - lambda.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 685 704 97.3 %
Date: 2020-03-28 11:57:23 Functions: 38 39 97.4 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Perform the semantic phase of lambda parsing, i.e., the process of
       2                 :            :    building tree structure, checking semantic consistency, and
       3                 :            :    building RTL.  These routines are used both during actual parsing
       4                 :            :    and during the instantiation of template functions.
       5                 :            : 
       6                 :            :    Copyright (C) 1998-2020 Free Software Foundation, Inc.
       7                 :            : 
       8                 :            :    This file is part of GCC.
       9                 :            : 
      10                 :            :    GCC is free software; you can redistribute it and/or modify it
      11                 :            :    under the terms of the GNU General Public License as published by
      12                 :            :    the Free Software Foundation; either version 3, or (at your option)
      13                 :            :    any later version.
      14                 :            : 
      15                 :            :    GCC is distributed in the hope that it will be useful, but
      16                 :            :    WITHOUT ANY WARRANTY; without even the implied warranty of
      17                 :            :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      18                 :            :    General Public License for more details.
      19                 :            : 
      20                 :            : You should have received a copy of the GNU General Public License
      21                 :            : along with GCC; see the file COPYING3.  If not see
      22                 :            : <http://www.gnu.org/licenses/>.  */
      23                 :            : 
      24                 :            : #include "config.h"
      25                 :            : #include "system.h"
      26                 :            : #include "coretypes.h"
      27                 :            : #include "cp-tree.h"
      28                 :            : #include "stringpool.h"
      29                 :            : #include "cgraph.h"
      30                 :            : #include "tree-iterator.h"
      31                 :            : #include "toplev.h"
      32                 :            : #include "gimplify.h"
      33                 :            : #include "target.h"
      34                 :            : 
      35                 :            : /* Constructor for a lambda expression.  */
      36                 :            : 
      37                 :            : tree
      38                 :      43739 : build_lambda_expr (void)
      39                 :            : {
      40                 :      43739 :   tree lambda = make_node (LAMBDA_EXPR);
      41                 :      43739 :   LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda) = CPLD_NONE;
      42                 :      43739 :   LAMBDA_EXPR_CAPTURE_LIST         (lambda) = NULL_TREE;
      43                 :      43739 :   LAMBDA_EXPR_THIS_CAPTURE         (lambda) = NULL_TREE;
      44                 :      43739 :   LAMBDA_EXPR_PENDING_PROXIES      (lambda) = NULL;
      45                 :      43739 :   LAMBDA_EXPR_MUTABLE_P            (lambda) = false;
      46                 :      43739 :   return lambda;
      47                 :            : }
      48                 :            : 
      49                 :            : /* Create the closure object for a LAMBDA_EXPR.  */
      50                 :            : 
      51                 :            : tree
      52                 :      43709 : build_lambda_object (tree lambda_expr)
      53                 :            : {
      54                 :            :   /* Build aggregate constructor call.
      55                 :            :      - cp_parser_braced_list
      56                 :            :      - cp_parser_functional_cast  */
      57                 :      43709 :   vec<constructor_elt, va_gc> *elts = NULL;
      58                 :      43709 :   tree node, expr, type;
      59                 :      43709 :   location_t saved_loc;
      60                 :            : 
      61                 :      43709 :   if (processing_template_decl || lambda_expr == error_mark_node)
      62                 :            :     return lambda_expr;
      63                 :            : 
      64                 :            :   /* Make sure any error messages refer to the lambda-introducer.  */
      65                 :      34772 :   saved_loc = input_location;
      66                 :      34772 :   input_location = LAMBDA_EXPR_LOCATION (lambda_expr);
      67                 :            : 
      68                 :      78017 :   for (node = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr);
      69                 :      78017 :        node;
      70                 :      43245 :        node = TREE_CHAIN (node))
      71                 :            :     {
      72                 :      43245 :       tree field = TREE_PURPOSE (node);
      73                 :      43245 :       tree val = TREE_VALUE (node);
      74                 :            : 
      75                 :      43245 :       if (field == error_mark_node)
      76                 :            :         {
      77                 :          0 :           expr = error_mark_node;
      78                 :          0 :           goto out;
      79                 :            :         }
      80                 :            : 
      81                 :      43245 :       if (TREE_CODE (val) == TREE_LIST)
      82                 :          0 :         val = build_x_compound_expr_from_list (val, ELK_INIT,
      83                 :            :                                                tf_warning_or_error);
      84                 :            : 
      85                 :      43245 :       if (DECL_P (val))
      86                 :       1187 :         mark_used (val);
      87                 :            : 
      88                 :            :       /* Mere mortals can't copy arrays with aggregate initialization, so
      89                 :            :          do some magic to make it work here.  */
      90                 :      43245 :       if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE)
      91                 :         22 :         val = build_array_copy (val);
      92                 :      43223 :       else if (DECL_NORMAL_CAPTURE_P (field)
      93                 :      42985 :                && !DECL_VLA_CAPTURE_P (field)
      94                 :      86166 :                && !TYPE_REF_P (TREE_TYPE (field)))
      95                 :            :         {
      96                 :            :           /* "the entities that are captured by copy are used to
      97                 :            :              direct-initialize each corresponding non-static data
      98                 :            :              member of the resulting closure object."
      99                 :            : 
     100                 :            :              There's normally no way to express direct-initialization
     101                 :            :              from an element of a CONSTRUCTOR, so we build up a special
     102                 :            :              TARGET_EXPR to bypass the usual copy-initialization.  */
     103                 :       2639 :           val = force_rvalue (val, tf_warning_or_error);
     104                 :       2639 :           if (TREE_CODE (val) == TARGET_EXPR)
     105                 :        366 :             TARGET_EXPR_DIRECT_INIT_P (val) = true;
     106                 :            :         }
     107                 :            : 
     108                 :      43245 :       CONSTRUCTOR_APPEND_ELT (elts, DECL_NAME (field), val);
     109                 :            :     }
     110                 :            : 
     111                 :      34772 :   expr = build_constructor (init_list_type_node, elts);
     112                 :      34772 :   CONSTRUCTOR_IS_DIRECT_INIT (expr) = 1;
     113                 :            : 
     114                 :            :   /* N2927: "[The closure] class type is not an aggregate."
     115                 :            :      But we briefly treat it as an aggregate to make this simpler.  */
     116                 :      34772 :   type = LAMBDA_EXPR_CLOSURE (lambda_expr);
     117                 :      34772 :   CLASSTYPE_NON_AGGREGATE (type) = 0;
     118                 :      34772 :   expr = finish_compound_literal (type, expr, tf_warning_or_error);
     119                 :      34772 :   CLASSTYPE_NON_AGGREGATE (type) = 1;
     120                 :            : 
     121                 :      34772 :  out:
     122                 :      34772 :   input_location = saved_loc;
     123                 :      34772 :   return expr;
     124                 :            : }
     125                 :            : 
     126                 :            : /* Return an initialized RECORD_TYPE for LAMBDA.
     127                 :            :    LAMBDA must have its explicit captures already.  */
     128                 :            : 
     129                 :            : tree
     130                 :      43727 : begin_lambda_type (tree lambda)
     131                 :            : {
     132                 :            :   /* Lambda names are nearly but not quite anonymous.  */
     133                 :      43727 :   tree name = make_anon_name ();
     134                 :      43727 :   IDENTIFIER_LAMBDA_P (name) = true;
     135                 :            : 
     136                 :            :   /* Create the new RECORD_TYPE for this lambda.  */
     137                 :      43727 :   tree type = xref_tag (/*tag_code=*/record_type, name,
     138                 :            :                         /*scope=*/ts_lambda, /*template_header_p=*/false);
     139                 :      43727 :   if (type == error_mark_node)
     140                 :            :     return error_mark_node;
     141                 :            : 
     142                 :            :   /* Designate it as a struct so that we can use aggregate initialization.  */
     143                 :      43720 :   CLASSTYPE_DECLARED_CLASS (type) = false;
     144                 :            : 
     145                 :            :   /* Cross-reference the expression and the type.  */
     146                 :      43720 :   LAMBDA_EXPR_CLOSURE (lambda) = type;
     147                 :      43720 :   CLASSTYPE_LAMBDA_EXPR (type) = lambda;
     148                 :            : 
     149                 :            :   /* In C++17, assume the closure is literal; we'll clear the flag later if
     150                 :            :      necessary.  */
     151                 :      43720 :   if (cxx_dialect >= cxx17)
     152                 :      13717 :     CLASSTYPE_LITERAL_P (type) = true;
     153                 :            : 
     154                 :            :   /* Clear base types.  */
     155                 :      43720 :   xref_basetypes (type, /*bases=*/NULL_TREE);
     156                 :            : 
     157                 :            :   /* Start the class.  */
     158                 :      43720 :   type = begin_class_definition (type);
     159                 :            : 
     160                 :      43720 :   return type;
     161                 :            : }
     162                 :            : 
     163                 :            : /* Returns the type to use for the return type of the operator() of a
     164                 :            :    closure class.  */
     165                 :            : 
     166                 :            : tree
     167                 :          0 : lambda_return_type (tree expr)
     168                 :            : {
     169                 :          0 :   if (expr == NULL_TREE)
     170                 :          0 :     return void_type_node;
     171                 :          0 :   if (type_unknown_p (expr)
     172                 :          0 :       || BRACE_ENCLOSED_INITIALIZER_P (expr))
     173                 :            :     {
     174                 :          0 :       cxx_incomplete_type_error (expr, TREE_TYPE (expr));
     175                 :          0 :       return error_mark_node;
     176                 :            :     }
     177                 :          0 :   gcc_checking_assert (!type_dependent_expression_p (expr));
     178                 :          0 :   return cv_unqualified (type_decays_to (unlowered_expr_type (expr)));
     179                 :            : }
     180                 :            : 
     181                 :            : /* Given a LAMBDA_EXPR or closure type LAMBDA, return the op() of the
     182                 :            :    closure type.  */
     183                 :            : 
     184                 :            : tree
     185                 :    1359470 : lambda_function (tree lambda)
     186                 :            : {
     187                 :    1359470 :   tree type;
     188                 :    1359470 :   if (TREE_CODE (lambda) == LAMBDA_EXPR)
     189                 :     109600 :     type = LAMBDA_EXPR_CLOSURE (lambda);
     190                 :            :   else
     191                 :            :     type = lambda;
     192                 :    2718950 :   gcc_assert (LAMBDA_TYPE_P (type));
     193                 :            :   /* Don't let debug_tree cause instantiation.  */
     194                 :    1359470 :   if (CLASSTYPE_TEMPLATE_INSTANTIATION (type)
     195                 :    1359470 :       && !COMPLETE_OR_OPEN_TYPE_P (type))
     196                 :            :     return NULL_TREE;
     197                 :    1359470 :   lambda = lookup_member (type, call_op_identifier,
     198                 :            :                           /*protect=*/0, /*want_type=*/false,
     199                 :            :                           tf_warning_or_error);
     200                 :    1359470 :   if (lambda)
     201                 :    1359460 :     lambda = STRIP_TEMPLATE (get_first_fn (lambda));
     202                 :            :   return lambda;
     203                 :            : }
     204                 :            : 
     205                 :            : /* Returns the type to use for the FIELD_DECL corresponding to the
     206                 :            :    capture of EXPR.  EXPLICIT_INIT_P indicates whether this is a
     207                 :            :    C++14 init capture, and BY_REFERENCE_P indicates whether we're
     208                 :            :    capturing by reference.  */
     209                 :            : 
     210                 :            : tree
     211                 :      50018 : lambda_capture_field_type (tree expr, bool explicit_init_p,
     212                 :            :                            bool by_reference_p)
     213                 :            : {
     214                 :      50018 :   tree type;
     215                 :      50018 :   bool is_this = is_this_parameter (tree_strip_nop_conversions (expr));
     216                 :            : 
     217                 :      50018 :   if (!is_this && explicit_init_p)
     218                 :            :     {
     219                 :        533 :       tree auto_node = make_auto ();
     220                 :            :       
     221                 :        533 :       type = auto_node;
     222                 :        533 :       if (by_reference_p)
     223                 :            :         /* Add the reference now, so deduction doesn't lose
     224                 :            :            outermost CV qualifiers of EXPR.  */
     225                 :         41 :         type = build_reference_type (type);
     226                 :        533 :       type = do_auto_deduction (type, expr, auto_node);
     227                 :            :     }
     228                 :      49485 :   else if (!is_this && type_dependent_expression_p (expr))
     229                 :            :     {
     230                 :       5785 :       type = cxx_make_type (DECLTYPE_TYPE);
     231                 :       5785 :       DECLTYPE_TYPE_EXPR (type) = expr;
     232                 :       5785 :       DECLTYPE_FOR_LAMBDA_CAPTURE (type) = true;
     233                 :       5785 :       DECLTYPE_FOR_REF_CAPTURE (type) = by_reference_p;
     234                 :       5785 :       SET_TYPE_STRUCTURAL_EQUALITY (type);
     235                 :            :     }
     236                 :            :   else
     237                 :            :     {
     238                 :      43700 :       type = non_reference (unlowered_expr_type (expr));
     239                 :            : 
     240                 :      43700 :       if (!is_this
     241                 :      41876 :           && (by_reference_p || TREE_CODE (type) == FUNCTION_TYPE))
     242                 :      40466 :         type = build_reference_type (type);
     243                 :            :     }
     244                 :            : 
     245                 :      50018 :   return type;
     246                 :            : }
     247                 :            : 
     248                 :            : /* Returns true iff DECL is a lambda capture proxy variable created by
     249                 :            :    build_capture_proxy.  */
     250                 :            : 
     251                 :            : bool
     252                 :  390899000 : is_capture_proxy (tree decl)
     253                 :            : {
     254                 :  390899000 :   return (VAR_P (decl)
     255                 :   87240100 :           && DECL_HAS_VALUE_EXPR_P (decl)
     256                 :     708501 :           && !DECL_ANON_UNION_VAR_P (decl)
     257                 :     706062 :           && !DECL_DECOMPOSITION_P (decl)
     258                 :     640231 :           && !DECL_FNAME_P (decl)
     259                 :     516810 :           && !(DECL_ARTIFICIAL (decl)
     260                 :     524264 :                && DECL_LANG_SPECIFIC (decl)
     261                 :     516810 :                && DECL_OMP_PRIVATIZED_MEMBER (decl))
     262                 :  391937000 :           && LAMBDA_FUNCTION_P (DECL_CONTEXT (decl)));
     263                 :            : }
     264                 :            : 
     265                 :            : /* Returns true iff DECL is a capture proxy for a normal capture
     266                 :            :    (i.e. without explicit initializer).  */
     267                 :            : 
     268                 :            : bool
     269                 :  362065000 : is_normal_capture_proxy (tree decl)
     270                 :            : {
     271                 :  362065000 :   if (!is_capture_proxy (decl))
     272                 :            :     /* It's not a capture proxy.  */
     273                 :            :     return false;
     274                 :            : 
     275                 :     350494 :   return (DECL_LANG_SPECIFIC (decl)
     276                 :     350494 :           && DECL_CAPTURED_VARIABLE (decl));
     277                 :            : }
     278                 :            : 
     279                 :            : /* Returns true iff DECL is a capture proxy for a normal capture
     280                 :            :    of a constant variable.  */
     281                 :            : 
     282                 :            : bool
     283                 :        446 : is_constant_capture_proxy (tree decl)
     284                 :            : {
     285                 :        446 :   if (is_normal_capture_proxy (decl))
     286                 :         43 :     return decl_constant_var_p (DECL_CAPTURED_VARIABLE (decl));
     287                 :            :   return false;
     288                 :            : }
     289                 :            : 
     290                 :            : /* VAR is a capture proxy created by build_capture_proxy; add it to the
     291                 :            :    current function, which is the operator() for the appropriate lambda.  */
     292                 :            : 
     293                 :            : void
     294                 :      52227 : insert_capture_proxy (tree var)
     295                 :            : {
     296                 :      52227 :   if (is_normal_capture_proxy (var))
     297                 :            :     {
     298                 :      51493 :       tree cap = DECL_CAPTURED_VARIABLE (var);
     299                 :      51493 :       if (CHECKING_P)
     300                 :            :         {
     301                 :      51493 :           gcc_assert (!is_normal_capture_proxy (cap));
     302                 :      51493 :           tree old = retrieve_local_specialization (cap);
     303                 :      51493 :           if (old)
     304                 :        255 :             gcc_assert (DECL_CONTEXT (old) != DECL_CONTEXT (var));
     305                 :            :         }
     306                 :      51493 :       register_local_specialization (var, cap);
     307                 :            :     }
     308                 :            : 
     309                 :            :   /* Put the capture proxy in the extra body block so that it won't clash
     310                 :            :      with a later local variable.  */
     311                 :      52227 :   pushdecl_outermost_localscope (var);
     312                 :            : 
     313                 :            :   /* And put a DECL_EXPR in the STATEMENT_LIST for the same block.  */
     314                 :      52227 :   var = build_stmt (DECL_SOURCE_LOCATION (var), DECL_EXPR, var);
     315                 :      52227 :   tree stmt_list = (*stmt_list_stack)[1];
     316                 :      52227 :   gcc_assert (stmt_list);
     317                 :      52227 :   append_to_statement_list_force (var, &stmt_list);
     318                 :      52227 : }
     319                 :            : 
     320                 :            : /* We've just finished processing a lambda; if the containing scope is also
     321                 :            :    a lambda, insert any capture proxies that were created while processing
     322                 :            :    the nested lambda.  */
     323                 :            : 
     324                 :            : void
     325                 :      43720 : insert_pending_capture_proxies (void)
     326                 :            : {
     327                 :      43720 :   tree lam;
     328                 :      43720 :   vec<tree, va_gc> *proxies;
     329                 :      43720 :   unsigned i;
     330                 :            : 
     331                 :      49713 :   if (!current_function_decl || !LAMBDA_FUNCTION_P (current_function_decl))
     332                 :            :     return;
     333                 :            : 
     334                 :        623 :   lam = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl));
     335                 :        623 :   proxies = LAMBDA_EXPR_PENDING_PROXIES (lam);
     336                 :       1035 :   for (i = 0; i < vec_safe_length (proxies); ++i)
     337                 :            :     {
     338                 :        145 :       tree var = (*proxies)[i];
     339                 :        145 :       insert_capture_proxy (var);
     340                 :            :     }
     341                 :        623 :   release_tree_vector (LAMBDA_EXPR_PENDING_PROXIES (lam));
     342                 :        623 :   LAMBDA_EXPR_PENDING_PROXIES (lam) = NULL;
     343                 :            : }
     344                 :            : 
     345                 :            : /* Given REF, a COMPONENT_REF designating a field in the lambda closure,
     346                 :            :    return the type we want the proxy to have: the type of the field itself,
     347                 :            :    with added const-qualification if the lambda isn't mutable and the
     348                 :            :    capture is by value.  */
     349                 :            : 
     350                 :            : tree
     351                 :      51457 : lambda_proxy_type (tree ref)
     352                 :            : {
     353                 :      51457 :   tree type;
     354                 :      51457 :   if (ref == error_mark_node)
     355                 :            :     return error_mark_node;
     356                 :      51451 :   if (REFERENCE_REF_P (ref))
     357                 :          0 :     ref = TREE_OPERAND (ref, 0);
     358                 :      51451 :   gcc_assert (TREE_CODE (ref) == COMPONENT_REF);
     359                 :      51451 :   type = TREE_TYPE (ref);
     360                 :      51451 :   if (!type || WILDCARD_TYPE_P (non_reference (type)))
     361                 :            :     {
     362                 :       6173 :       type = cxx_make_type (DECLTYPE_TYPE);
     363                 :       6173 :       DECLTYPE_TYPE_EXPR (type) = ref;
     364                 :       6173 :       DECLTYPE_FOR_LAMBDA_PROXY (type) = true;
     365                 :       6173 :       SET_TYPE_STRUCTURAL_EQUALITY (type);
     366                 :            :     }
     367                 :      51451 :   if (DECL_PACK_P (TREE_OPERAND (ref, 1)))
     368                 :        329 :     type = make_pack_expansion (type);
     369                 :            :   return type;
     370                 :            : }
     371                 :            : 
     372                 :            : /* MEMBER is a capture field in a lambda closure class.  Now that we're
     373                 :            :    inside the operator(), build a placeholder var for future lookups and
     374                 :            :    debugging.  */
     375                 :            : 
     376                 :            : static tree
     377                 :      51457 : build_capture_proxy (tree member, tree init)
     378                 :            : {
     379                 :      51457 :   tree var, object, fn, closure, name, lam, type;
     380                 :            : 
     381                 :      51457 :   if (PACK_EXPANSION_P (member))
     382                 :        323 :     member = PACK_EXPANSION_PATTERN (member);
     383                 :            : 
     384                 :      51457 :   closure = DECL_CONTEXT (member);
     385                 :      51457 :   fn = lambda_function (closure);
     386                 :      51457 :   lam = CLASSTYPE_LAMBDA_EXPR (closure);
     387                 :            : 
     388                 :            :   /* The proxy variable forwards to the capture field.  */
     389                 :      51457 :   object = build_fold_indirect_ref (DECL_ARGUMENTS (fn));
     390                 :      51457 :   object = finish_non_static_data_member (member, object, NULL_TREE);
     391                 :      51457 :   if (REFERENCE_REF_P (object))
     392                 :      40769 :     object = TREE_OPERAND (object, 0);
     393                 :            : 
     394                 :            :   /* Remove the __ inserted by add_capture.  */
     395                 :      51457 :   name = get_identifier (IDENTIFIER_POINTER (DECL_NAME (member)) + 2);
     396                 :            : 
     397                 :      51457 :   type = lambda_proxy_type (object);
     398                 :            : 
     399                 :      51457 :   if (name == this_identifier && !INDIRECT_TYPE_P (type))
     400                 :            :     {
     401                 :        103 :       type = build_pointer_type (type);
     402                 :        103 :       type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
     403                 :        103 :       object = build_fold_addr_expr_with_type (object, type);
     404                 :            :     }
     405                 :            : 
     406                 :      51457 :   if (DECL_VLA_CAPTURE_P (member))
     407                 :            :     {
     408                 :            :       /* Rebuild the VLA type from the pointer and maxindex.  */
     409                 :         45 :       tree field = next_initializable_field (TYPE_FIELDS (type));
     410                 :         45 :       tree ptr = build_simple_component_ref (object, field);
     411                 :         45 :       field = next_initializable_field (DECL_CHAIN (field));
     412                 :         45 :       tree max = build_simple_component_ref (object, field);
     413                 :         45 :       type = build_cplus_array_type (TREE_TYPE (TREE_TYPE (ptr)),
     414                 :            :                                      build_index_type (max));
     415                 :         45 :       type = build_reference_type (type);
     416                 :         45 :       object = convert (type, ptr);
     417                 :            :     }
     418                 :            : 
     419                 :      51457 :   complete_type (type);
     420                 :            : 
     421                 :      51457 :   var = build_decl (input_location, VAR_DECL, name, type);
     422                 :      51457 :   SET_DECL_VALUE_EXPR (var, object);
     423                 :      51457 :   DECL_HAS_VALUE_EXPR_P (var) = 1;
     424                 :      51457 :   DECL_ARTIFICIAL (var) = 1;
     425                 :      51457 :   TREE_USED (var) = 1;
     426                 :      51457 :   DECL_CONTEXT (var) = fn;
     427                 :            : 
     428                 :      51457 :   if (DECL_NORMAL_CAPTURE_P (member))
     429                 :            :     {
     430                 :      50806 :       if (DECL_VLA_CAPTURE_P (member))
     431                 :            :         {
     432                 :         42 :           init = CONSTRUCTOR_ELT (init, 0)->value;
     433                 :         42 :           init = TREE_OPERAND (init, 0); // Strip ADDR_EXPR.
     434                 :         42 :           init = TREE_OPERAND (init, 0); // Strip ARRAY_REF.
     435                 :            :         }
     436                 :            :       else
     437                 :            :         {
     438                 :      50764 :           if (PACK_EXPANSION_P (init))
     439                 :         34 :             init = PACK_EXPANSION_PATTERN (init);
     440                 :            :         }
     441                 :            : 
     442                 :      50806 :       if (INDIRECT_REF_P (init))
     443                 :      43387 :         init = TREE_OPERAND (init, 0);
     444                 :      50806 :       STRIP_NOPS (init);
     445                 :            : 
     446                 :      50806 :       gcc_assert (VAR_P (init) || TREE_CODE (init) == PARM_DECL);
     447                 :      51206 :       while (is_normal_capture_proxy (init))
     448                 :        400 :         init = DECL_CAPTURED_VARIABLE (init);
     449                 :      50806 :       retrofit_lang_decl (var);
     450                 :      50806 :       DECL_CAPTURED_VARIABLE (var) = init;
     451                 :            :     }
     452                 :            : 
     453                 :      51457 :   if (name == this_identifier)
     454                 :            :     {
     455                 :       2667 :       gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (lam) == member);
     456                 :       2667 :       LAMBDA_EXPR_THIS_CAPTURE (lam) = var;
     457                 :            :     }
     458                 :            : 
     459                 :      51457 :   if (fn == current_function_decl)
     460                 :      51312 :     insert_capture_proxy (var);
     461                 :            :   else
     462                 :        145 :     vec_safe_push (LAMBDA_EXPR_PENDING_PROXIES (lam), var);
     463                 :            : 
     464                 :      51457 :   return var;
     465                 :            : }
     466                 :            : 
     467                 :            : static GTY(()) tree ptr_id;
     468                 :            : static GTY(()) tree max_id;
     469                 :            : 
     470                 :            : /* Return a struct containing a pointer and a length for lambda capture of
     471                 :            :    an array of runtime length.  */
     472                 :            : 
     473                 :            : static tree
     474                 :         45 : vla_capture_type (tree array_type)
     475                 :            : {
     476                 :         45 :   tree type = xref_tag (record_type, make_anon_name (), ts_current, false);
     477                 :         45 :   xref_basetypes (type, NULL_TREE);
     478                 :         45 :   type = begin_class_definition (type);
     479                 :         45 :   if (!ptr_id)
     480                 :            :     {
     481                 :         36 :       ptr_id = get_identifier ("ptr");
     482                 :         36 :       max_id = get_identifier ("max");
     483                 :            :     }
     484                 :         45 :   tree ptrtype = build_pointer_type (TREE_TYPE (array_type));
     485                 :         45 :   tree field = build_decl (input_location, FIELD_DECL, ptr_id, ptrtype);
     486                 :         45 :   finish_member_declaration (field);
     487                 :         45 :   field = build_decl (input_location, FIELD_DECL, max_id, sizetype);
     488                 :         45 :   finish_member_declaration (field);
     489                 :         45 :   return finish_struct (type, NULL_TREE);
     490                 :            : }
     491                 :            : 
     492                 :            : /* From an ID and INITIALIZER, create a capture (by reference if
     493                 :            :    BY_REFERENCE_P is true), add it to the capture-list for LAMBDA,
     494                 :            :    and return it.  If ID is `this', BY_REFERENCE_P says whether
     495                 :            :    `*this' is captured by reference.  */
     496                 :            : 
     497                 :            : tree
     498                 :      34758 : add_capture (tree lambda, tree id, tree orig_init, bool by_reference_p,
     499                 :            :              bool explicit_init_p)
     500                 :            : {
     501                 :      34758 :   char *buf;
     502                 :      34758 :   tree type, member, name;
     503                 :      34758 :   bool vla = false;
     504                 :      34758 :   bool variadic = false;
     505                 :      34758 :   tree initializer = orig_init;
     506                 :            : 
     507                 :      34758 :   if (PACK_EXPANSION_P (initializer))
     508                 :            :     {
     509                 :        323 :       initializer = PACK_EXPANSION_PATTERN (initializer);
     510                 :            :       variadic = true;
     511                 :            :     }
     512                 :            : 
     513                 :      34758 :   if (TREE_CODE (initializer) == TREE_LIST
     514                 :            :       /* A pack expansion might end up with multiple elements.  */
     515                 :      34758 :       && !PACK_EXPANSION_P (TREE_VALUE (initializer)))
     516                 :        298 :     initializer = build_x_compound_expr_from_list (initializer, ELK_INIT,
     517                 :            :                                                    tf_warning_or_error);
     518                 :      34758 :   type = TREE_TYPE (initializer);
     519                 :      34758 :   if (type == error_mark_node)
     520                 :            :     return error_mark_node;
     521                 :            : 
     522                 :      34737 :   if (!dependent_type_p (type) && array_of_runtime_bound_p (type))
     523                 :            :     {
     524                 :         45 :       vla = true;
     525                 :         45 :       if (!by_reference_p)
     526                 :          3 :         error ("array of runtime bound cannot be captured by copy, "
     527                 :            :                "only by reference");
     528                 :            : 
     529                 :            :       /* For a VLA, we capture the address of the first element and the
     530                 :            :          maximum index, and then reconstruct the VLA for the proxy.  */
     531                 :         45 :       tree elt = cp_build_array_ref (input_location, initializer,
     532                 :            :                                      integer_zero_node, tf_warning_or_error);
     533                 :         45 :       initializer = build_constructor_va (init_list_type_node, 2,
     534                 :            :                                           NULL_TREE, build_address (elt),
     535                 :            :                                           NULL_TREE, array_type_nelts (type));
     536                 :         45 :       type = vla_capture_type (type);
     537                 :            :     }
     538                 :      34692 :   else if (!dependent_type_p (type)
     539                 :      34692 :            && variably_modified_type_p (type, NULL_TREE))
     540                 :            :     {
     541                 :         18 :       sorry ("capture of variably-modified type %qT that is not an N3639 array "
     542                 :            :              "of runtime bound", type);
     543                 :         18 :       if (TREE_CODE (type) == ARRAY_TYPE
     544                 :         30 :           && variably_modified_type_p (TREE_TYPE (type), NULL_TREE))
     545                 :         12 :         inform (input_location, "because the array element type %qT has "
     546                 :         12 :                 "variable size", TREE_TYPE (type));
     547                 :         18 :       return error_mark_node;
     548                 :            :     }
     549                 :            :   else
     550                 :            :     {
     551                 :      34674 :       type = lambda_capture_field_type (initializer, explicit_init_p,
     552                 :            :                                         by_reference_p);
     553                 :      34674 :       if (type == error_mark_node)
     554                 :            :         return error_mark_node;
     555                 :            : 
     556                 :      34671 :       if (id == this_identifier && !by_reference_p)
     557                 :            :         {
     558                 :         97 :           gcc_assert (INDIRECT_TYPE_P (type));
     559                 :         97 :           type = TREE_TYPE (type);
     560                 :         97 :           initializer = cp_build_fold_indirect_ref (initializer);
     561                 :            :         }
     562                 :            : 
     563                 :      34671 :       if (dependent_type_p (type))
     564                 :            :         ;
     565                 :      27171 :       else if (id != this_identifier && by_reference_p)
     566                 :            :         {
     567                 :      25882 :           if (!lvalue_p (initializer))
     568                 :            :             {
     569                 :          3 :               error ("cannot capture %qE by reference", initializer);
     570                 :          3 :               return error_mark_node;
     571                 :            :             }
     572                 :            :         }
     573                 :            :       else
     574                 :            :         {
     575                 :            :           /* Capture by copy requires a complete type.  */
     576                 :       1289 :           type = complete_type (type);
     577                 :       1289 :           if (!COMPLETE_TYPE_P (type))
     578                 :            :             {
     579                 :          6 :               error ("capture by copy of incomplete type %qT", type);
     580                 :          6 :               cxx_incomplete_type_inform (type);
     581                 :          6 :               return error_mark_node;
     582                 :            :             }
     583                 :       1283 :           else if (!verify_type_context (input_location,
     584                 :            :                                          TCTX_CAPTURE_BY_COPY, type))
     585                 :          0 :             return error_mark_node;
     586                 :            :         }
     587                 :            :     }
     588                 :            : 
     589                 :            :   /* Add __ to the beginning of the field name so that user code
     590                 :            :      won't find the field with name lookup.  We can't just leave the name
     591                 :            :      unset because template instantiation uses the name to find
     592                 :            :      instantiated fields.  */
     593                 :      34707 :   buf = (char *) alloca (IDENTIFIER_LENGTH (id) + 3);
     594                 :      34707 :   buf[1] = buf[0] = '_';
     595                 :      34707 :   memcpy (buf + 2, IDENTIFIER_POINTER (id),
     596                 :      34707 :           IDENTIFIER_LENGTH (id) + 1);
     597                 :      34707 :   name = get_identifier (buf);
     598                 :            : 
     599                 :      34707 :   if (variadic)
     600                 :            :     {
     601                 :        323 :       type = make_pack_expansion (type);
     602                 :        323 :       if (explicit_init_p)
     603                 :            :         /* With an explicit initializer 'type' is auto, which isn't really a
     604                 :            :            parameter pack in this context.  We will want as many fields as we
     605                 :            :            have elements in the expansion of the initializer, so use its packs
     606                 :            :            instead.  */
     607                 :        590 :         PACK_EXPANSION_PARAMETER_PACKS (type)
     608                 :        295 :           = uses_parameter_packs (initializer);
     609                 :            :     }
     610                 :            : 
     611                 :            :   /* Make member variable.  */
     612                 :      34707 :   member = build_decl (input_location, FIELD_DECL, name, type);
     613                 :      34707 :   DECL_VLA_CAPTURE_P (member) = vla;
     614                 :            : 
     615                 :      34707 :   if (!explicit_init_p)
     616                 :            :     /* Normal captures are invisible to name lookup but uses are replaced
     617                 :            :        with references to the capture field; we implement this by only
     618                 :            :        really making them invisible in unevaluated context; see
     619                 :            :        qualify_lookup.  For now, let's make explicitly initialized captures
     620                 :            :        always visible.  */
     621                 :      34174 :     DECL_NORMAL_CAPTURE_P (member) = true;
     622                 :            : 
     623                 :      34707 :   if (id == this_identifier)
     624                 :       1821 :     LAMBDA_EXPR_THIS_CAPTURE (lambda) = member;
     625                 :            : 
     626                 :            :   /* Add it to the appropriate closure class if we've started it.  */
     627                 :      34707 :   if (current_class_type
     628                 :      34707 :       && current_class_type == LAMBDA_EXPR_CLOSURE (lambda))
     629                 :            :     {
     630                 :      28934 :       if (COMPLETE_TYPE_P (current_class_type))
     631                 :          0 :         internal_error ("trying to capture %qD in instantiation of "
     632                 :            :                         "generic lambda", id);
     633                 :      28934 :       finish_member_declaration (member);
     634                 :            :     }
     635                 :            : 
     636                 :      34707 :   tree listmem = member;
     637                 :      34707 :   if (variadic)
     638                 :            :     {
     639                 :        323 :       listmem = make_pack_expansion (member);
     640                 :        323 :       initializer = orig_init;
     641                 :            :     }
     642                 :      34707 :   LAMBDA_EXPR_CAPTURE_LIST (lambda)
     643                 :      34707 :     = tree_cons (listmem, initializer, LAMBDA_EXPR_CAPTURE_LIST (lambda));
     644                 :            : 
     645                 :      34707 :   if (LAMBDA_EXPR_CLOSURE (lambda))
     646                 :      28934 :     return build_capture_proxy (member, initializer);
     647                 :            :   /* For explicit captures we haven't started the function yet, so we wait
     648                 :            :      and build the proxy from cp_parser_lambda_body.  */
     649                 :       5773 :   LAMBDA_CAPTURE_EXPLICIT_P (LAMBDA_EXPR_CAPTURE_LIST (lambda)) = true;
     650                 :       5773 :   return NULL_TREE;
     651                 :            : }
     652                 :            : 
     653                 :            : /* Register all the capture members on the list CAPTURES, which is the
     654                 :            :    LAMBDA_EXPR_CAPTURE_LIST for the lambda after the introducer.  */
     655                 :            : 
     656                 :            : void
     657                 :      66243 : register_capture_members (tree captures)
     658                 :            : {
     659                 :      66243 :   if (captures == NULL_TREE)
     660                 :            :     return;
     661                 :            : 
     662                 :      22523 :   register_capture_members (TREE_CHAIN (captures));
     663                 :            : 
     664                 :      22523 :   tree field = TREE_PURPOSE (captures);
     665                 :      22523 :   if (PACK_EXPANSION_P (field))
     666                 :        323 :     field = PACK_EXPANSION_PATTERN (field);
     667                 :            : 
     668                 :      22523 :   finish_member_declaration (field);
     669                 :            : }
     670                 :            : 
     671                 :            : /* Similar to add_capture, except this works on a stack of nested lambdas.
     672                 :            :    BY_REFERENCE_P in this case is derived from the default capture mode.
     673                 :            :    Returns the capture for the lambda at the bottom of the stack.  */
     674                 :            : 
     675                 :            : tree
     676                 :      28807 : add_default_capture (tree lambda_stack, tree id, tree initializer)
     677                 :            : {
     678                 :      28807 :   bool this_capture_p = (id == this_identifier);
     679                 :      28807 :   tree var = NULL_TREE;
     680                 :      28807 :   tree saved_class_type = current_class_type;
     681                 :            : 
     682                 :      57765 :   for (tree node = lambda_stack;
     683                 :      57765 :        node;
     684                 :      28958 :        node = TREE_CHAIN (node))
     685                 :            :     {
     686                 :      28958 :       tree lambda = TREE_VALUE (node);
     687                 :            : 
     688                 :      28958 :       current_class_type = LAMBDA_EXPR_CLOSURE (lambda);
     689                 :      31085 :       if (DECL_PACK_P (initializer))
     690                 :          0 :         initializer = make_pack_expansion (initializer);
     691                 :      28958 :       var = add_capture (lambda,
     692                 :            :                             id,
     693                 :            :                             initializer,
     694                 :            :                             /*by_reference_p=*/
     695                 :            :                             (this_capture_p
     696                 :      57403 :                              || (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda)
     697                 :            :                                  == CPLD_REFERENCE)),
     698                 :            :                             /*explicit_init_p=*/false);
     699                 :      28958 :       initializer = convert_from_reference (var);
     700                 :            : 
     701                 :            :       /* Warn about deprecated implicit capture of this via [=].  */
     702                 :      28958 :       if (cxx_dialect >= cxx2a
     703                 :       2608 :           && this_capture_p
     704                 :      29074 :           && LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda) == CPLD_COPY)
     705                 :            :         {
     706                 :         38 :           if (warning_at (LAMBDA_EXPR_LOCATION (lambda), OPT_Wdeprecated,
     707                 :            :                           "implicit capture of %qE via %<[=]%> is deprecated "
     708                 :            :                           "in C++20", this_identifier))
     709                 :         34 :             inform (LAMBDA_EXPR_LOCATION (lambda), "add explicit %<this%> or "
     710                 :            :                     "%<*this%> capture");
     711                 :            :         }
     712                 :            :     }
     713                 :            : 
     714                 :      28807 :   current_class_type = saved_class_type;
     715                 :            : 
     716                 :      28807 :   return var;
     717                 :            : }
     718                 :            : 
     719                 :            : /* Return the capture pertaining to a use of 'this' in LAMBDA, in the
     720                 :            :    form of an INDIRECT_REF, possibly adding it through default
     721                 :            :    capturing, if ADD_CAPTURE_P is nonzero.  If ADD_CAPTURE_P is negative,
     722                 :            :    try to capture but don't complain if we can't.  */
     723                 :            : 
     724                 :            : tree
     725                 :       4346 : lambda_expr_this_capture (tree lambda, int add_capture_p)
     726                 :            : {
     727                 :       4346 :   tree result;
     728                 :            : 
     729                 :       4346 :   tree this_capture = LAMBDA_EXPR_THIS_CAPTURE (lambda);
     730                 :            : 
     731                 :            :   /* In unevaluated context this isn't an odr-use, so don't capture.  */
     732                 :       4346 :   if (cp_unevaluated_operand)
     733                 :         27 :     add_capture_p = false;
     734                 :            : 
     735                 :            :   /* Try to default capture 'this' if we can.  */
     736                 :       4346 :   if (!this_capture)
     737                 :            :     {
     738                 :            :       tree lambda_stack = NULL_TREE;
     739                 :        611 :       tree init = NULL_TREE;
     740                 :            : 
     741                 :            :       /* If we are in a lambda function, we can move out until we hit:
     742                 :            :            1. a non-lambda function or NSDMI,
     743                 :            :            2. a lambda function capturing 'this', or
     744                 :            :            3. a non-default capturing lambda function.  */
     745                 :            :       for (tree tlambda = lambda; ;)
     746                 :            :         {
     747                 :        611 :           if (add_capture_p
     748                 :       1143 :               && LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (tlambda) == CPLD_NONE)
     749                 :            :             /* tlambda won't let us capture 'this'.  */
     750                 :            :             break;
     751                 :            : 
     752                 :        595 :           if (add_capture_p)
     753                 :        516 :             lambda_stack = tree_cons (NULL_TREE,
     754                 :            :                                       tlambda,
     755                 :            :                                       lambda_stack);
     756                 :            : 
     757                 :        595 :           tree closure = LAMBDA_EXPR_CLOSURE (tlambda);
     758                 :        595 :           tree containing_function
     759                 :        595 :             = decl_function_context (TYPE_NAME (closure));
     760                 :            : 
     761                 :        595 :           tree ex = LAMBDA_EXPR_EXTRA_SCOPE (tlambda);
     762                 :        595 :           if (ex && TREE_CODE (ex) == FIELD_DECL)
     763                 :            :             {
     764                 :            :               /* Lambda in an NSDMI.  We don't have a function to look up
     765                 :            :                  'this' in, but we can find (or rebuild) the fake one from
     766                 :            :                  inject_this_parameter.  */
     767                 :         51 :               if (!containing_function && !COMPLETE_TYPE_P (closure))
     768                 :            :                 /* If we're parsing a lambda in a non-local class,
     769                 :            :                    we can find the fake 'this' in scope_chain.  */
     770                 :         21 :                 init = scope_chain->x_current_class_ptr;
     771                 :            :               else
     772                 :            :                 /* Otherwise it's either gone or buried in
     773                 :            :                    function_context_stack, so make another.  */
     774                 :          6 :                 init = build_this_parm (NULL_TREE, DECL_CONTEXT (ex),
     775                 :            :                                         TYPE_UNQUALIFIED);
     776                 :         54 :               gcc_checking_assert
     777                 :            :                 (init && (TREE_TYPE (TREE_TYPE (init))
     778                 :            :                           == current_nonlambda_class_type ()));
     779                 :            :               break;
     780                 :            :             }
     781                 :            : 
     782                 :        568 :           if (containing_function == NULL_TREE)
     783                 :            :             /* We ran out of scopes; there's no 'this' to capture.  */
     784                 :            :             break;
     785                 :            : 
     786                 :       1192 :           if (!LAMBDA_FUNCTION_P (containing_function))
     787                 :            :             {
     788                 :            :               /* We found a non-lambda function.  */
     789                 :        528 :               if (DECL_NONSTATIC_MEMBER_FUNCTION_P (containing_function))
     790                 :            :                 /* First parameter is 'this'.  */
     791                 :        528 :                 init = DECL_ARGUMENTS (containing_function);
     792                 :            :               break;
     793                 :            :             }
     794                 :            : 
     795                 :         34 :           tlambda
     796                 :         34 :             = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function));
     797                 :            : 
     798                 :         34 :           if (LAMBDA_EXPR_THIS_CAPTURE (tlambda))
     799                 :            :             {
     800                 :            :               /* An outer lambda has already captured 'this'.  */
     801                 :        586 :               init = LAMBDA_EXPR_THIS_CAPTURE (tlambda);
     802                 :            :               break;
     803                 :            :             }
     804                 :            :         }
     805                 :            : 
     806                 :        586 :       if (init)
     807                 :            :         {
     808                 :        564 :           if (add_capture_p)
     809                 :        491 :             this_capture = add_default_capture (lambda_stack,
     810                 :            :                                                 /*id=*/this_identifier,
     811                 :            :                                                 init);
     812                 :            :           else
     813                 :            :             this_capture = init;
     814                 :            :         }
     815                 :            :     }
     816                 :            : 
     817                 :       4346 :   if (cp_unevaluated_operand)
     818                 :            :     result = this_capture;
     819                 :       4319 :   else if (!this_capture)
     820                 :            :     {
     821                 :         19 :       if (add_capture_p == 1)
     822                 :            :         {
     823                 :         16 :           error ("%<this%> was not captured for this lambda function");
     824                 :         16 :           result = error_mark_node;
     825                 :            :         }
     826                 :            :       else
     827                 :            :         result = NULL_TREE;
     828                 :            :     }
     829                 :            :   else
     830                 :            :     {
     831                 :            :       /* To make sure that current_class_ref is for the lambda.  */
     832                 :       4300 :       gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref))
     833                 :            :                   == LAMBDA_EXPR_CLOSURE (lambda));
     834                 :            : 
     835                 :       4300 :       result = this_capture;
     836                 :            : 
     837                 :            :       /* If 'this' is captured, each use of 'this' is transformed into an
     838                 :            :          access to the corresponding unnamed data member of the closure
     839                 :            :          type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast
     840                 :            :          ensures that the transformed expression is an rvalue. ] */
     841                 :       4300 :       result = rvalue (result);
     842                 :            :     }
     843                 :            : 
     844                 :       4346 :   return result;
     845                 :            : }
     846                 :            : 
     847                 :            : /* Return the innermost LAMBDA_EXPR we're currently in, if any.  */
     848                 :            : 
     849                 :            : tree
     850                 :    5841610 : current_lambda_expr (void)
     851                 :            : {
     852                 :    5841610 :   tree type = current_class_type;
     853                 :   12301500 :   while (type && !LAMBDA_TYPE_P (type))
     854                 :    3152760 :     type = decl_type_context (TYPE_NAME (type));
     855                 :    5841610 :   if (type)
     856                 :     154372 :     return CLASSTYPE_LAMBDA_EXPR (type);
     857                 :            :   else
     858                 :            :     return NULL_TREE;
     859                 :            : }
     860                 :            : 
     861                 :            : /* Return the current LAMBDA_EXPR, if this is a resolvable dummy
     862                 :            :    object.  NULL otherwise..  */
     863                 :            : 
     864                 :            : static tree
     865                 :   20906600 : resolvable_dummy_lambda (tree object)
     866                 :            : {
     867                 :   20906600 :   if (!is_dummy_object (object))
     868                 :            :     return NULL_TREE;
     869                 :            : 
     870                 :    3272540 :   tree type = TYPE_MAIN_VARIANT (TREE_TYPE (object));
     871                 :    3272540 :   gcc_assert (!TYPE_PTR_P (type));
     872                 :            : 
     873                 :    3272540 :   if (type != current_class_type
     874                 :    2519400 :       && current_class_type
     875                 :    1828560 :       && LAMBDA_TYPE_P (current_class_type)
     876                 :       3737 :       && lambda_function (current_class_type)
     877                 :    3276260 :       && DERIVED_FROM_P (type, nonlambda_method_basetype()))
     878                 :       3623 :     return CLASSTYPE_LAMBDA_EXPR (current_class_type);
     879                 :            : 
     880                 :            :   return NULL_TREE;
     881                 :            : }
     882                 :            : 
     883                 :            : /* We don't want to capture 'this' until we know we need it, i.e. after
     884                 :            :    overload resolution has chosen a non-static member function.  At that
     885                 :            :    point we call this function to turn a dummy object into a use of the
     886                 :            :    'this' capture.  */
     887                 :            : 
     888                 :            : tree
     889                 :   15778300 : maybe_resolve_dummy (tree object, bool add_capture_p)
     890                 :            : {
     891                 :   15778300 :   if (tree lam = resolvable_dummy_lambda (object))
     892                 :       3389 :     if (tree cap = lambda_expr_this_capture (lam, add_capture_p))
     893                 :       3389 :       if (cap != error_mark_node)
     894                 :       3383 :         object = build_fold_indirect_ref (cap);
     895                 :            : 
     896                 :   15778300 :   return object;
     897                 :            : }
     898                 :            : 
     899                 :            : /* When parsing a generic lambda containing an argument-dependent
     900                 :            :    member function call we defer overload resolution to instantiation
     901                 :            :    time.  But we have to know now whether to capture this or not.
     902                 :            :    Do that if FNS contains any non-static fns.
     903                 :            :    The std doesn't anticipate this case, but I expect this to be the
     904                 :            :    outcome of discussion.  */
     905                 :            : 
     906                 :            : void
     907                 :    5128240 : maybe_generic_this_capture (tree object, tree fns)
     908                 :            : {
     909                 :    5128240 :   if (tree lam = resolvable_dummy_lambda (object))
     910                 :        234 :     if (!LAMBDA_EXPR_THIS_CAPTURE (lam))
     911                 :            :       {
     912                 :            :         /* We've not yet captured, so look at the function set of
     913                 :            :            interest.  */
     914                 :         55 :         if (BASELINK_P (fns))
     915                 :         49 :           fns = BASELINK_FUNCTIONS (fns);
     916                 :         55 :         bool id_expr = TREE_CODE (fns) == TEMPLATE_ID_EXPR;
     917                 :         55 :         if (id_expr)
     918                 :         12 :           fns = TREE_OPERAND (fns, 0);
     919                 :            : 
     920                 :        119 :         for (lkp_iterator iter (fns); iter; ++iter)
     921                 :         52 :           if (((!id_expr && TREE_CODE (*iter) != USING_DECL)
     922                 :         15 :                || TREE_CODE (*iter) == TEMPLATE_DECL)
     923                 :        125 :               && DECL_NONSTATIC_MEMBER_FUNCTION_P (*iter))
     924                 :            :             {
     925                 :            :               /* Found a non-static member.  Capture this.  */
     926                 :         55 :               lambda_expr_this_capture (lam, /*maybe*/-1);
     927                 :         55 :               break;
     928                 :            :             }
     929                 :            :       }
     930                 :    5128240 : }
     931                 :            : 
     932                 :            : /* Returns the innermost non-lambda function.  */
     933                 :            : 
     934                 :            : tree
     935                 :         17 : current_nonlambda_function (void)
     936                 :            : {
     937                 :         17 :   tree fn = current_function_decl;
     938                 :         37 :   while (fn && LAMBDA_FUNCTION_P (fn))
     939                 :          3 :     fn = decl_function_context (fn);
     940                 :         17 :   return fn;
     941                 :            : }
     942                 :            : 
     943                 :            : /* Returns the method basetype of the innermost non-lambda function, including
     944                 :            :    a hypothetical constructor if inside an NSDMI, or NULL_TREE if none.  */
     945                 :            : 
     946                 :            : tree
     947                 :       4072 : nonlambda_method_basetype (void)
     948                 :            : {
     949                 :       4072 :   if (!current_class_ref)
     950                 :            :     return NULL_TREE;
     951                 :            : 
     952                 :       3865 :   tree type = current_class_type;
     953                 :       7730 :   if (!type || !LAMBDA_TYPE_P (type))
     954                 :            :     return type;
     955                 :            : 
     956                 :       3827 :   while (true)
     957                 :            :     {
     958                 :       7654 :       tree lam = CLASSTYPE_LAMBDA_EXPR (type);
     959                 :       3827 :       tree ex = LAMBDA_EXPR_EXTRA_SCOPE (lam);
     960                 :       3827 :       if (ex && TREE_CODE (ex) == FIELD_DECL)
     961                 :            :         /* Lambda in an NSDMI.  */
     962                 :         24 :         return DECL_CONTEXT (ex);
     963                 :            : 
     964                 :       3803 :       tree fn = TYPE_CONTEXT (type);
     965                 :       3803 :       if (!fn || TREE_CODE (fn) != FUNCTION_DECL
     966                 :       7597 :           || !DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
     967                 :            :         /* No enclosing non-lambda method.  */
     968                 :            :         return NULL_TREE;
     969                 :       3798 :       if (!LAMBDA_FUNCTION_P (fn))
     970                 :            :         /* Found an enclosing non-lambda method.  */
     971                 :       3636 :         return TYPE_METHOD_BASETYPE (TREE_TYPE (fn));
     972                 :       3827 :       type = DECL_CONTEXT (fn);
     973                 :            :     }
     974                 :            : }
     975                 :            : 
     976                 :            : /* Like current_scope, but looking through lambdas.  */
     977                 :            : 
     978                 :            : tree
     979                 :    5841810 : current_nonlambda_scope (void)
     980                 :            : {
     981                 :    5841810 :   tree scope = current_scope ();
     982                 :    5848570 :   for (;;)
     983                 :            :     {
     984                 :    5855330 :       if (TREE_CODE (scope) == FUNCTION_DECL
     985                 :   11446100 :           && LAMBDA_FUNCTION_P (scope))
     986                 :            :         {
     987                 :       6759 :           scope = CP_TYPE_CONTEXT (DECL_CONTEXT (scope));
     988                 :       6759 :           continue;
     989                 :            :         }
     990                 :    6190640 :       else if (LAMBDA_TYPE_P (scope))
     991                 :            :         {
     992                 :          0 :           scope = CP_TYPE_CONTEXT (scope);
     993                 :          0 :           continue;
     994                 :            :         }
     995                 :    5841810 :       break;
     996                 :            :     }
     997                 :    5841810 :   return scope;
     998                 :            : }
     999                 :            : 
    1000                 :            : /* Helper function for maybe_add_lambda_conv_op; build a CALL_EXPR with
    1001                 :            :    indicated FN and NARGS, but do not initialize the return type or any of the
    1002                 :            :    argument slots.  */
    1003                 :            : 
    1004                 :            : static tree
    1005                 :       8698 : prepare_op_call (tree fn, int nargs)
    1006                 :            : {
    1007                 :       8698 :   tree t;
    1008                 :            : 
    1009                 :       8698 :   t = build_vl_exp (CALL_EXPR, nargs + 3);
    1010                 :       8698 :   CALL_EXPR_FN (t) = fn;
    1011                 :       8698 :   CALL_EXPR_STATIC_CHAIN (t) = NULL;
    1012                 :            : 
    1013                 :       8698 :   return t;
    1014                 :            : }
    1015                 :            : 
    1016                 :            : /* Return true iff CALLOP is the op() for a generic lambda.  */
    1017                 :            : 
    1018                 :            : bool
    1019                 :      48579 : generic_lambda_fn_p (tree callop)
    1020                 :            : {
    1021                 :     145737 :   return (LAMBDA_FUNCTION_P (callop)
    1022                 :      48579 :           && DECL_TEMPLATE_INFO (callop)
    1023                 :      83212 :           && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (callop)));
    1024                 :            : }
    1025                 :            : 
    1026                 :            : /* If the closure TYPE has a static op(), also add a conversion to function
    1027                 :            :    pointer.  */
    1028                 :            : 
    1029                 :            : void
    1030                 :      43685 : maybe_add_lambda_conv_op (tree type)
    1031                 :            : {
    1032                 :      43685 :   bool nested = (cfun != NULL);
    1033                 :      43685 :   bool nested_def = decl_function_context (TYPE_MAIN_DECL (type));
    1034                 :      43685 :   tree callop = lambda_function (type);
    1035                 :      43685 :   tree lam = CLASSTYPE_LAMBDA_EXPR (type);
    1036                 :            : 
    1037                 :      43685 :   if (LAMBDA_EXPR_CAPTURE_LIST (lam) != NULL_TREE
    1038                 :      43685 :       || LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam) != CPLD_NONE)
    1039                 :      25395 :     return;
    1040                 :            : 
    1041                 :      21120 :   if (processing_template_decl)
    1042                 :            :     return;
    1043                 :            : 
    1044                 :      18324 :   bool const generic_lambda_p = generic_lambda_fn_p (callop);
    1045                 :            : 
    1046                 :      18324 :   if (!generic_lambda_p && undeduced_auto_decl (callop))
    1047                 :            :     {
    1048                 :            :       /* If the op() wasn't deduced due to errors, give up.  */
    1049                 :         19 :       gcc_assert (errorcount || sorrycount);
    1050                 :            :       return;
    1051                 :            :     }
    1052                 :            : 
    1053                 :            :   /* Non-generic non-capturing lambdas only have a conversion function to
    1054                 :            :      pointer to function when the trailing requires-clause's constraints are
    1055                 :            :      satisfied.  */
    1056                 :      18305 :   if (!generic_lambda_p && !constraints_satisfied_p (callop))
    1057                 :            :     return;
    1058                 :            : 
    1059                 :            :   /* Non-template conversion operators are defined directly with build_call_a
    1060                 :            :      and using DIRECT_ARGVEC for arguments (including 'this').  Templates are
    1061                 :            :      deferred and the CALL is built in-place.  In the case of a deduced return
    1062                 :            :      call op, the decltype expression, DECLTYPE_CALL, used as a substitute for
    1063                 :            :      the return type is also built in-place.  The arguments of DECLTYPE_CALL in
    1064                 :            :      the return expression may differ in flags from those in the body CALL.  In
    1065                 :            :      particular, parameter pack expansions are marked PACK_EXPANSION_LOCAL_P in
    1066                 :            :      the body CALL, but not in DECLTYPE_CALL.  */
    1067                 :            : 
    1068                 :      18302 :   vec<tree, va_gc> *direct_argvec = 0;
    1069                 :      18302 :   tree decltype_call = 0, call = 0;
    1070                 :      18302 :   tree optype = TREE_TYPE (callop);
    1071                 :      18302 :   tree fn_result = TREE_TYPE (optype);
    1072                 :            : 
    1073                 :      18302 :   tree thisarg = build_int_cst (TREE_TYPE (DECL_ARGUMENTS (callop)), 0);
    1074                 :      18302 :   if (generic_lambda_p)
    1075                 :            :     {
    1076                 :       4378 :       ++processing_template_decl;
    1077                 :            : 
    1078                 :            :       /* Prepare the dependent member call for the static member function
    1079                 :            :          '_FUN' and, potentially, prepare another call to be used in a decltype
    1080                 :            :          return expression for a deduced return call op to allow for simple
    1081                 :            :          implementation of the conversion operator.  */
    1082                 :            : 
    1083                 :       4378 :       tree instance = cp_build_fold_indirect_ref (thisarg);
    1084                 :       4378 :       tree objfn = lookup_template_function (DECL_NAME (callop),
    1085                 :       4378 :                                              DECL_TI_ARGS (callop));
    1086                 :       4378 :       objfn = build_min (COMPONENT_REF, NULL_TREE,
    1087                 :            :                          instance, objfn, NULL_TREE);
    1088                 :       4378 :       int nargs = list_length (DECL_ARGUMENTS (callop)) - 1;
    1089                 :            : 
    1090                 :       4378 :       call = prepare_op_call (objfn, nargs);
    1091                 :       4378 :       if (type_uses_auto (fn_result))
    1092                 :       4320 :         decltype_call = prepare_op_call (objfn, nargs);
    1093                 :            :     }
    1094                 :            :   else
    1095                 :            :     {
    1096                 :      13924 :       direct_argvec = make_tree_vector ();
    1097                 :      13924 :       direct_argvec->quick_push (thisarg);
    1098                 :            :     }
    1099                 :            : 
    1100                 :            :   /* Copy CALLOP's argument list (as per 'copy_list') as FN_ARGS in order to
    1101                 :            :      declare the static member function "_FUN" below.  For each arg append to
    1102                 :            :      DIRECT_ARGVEC (for the non-template case) or populate the pre-allocated
    1103                 :            :      call args (for the template case).  If a parameter pack is found, expand
    1104                 :            :      it, flagging it as PACK_EXPANSION_LOCAL_P for the body call.  */
    1105                 :            : 
    1106                 :      18302 :   tree fn_args = NULL_TREE;
    1107                 :      18302 :   {
    1108                 :      18302 :     int ix = 0;
    1109                 :      18302 :     tree src = DECL_CHAIN (DECL_ARGUMENTS (callop));
    1110                 :      18302 :     tree tgt = NULL;
    1111                 :            : 
    1112                 :      25519 :     while (src)
    1113                 :            :       {
    1114                 :       7217 :         tree new_node = copy_node (src);
    1115                 :            : 
    1116                 :            :         /* Clear TREE_ADDRESSABLE on thunk arguments.  */
    1117                 :       7217 :         TREE_ADDRESSABLE (new_node) = 0;
    1118                 :            : 
    1119                 :       7217 :         if (!fn_args)
    1120                 :       4959 :           fn_args = tgt = new_node;
    1121                 :            :         else
    1122                 :            :           {
    1123                 :       2258 :             TREE_CHAIN (tgt) = new_node;
    1124                 :       2258 :             tgt = new_node;
    1125                 :            :           }
    1126                 :            : 
    1127                 :       7217 :         mark_exp_read (tgt);
    1128                 :            : 
    1129                 :       7217 :         if (generic_lambda_p)
    1130                 :            :           {
    1131                 :       6574 :             tree a = tgt;
    1132                 :       6574 :             if (DECL_PACK_P (tgt))
    1133                 :            :               {
    1134                 :        131 :                 a = make_pack_expansion (a);
    1135                 :        262 :                 PACK_EXPANSION_LOCAL_P (a) = true;
    1136                 :            :               }
    1137                 :       6574 :             CALL_EXPR_ARG (call, ix) = a;
    1138                 :            : 
    1139                 :       6574 :             if (decltype_call)
    1140                 :            :               {
    1141                 :            :                 /* Avoid capturing variables in this context.  */
    1142                 :       6501 :                 ++cp_unevaluated_operand;
    1143                 :       6501 :                 CALL_EXPR_ARG (decltype_call, ix) = forward_parm (tgt);
    1144                 :       6501 :                 --cp_unevaluated_operand;
    1145                 :            :               }
    1146                 :            : 
    1147                 :       6574 :             ++ix;
    1148                 :            :           }
    1149                 :            :         else
    1150                 :        643 :           vec_safe_push (direct_argvec, tgt);
    1151                 :            : 
    1152                 :       7217 :         src = TREE_CHAIN (src);
    1153                 :            :       }
    1154                 :            :   }
    1155                 :            : 
    1156                 :      18302 :   if (generic_lambda_p)
    1157                 :            :     {
    1158                 :       4378 :       if (decltype_call)
    1159                 :            :         {
    1160                 :       4320 :           fn_result = finish_decltype_type
    1161                 :       4320 :             (decltype_call, /*id_expression_or_member_access_p=*/false,
    1162                 :            :              tf_warning_or_error);
    1163                 :            :         }
    1164                 :            :     }
    1165                 :            :   else
    1166                 :      13924 :     call = build_call_a (callop,
    1167                 :      13924 :                          direct_argvec->length (),
    1168                 :            :                          direct_argvec->address ());
    1169                 :            : 
    1170                 :      18302 :   CALL_FROM_THUNK_P (call) = 1;
    1171                 :      18302 :   SET_EXPR_LOCATION (call, UNKNOWN_LOCATION);
    1172                 :            : 
    1173                 :      36604 :   tree stattype = build_function_type (fn_result, FUNCTION_ARG_CHAIN (callop));
    1174                 :      18302 :   stattype = (cp_build_type_attribute_variant
    1175                 :      18302 :               (stattype, TYPE_ATTRIBUTES (optype)));
    1176                 :      18302 :   if (flag_noexcept_type
    1177                 :      28718 :       && TYPE_NOTHROW_P (TREE_TYPE (callop)))
    1178                 :          7 :     stattype = build_exception_variant (stattype, noexcept_true_spec);
    1179                 :            : 
    1180                 :      18302 :   if (generic_lambda_p)
    1181                 :       4378 :     --processing_template_decl;
    1182                 :            : 
    1183                 :            :   /* First build up the conversion op.  */
    1184                 :            : 
    1185                 :      18302 :   tree rettype = build_pointer_type (stattype);
    1186                 :      18302 :   tree name = make_conv_op_name (rettype);
    1187                 :      18302 :   tree thistype = cp_build_qualified_type (type, TYPE_QUAL_CONST);
    1188                 :      18302 :   tree fntype = build_method_type_directly (thistype, rettype, void_list_node);
    1189                 :      18302 :   tree convfn = build_lang_decl (FUNCTION_DECL, name, fntype);
    1190                 :      18302 :   SET_DECL_LANGUAGE (convfn, lang_cplusplus);
    1191                 :      18302 :   tree fn = convfn;
    1192                 :      18302 :   DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (callop);
    1193                 :      18302 :   SET_DECL_ALIGN (fn, MINIMUM_METHOD_BOUNDARY);
    1194                 :      18302 :   grokclassfn (type, fn, NO_SPECIAL);
    1195                 :      18302 :   set_linkage_according_to_type (type, fn);
    1196                 :      18302 :   rest_of_decl_compilation (fn, namespace_bindings_p (), at_eof);
    1197                 :      18302 :   DECL_IN_AGGR_P (fn) = 1;
    1198                 :      18302 :   DECL_ARTIFICIAL (fn) = 1;
    1199                 :      18302 :   DECL_NOT_REALLY_EXTERN (fn) = 1;
    1200                 :      18302 :   DECL_DECLARED_INLINE_P (fn) = 1;
    1201                 :      54906 :   DECL_DECLARED_CONSTEXPR_P (fn) = DECL_DECLARED_CONSTEXPR_P (callop);
    1202                 :      36604 :   if (DECL_IMMEDIATE_FUNCTION_P (callop))
    1203                 :          8 :     SET_DECL_IMMEDIATE_FUNCTION_P (fn);
    1204                 :      18302 :   DECL_ARGUMENTS (fn) = build_this_parm (fn, fntype, TYPE_QUAL_CONST);
    1205                 :            : 
    1206                 :      18302 :   if (nested_def)
    1207                 :      13936 :     DECL_INTERFACE_KNOWN (fn) = 1;
    1208                 :            : 
    1209                 :      18302 :   if (generic_lambda_p)
    1210                 :       4378 :     fn = add_inherited_template_parms (fn, DECL_TI_TEMPLATE (callop));
    1211                 :            : 
    1212                 :      18302 :   add_method (type, fn, false);
    1213                 :            : 
    1214                 :            :   /* Generic thunk code fails for varargs; we'll complain in mark_used if
    1215                 :            :      the conversion op is used.  */
    1216                 :      18302 :   if (varargs_function_p (callop))
    1217                 :            :     {
    1218                 :         24 :       DECL_DELETED_FN (fn) = 1;
    1219                 :         12 :       return;
    1220                 :            :     }
    1221                 :            : 
    1222                 :            :   /* Now build up the thunk to be returned.  */
    1223                 :            : 
    1224                 :      18290 :   tree statfn = build_lang_decl (FUNCTION_DECL, fun_identifier, stattype);
    1225                 :      18290 :   SET_DECL_LANGUAGE (statfn, lang_cplusplus);
    1226                 :      18290 :   fn = statfn;
    1227                 :      18290 :   DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (callop);
    1228                 :      18290 :   grokclassfn (type, fn, NO_SPECIAL);
    1229                 :      18290 :   set_linkage_according_to_type (type, fn);
    1230                 :      18290 :   rest_of_decl_compilation (fn, namespace_bindings_p (), at_eof);
    1231                 :      18290 :   DECL_IN_AGGR_P (fn) = 1;
    1232                 :      18290 :   DECL_ARTIFICIAL (fn) = 1;
    1233                 :      18290 :   DECL_NOT_REALLY_EXTERN (fn) = 1;
    1234                 :      18290 :   DECL_DECLARED_INLINE_P (fn) = 1;
    1235                 :      18290 :   DECL_STATIC_FUNCTION_P (fn) = 1;
    1236                 :      54870 :   DECL_DECLARED_CONSTEXPR_P (fn) = DECL_DECLARED_CONSTEXPR_P (callop);
    1237                 :      36580 :   if (DECL_IMMEDIATE_FUNCTION_P (callop))
    1238                 :          8 :     SET_DECL_IMMEDIATE_FUNCTION_P (fn);
    1239                 :      18290 :   DECL_ARGUMENTS (fn) = fn_args;
    1240                 :      25501 :   for (tree arg = fn_args; arg; arg = DECL_CHAIN (arg))
    1241                 :            :     {
    1242                 :            :       /* Avoid duplicate -Wshadow warnings.  */
    1243                 :       7211 :       DECL_NAME (arg) = NULL_TREE;
    1244                 :       7211 :       DECL_CONTEXT (arg) = fn;
    1245                 :            :     }
    1246                 :      18290 :   if (nested_def)
    1247                 :      13930 :     DECL_INTERFACE_KNOWN (fn) = 1;
    1248                 :            : 
    1249                 :      18290 :   if (generic_lambda_p)
    1250                 :       4372 :     fn = add_inherited_template_parms (fn, DECL_TI_TEMPLATE (callop));
    1251                 :            : 
    1252                 :      18290 :   if (flag_sanitize & SANITIZE_NULL)
    1253                 :            :     /* Don't UBsan this function; we're deliberately calling op() with a null
    1254                 :            :        object argument.  */
    1255                 :          7 :     add_no_sanitize_value (fn, SANITIZE_UNDEFINED);
    1256                 :            : 
    1257                 :      18290 :   add_method (type, fn, false);
    1258                 :            : 
    1259                 :      18290 :   if (nested)
    1260                 :      13930 :     push_function_context ();
    1261                 :            :   else
    1262                 :            :     /* Still increment function_depth so that we don't GC in the
    1263                 :            :        middle of an expression.  */
    1264                 :       4360 :     ++function_depth;
    1265                 :            : 
    1266                 :            :   /* Generate the body of the thunk.  */
    1267                 :            : 
    1268                 :      18290 :   start_preparsed_function (statfn, NULL_TREE,
    1269                 :            :                             SF_PRE_PARSED | SF_INCLASS_INLINE);
    1270                 :      18290 :   tree body = begin_function_body ();
    1271                 :      18290 :   tree compound_stmt = begin_compound_stmt (0);
    1272                 :      18290 :   if (!generic_lambda_p)
    1273                 :            :     {
    1274                 :      13918 :       set_flags_from_callee (call);
    1275                 :      13918 :       if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call)))
    1276                 :         90 :         call = build_cplus_new (TREE_TYPE (call), call, tf_warning_or_error);
    1277                 :            :     }
    1278                 :      18290 :   call = convert_from_reference (call);
    1279                 :      18290 :   finish_return_stmt (call);
    1280                 :            : 
    1281                 :      18290 :   finish_compound_stmt (compound_stmt);
    1282                 :      18290 :   finish_function_body (body);
    1283                 :            : 
    1284                 :      18290 :   fn = finish_function (/*inline_p=*/true);
    1285                 :      18290 :   if (!generic_lambda_p)
    1286                 :      13918 :     expand_or_defer_fn (fn);
    1287                 :            : 
    1288                 :            :   /* Generate the body of the conversion op.  */
    1289                 :            : 
    1290                 :      18290 :   start_preparsed_function (convfn, NULL_TREE,
    1291                 :            :                             SF_PRE_PARSED | SF_INCLASS_INLINE);
    1292                 :      18290 :   body = begin_function_body ();
    1293                 :      18290 :   compound_stmt = begin_compound_stmt (0);
    1294                 :            : 
    1295                 :            :   /* decl_needed_p needs to see that it's used.  */
    1296                 :      18290 :   TREE_USED (statfn) = 1;
    1297                 :      18290 :   finish_return_stmt (decay_conversion (statfn, tf_warning_or_error));
    1298                 :            : 
    1299                 :      18290 :   finish_compound_stmt (compound_stmt);
    1300                 :      18290 :   finish_function_body (body);
    1301                 :            : 
    1302                 :      18290 :   fn = finish_function (/*inline_p=*/true);
    1303                 :      18290 :   if (!generic_lambda_p)
    1304                 :      13918 :     expand_or_defer_fn (fn);
    1305                 :            : 
    1306                 :      18290 :   if (nested)
    1307                 :      13930 :     pop_function_context ();
    1308                 :            :   else
    1309                 :       4360 :     --function_depth;
    1310                 :            : }
    1311                 :            : 
    1312                 :            : /* True if FN is the static function "_FUN" that gets returned from the lambda
    1313                 :            :    conversion operator.  */
    1314                 :            : 
    1315                 :            : bool
    1316                 :        103 : lambda_static_thunk_p (tree fn)
    1317                 :            : {
    1318                 :        103 :   return (fn && TREE_CODE (fn) == FUNCTION_DECL
    1319                 :        103 :           && DECL_ARTIFICIAL (fn)
    1320                 :         15 :           && DECL_STATIC_FUNCTION_P (fn)
    1321                 :        111 :           && LAMBDA_TYPE_P (CP_DECL_CONTEXT (fn)));
    1322                 :            : }
    1323                 :            : 
    1324                 :            : /* Returns true iff VAL is a lambda-related declaration which should
    1325                 :            :    be ignored by unqualified lookup.  */
    1326                 :            : 
    1327                 :            : bool
    1328                 :  185600000 : is_lambda_ignored_entity (tree val)
    1329                 :            : {
    1330                 :            :   /* Look past normal, non-VLA capture proxies.  */
    1331                 :  185600000 :   if (is_normal_capture_proxy (val)
    1332                 :  185627000 :       && !variably_modified_type_p (TREE_TYPE (val), NULL_TREE))
    1333                 :            :     return true;
    1334                 :            : 
    1335                 :            :   /* Always ignore lambda fields, their names are only for debugging.  */
    1336                 :  185572000 :   if (TREE_CODE (val) == FIELD_DECL
    1337                 :  196175000 :       && CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (val)))
    1338                 :            :     return true;
    1339                 :            : 
    1340                 :            :   /* None of the lookups that use qualify_lookup want the op() from the
    1341                 :            :      lambda; they want the one from the enclosing class.  */
    1342                 :  191543000 :   if (TREE_CODE (val) == FUNCTION_DECL && LAMBDA_FUNCTION_P (val))
    1343                 :        511 :     return true;
    1344                 :            : 
    1345                 :            :   return false;
    1346                 :            : }
    1347                 :            : 
    1348                 :            : /* Lambdas that appear in variable initializer or default argument scope
    1349                 :            :    get that in their mangling, so we need to record it.  We might as well
    1350                 :            :    use the count for function and namespace scopes as well.  */
    1351                 :            : static GTY(()) tree lambda_scope;
    1352                 :            : static GTY(()) int lambda_count;
    1353                 :            : struct GTY(()) tree_int
    1354                 :            : {
    1355                 :            :   tree t;
    1356                 :            :   int i;
    1357                 :            : };
    1358                 :            : static GTY(()) vec<tree_int, va_gc> *lambda_scope_stack;
    1359                 :            : 
    1360                 :            : void
    1361                 :   23203500 : start_lambda_scope (tree decl)
    1362                 :            : {
    1363                 :   23203500 :   tree_int ti;
    1364                 :   23203500 :   gcc_assert (decl);
    1365                 :            :   /* Once we're inside a function, we ignore variable scope and just push
    1366                 :            :      the function again so that popping works properly.  */
    1367                 :   23203500 :   if (current_function_decl && TREE_CODE (decl) == VAR_DECL)
    1368                 :    2148860 :     decl = current_function_decl;
    1369                 :   23203500 :   ti.t = lambda_scope;
    1370                 :   23203500 :   ti.i = lambda_count;
    1371                 :   23203500 :   vec_safe_push (lambda_scope_stack, ti);
    1372                 :   23203500 :   if (lambda_scope != decl)
    1373                 :            :     {
    1374                 :            :       /* Don't reset the count if we're still in the same function.  */
    1375                 :   21054700 :       lambda_scope = decl;
    1376                 :   21054700 :       lambda_count = 0;
    1377                 :            :     }
    1378                 :   23203500 : }
    1379                 :            : 
    1380                 :            : void
    1381                 :      43660 : record_lambda_scope (tree lambda)
    1382                 :            : {
    1383                 :      43660 :   LAMBDA_EXPR_EXTRA_SCOPE (lambda) = lambda_scope;
    1384                 :      43660 :   LAMBDA_EXPR_DISCRIMINATOR (lambda) = lambda_count++;
    1385                 :      43660 : }
    1386                 :            : 
    1387                 :            : /* This lambda is an instantiation of a lambda in a template default argument
    1388                 :            :    that got no LAMBDA_EXPR_EXTRA_SCOPE, so this shouldn't either.  But we do
    1389                 :            :    need to use and increment the global count to avoid collisions.  */
    1390                 :            : 
    1391                 :            : void
    1392                 :        139 : record_null_lambda_scope (tree lambda)
    1393                 :            : {
    1394                 :        139 :   if (vec_safe_is_empty (lambda_scope_stack))
    1395                 :         65 :     record_lambda_scope (lambda);
    1396                 :            :   else
    1397                 :            :     {
    1398                 :         74 :       tree_int *p = lambda_scope_stack->begin();
    1399                 :         74 :       LAMBDA_EXPR_EXTRA_SCOPE (lambda) = p->t;
    1400                 :         74 :       LAMBDA_EXPR_DISCRIMINATOR (lambda) = p->i++;
    1401                 :            :     }
    1402                 :        139 :   gcc_assert (LAMBDA_EXPR_EXTRA_SCOPE (lambda) == NULL_TREE);
    1403                 :        139 : }
    1404                 :            : 
    1405                 :            : void
    1406                 :   23203500 : finish_lambda_scope (void)
    1407                 :            : {
    1408                 :   23203500 :   tree_int *p = &lambda_scope_stack->last ();
    1409                 :   23203500 :   if (lambda_scope != p->t)
    1410                 :            :     {
    1411                 :   21054600 :       lambda_scope = p->t;
    1412                 :   21054600 :       lambda_count = p->i;
    1413                 :            :     }
    1414                 :   23203500 :   lambda_scope_stack->pop ();
    1415                 :   23203500 : }
    1416                 :            : 
    1417                 :            : tree
    1418                 :      43685 : start_lambda_function (tree fco, tree lambda_expr)
    1419                 :            : {
    1420                 :            :   /* Let the front end know that we are going to be defining this
    1421                 :            :      function.  */
    1422                 :      43685 :   start_preparsed_function (fco,
    1423                 :            :                             NULL_TREE,
    1424                 :            :                             SF_PRE_PARSED | SF_INCLASS_INLINE);
    1425                 :            : 
    1426                 :      43685 :   tree body = begin_function_body ();
    1427                 :            : 
    1428                 :            :   /* Push the proxies for any explicit captures.  */
    1429                 :      88731 :   for (tree cap = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr); cap;
    1430                 :      22523 :        cap = TREE_CHAIN (cap))
    1431                 :      22523 :     build_capture_proxy (TREE_PURPOSE (cap), TREE_VALUE (cap));
    1432                 :            : 
    1433                 :      43685 :   return body;
    1434                 :            : }
    1435                 :            : 
    1436                 :            : /* Subroutine of prune_lambda_captures: CAP is a node in
    1437                 :            :    LAMBDA_EXPR_CAPTURE_LIST.  Return the variable it captures for which we
    1438                 :            :    might optimize away the capture, or NULL_TREE if there is no such
    1439                 :            :    variable.  */
    1440                 :            : 
    1441                 :            : static tree
    1442                 :         39 : var_to_maybe_prune (tree cap)
    1443                 :            : {
    1444                 :         39 :   if (LAMBDA_CAPTURE_EXPLICIT_P (cap))
    1445                 :            :     /* Don't prune explicit captures.  */
    1446                 :            :     return NULL_TREE;
    1447                 :            : 
    1448                 :         39 :   tree mem = TREE_PURPOSE (cap);
    1449                 :         78 :   if (!DECL_P (mem) || !DECL_NORMAL_CAPTURE_P (mem))
    1450                 :            :     /* Packs and init-captures aren't captures of constant vars.  */
    1451                 :            :     return NULL_TREE;
    1452                 :            : 
    1453                 :         39 :   tree init = TREE_VALUE (cap);
    1454                 :         39 :   if (is_normal_capture_proxy (init))
    1455                 :          0 :     init = DECL_CAPTURED_VARIABLE (init);
    1456                 :         39 :   if (decl_constant_var_p (init))
    1457                 :         35 :     return init;
    1458                 :            : 
    1459                 :            :   return NULL_TREE;
    1460                 :            : }
    1461                 :            : 
    1462                 :            : /* walk_tree helper for prune_lambda_captures: Remember which capture proxies
    1463                 :            :    for constant variables are actually used in the lambda body.
    1464                 :            : 
    1465                 :            :    There will always be a DECL_EXPR for the capture proxy; remember it when we
    1466                 :            :    see it, but replace it with any other use.  */
    1467                 :            : 
    1468                 :            : static tree
    1469                 :        446 : mark_const_cap_r (tree *t, int *walk_subtrees, void *data)
    1470                 :            : {
    1471                 :        446 :   hash_map<tree,tree*> &const_vars = *(hash_map<tree,tree*>*)data;
    1472                 :            : 
    1473                 :        446 :   tree var = NULL_TREE;
    1474                 :        446 :   if (TREE_CODE (*t) == DECL_EXPR)
    1475                 :            :     {
    1476                 :         63 :       tree decl = DECL_EXPR_DECL (*t);
    1477                 :         63 :       if (is_constant_capture_proxy (decl))
    1478                 :            :         {
    1479                 :         32 :           var = DECL_CAPTURED_VARIABLE (decl);
    1480                 :         32 :           *walk_subtrees = 0;
    1481                 :            :         }
    1482                 :            :     }
    1483                 :        383 :   else if (is_constant_capture_proxy (*t))
    1484                 :          3 :     var = DECL_CAPTURED_VARIABLE (*t);
    1485                 :            : 
    1486                 :        446 :   if (var)
    1487                 :            :     {
    1488                 :         35 :       tree *&slot = const_vars.get_or_insert (var);
    1489                 :         35 :       if (!slot || VAR_P (*t))
    1490                 :         35 :         slot = t;
    1491                 :            :     }
    1492                 :            : 
    1493                 :        446 :   return NULL_TREE;
    1494                 :            : }
    1495                 :            : 
    1496                 :            : /* We're at the end of processing a lambda; go back and remove any captures of
    1497                 :            :    constant variables for which we've folded away all uses.  */
    1498                 :            : 
    1499                 :            : static void
    1500                 :      43685 : prune_lambda_captures (tree body)
    1501                 :            : {
    1502                 :      43685 :   tree lam = current_lambda_expr ();
    1503                 :      43685 :   if (!LAMBDA_EXPR_CAPTURE_OPTIMIZED (lam))
    1504                 :            :     /* No uses were optimized away.  */
    1505                 :      43650 :     return;
    1506                 :         41 :   if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam) == CPLD_NONE)
    1507                 :            :     /* No default captures, and we don't prune explicit captures.  */
    1508                 :            :     return;
    1509                 :            : 
    1510                 :         70 :   hash_map<tree,tree*> const_vars;
    1511                 :            : 
    1512                 :         35 :   cp_walk_tree_without_duplicates (&body, mark_const_cap_r, &const_vars);
    1513                 :            : 
    1514                 :         35 :   tree *fieldp = &TYPE_FIELDS (LAMBDA_EXPR_CLOSURE (lam));
    1515                 :         74 :   for (tree *capp = &LAMBDA_EXPR_CAPTURE_LIST (lam); *capp; )
    1516                 :            :     {
    1517                 :         39 :       tree cap = *capp;
    1518                 :         39 :       if (tree var = var_to_maybe_prune (cap))
    1519                 :            :         {
    1520                 :         35 :           tree **use = const_vars.get (var);
    1521                 :         32 :           if (use && TREE_CODE (**use) == DECL_EXPR)
    1522                 :            :             {
    1523                 :            :               /* All uses of this capture were folded away, leaving only the
    1524                 :            :                  proxy declaration.  */
    1525                 :            : 
    1526                 :            :               /* Splice the capture out of LAMBDA_EXPR_CAPTURE_LIST.  */
    1527                 :         29 :               *capp = TREE_CHAIN (cap);
    1528                 :            : 
    1529                 :            :               /* And out of TYPE_FIELDS.  */
    1530                 :         29 :               tree field = TREE_PURPOSE (cap);
    1531                 :         33 :               while (*fieldp != field)
    1532                 :          4 :                 fieldp = &DECL_CHAIN (*fieldp);
    1533                 :         29 :               *fieldp = DECL_CHAIN (*fieldp);
    1534                 :            : 
    1535                 :            :               /* And remove the capture proxy declaration.  */
    1536                 :         29 :               **use = void_node;
    1537                 :         29 :               continue;
    1538                 :            :             }
    1539                 :            :         }
    1540                 :            : 
    1541                 :         10 :       capp = &TREE_CHAIN (cap);
    1542                 :            :     }
    1543                 :            : }
    1544                 :            : 
    1545                 :            : void
    1546                 :      43685 : finish_lambda_function (tree body)
    1547                 :            : {
    1548                 :      43685 :   finish_function_body (body);
    1549                 :            : 
    1550                 :      43685 :   prune_lambda_captures (body);
    1551                 :            : 
    1552                 :            :   /* Finish the function and generate code for it if necessary.  */
    1553                 :      43685 :   tree fn = finish_function (/*inline_p=*/true);
    1554                 :            : 
    1555                 :            :   /* Only expand if the call op is not a template.  */
    1556                 :      43685 :   if (!DECL_TEMPLATE_INFO (fn))
    1557                 :      29863 :     expand_or_defer_fn (fn);
    1558                 :      43685 : }
    1559                 :            : 
    1560                 :            : #include "gt-cp-lambda.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.