{"id":2175267,"url":"http://patchwork.ozlabs.org/api/1.0/patches/2175267/?format=json","project":{"id":17,"url":"http://patchwork.ozlabs.org/api/1.0/projects/17/?format=json","name":"GNU Compiler Collection","link_name":"gcc","list_id":"gcc-patches.gcc.gnu.org","list_email":"gcc-patches@gcc.gnu.org","web_url":null,"scm_url":null,"webscm_url":null},"msgid":"","date":"2025-12-17T16:45:19","name":"[1/9,v2] c++: C++26 Reflection [PR120775]","commit_ref":null,"pull_url":null,"state":"new","archived":false,"hash":"18f2ebcdaa854d751d89df2a47ac6b4ad19d1543","submitter":{"id":14370,"url":"http://patchwork.ozlabs.org/api/1.0/people/14370/?format=json","name":"Marek Polacek","email":"polacek@redhat.com"},"delegate":null,"mbox":"http://patchwork.ozlabs.org/project/gcc/patch/aULeH32QBOdlw0Zf@redhat.com/mbox/","series":[{"id":485726,"url":"http://patchwork.ozlabs.org/api/1.0/series/485726/?format=json","date":"2025-12-17T16:42:41","name":"c++: C++26 Reflection [PR120775]","version":2,"mbox":"http://patchwork.ozlabs.org/series/485726/mbox/"}],"check":"pending","checks":"http://patchwork.ozlabs.org/api/patches/2175267/checks/","tags":{},"headers":{"Return-Path":"","X-Original-To":["incoming@patchwork.ozlabs.org","gcc-patches@gcc.gnu.org"],"Delivered-To":["patchwork-incoming@legolas.ozlabs.org","gcc-patches@gcc.gnu.org"],"Authentication-Results":["legolas.ozlabs.org;\n\tdkim=fail reason=\"signature verification failed\" (1024-bit key;\n unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256\n header.s=mimecast20190719 header.b=FNmFk7qW;\n\tdkim-atps=neutral","legolas.ozlabs.org;\n spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org\n (client-ip=38.145.34.32; helo=vm01.sourceware.org;\n envelope-from=gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org;\n receiver=patchwork.ozlabs.org)","sourceware.org;\n\tdkim=fail reason=\"signature verification failed\" (1024-bit key,\n unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256\n header.s=mimecast20190719 header.b=FNmFk7qW","sourceware.org; dmarc=pass (p=quarantine dis=none)\n header.from=redhat.com","sourceware.org; spf=pass smtp.mailfrom=redhat.com","server2.sourceware.org;\n arc=none smtp.remote-ip=170.10.133.124"],"Received":["from vm01.sourceware.org (vm01.sourceware.org [38.145.34.32])\n\t(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)\n\t key-exchange x25519 server-signature ECDSA (secp384r1) server-digest SHA384)\n\t(No client certificate requested)\n\tby legolas.ozlabs.org (Postfix) with ESMTPS id 4dWfrD0R2fz1xty\n\tfor ; Thu, 18 Dec 2025 03:48:28 +1100 (AEDT)","from vm01.sourceware.org (localhost [127.0.0.1])\n\tby sourceware.org (Postfix) with ESMTP id E5EA14BA2E2F\n\tfor ; Wed, 17 Dec 2025 16:48:25 +0000 (GMT)","from us-smtp-delivery-124.mimecast.com\n (us-smtp-delivery-124.mimecast.com [170.10.133.124])\n by sourceware.org (Postfix) with ESMTP id AA60E4BA2E22\n for ; Wed, 17 Dec 2025 16:45:31 +0000 (GMT)","from mail-qt1-f197.google.com (mail-qt1-f197.google.com\n [209.85.160.197]) by relay.mimecast.com with ESMTP with STARTTLS\n (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id\n us-mta-2-K8_lipbIP3OMSbj4r273yQ-1; Wed, 17 Dec 2025 11:45:29 -0500","by mail-qt1-f197.google.com with SMTP id\n d75a77b69052e-4edad69b4e8so17507581cf.1\n for ; Wed, 17 Dec 2025 08:45:29 -0800 (PST)","from redhat.com ([2603:7000:9500:10::1db4])\n by smtp.gmail.com with ESMTPSA id\n d75a77b69052e-4f345b16f72sm38829881cf.3.2025.12.17.08.45.21\n (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256);\n Wed, 17 Dec 2025 08:45:21 -0800 (PST)"],"DKIM-Filter":["OpenDKIM Filter v2.11.0 sourceware.org E5EA14BA2E2F","OpenDKIM Filter v2.11.0 sourceware.org AA60E4BA2E22"],"DMARC-Filter":"OpenDMARC Filter v1.4.2 sourceware.org AA60E4BA2E22","ARC-Filter":"OpenARC Filter v1.0.0 sourceware.org AA60E4BA2E22","ARC-Seal":"i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1765989931; cv=none;\n b=jszI45JAvN68CoupU4r808lmVdMqSuiafc4AtYVJbM0Q07MnTvU9/vZiptixT5WbPjm7B9kw9dw1GzoaiL5/+LnGG0QWXKzm5J4yujeLP2QBFJbvHw5K4yR+8pR4RBmJragG/YRqgIszWOIGbBRuIPEOFQicK1BnK3cg2X4B7j0=","ARC-Message-Signature":"i=1; a=rsa-sha256; d=sourceware.org; s=key;\n t=1765989931; c=relaxed/simple;\n bh=k5MXpBYD6ZTPAOXFNQnicop16TEbGb/nTwThYC7kL3I=;\n h=DKIM-Signature:Date:From:To:Subject:Message-ID:MIME-Version;\n b=NbXr7CYmKdt5NjninJG1vEn8srS2ixteHWv+qPc0xX02SqTswn3cmV6ExGokRWFU5uzDAHNDpOfCO6nbdl6sjfqjKCuP24zmwbq04rMqYv0rULdVkjNmMFj79HnWibzob6O2yz1xsE4AfY3LFa1GvPQyAlItvxtDH2WCM1VpwqQ=","ARC-Authentication-Results":"i=1; server2.sourceware.org","DKIM-Signature":"v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com;\n s=mimecast20190719; t=1765989931;\n h=from:from:reply-to:subject:subject:date:date:message-id:message-id:\n to:to:cc:mime-version:mime-version:content-type:content-type:\n in-reply-to:in-reply-to:references:references;\n bh=W89J2Kzej5NU16CW9lXlQVhRodbVKNQrTBfAkT4q9rE=;\n b=FNmFk7qWii2MIIkXoHpTFw+qRYJYZzNDAmciMtpWe1nCrIepgHZw/4Va3Nmqc94sZ5skOa\n TEj8wQgEmiuJUgU1cgttt3M0u6rNbhZ2cV5NaEgDdp1feB6xZjyphIGjoDoCLdcyTf+iid\n pzCPeMrnRByBJISZa4G+KkprkFfbKWs=","X-MC-Unique":"K8_lipbIP3OMSbj4r273yQ-1","X-Mimecast-MFC-AGG-ID":"K8_lipbIP3OMSbj4r273yQ_1765989929","X-Google-DKIM-Signature":"v=1; a=rsa-sha256; c=relaxed/relaxed;\n d=1e100.net; s=20230601; t=1765989928; x=1766594728;\n h=user-agent:in-reply-to:content-disposition:mime-version:references\n :message-id:subject:to:from:date:x-gm-gg:x-gm-message-state:from:to\n :cc:subject:date:message-id:reply-to;\n bh=0pcrsSkJY2YHDQKAILRN8iAzbkec8QIl9p7Qf3N6jDk=;\n b=vblDZZuJ6BAeatEFM19lhHrLwiaO6N+c7wdJl/l+uDWU+FQ/0/pc68wKpKJgukeJ+z\n UxhuqqUqEVvmYifK7x+EPIePQacx8luw966zkJ90gyI1XzzNw6LVzTWYtPh6OLJPYQ17\n FIfhpomi4qQtmxX/mP+RmG58KH5I7xT59hpfGsvQkp0mLBqiLZVoPQGWQOTpr47YiCao\n jA1+LRedKr4q7tPgzZzttYIRxbSDXq1A9Ns3JBfhbtaHFQc8w5decnSsNhvMuP94U7Qy\n dpoK3OPoUjV2NYvoEcCPW1odxJCRHwpnIZdQ9lI/NbUKR4CigQSGlu+iPKLHaDIyEmsW\n IFBw==","X-Gm-Message-State":"AOJu0YynnTFG8vttWWZYlxOGs077+VyKWyy3WwCIcpuJJhFQEOqqACvD\n WknF/BqmPAD1NueZZejCMfYPYB97oAadND84i4fcKZlyGq+jA6OisMkZgC7QxqSbXj8z38+nJIV\n VregKy+bZvGPlyYd79jvUrgbLrCvvC4Goy4JM+8JDV7Eeub/XoVraY+Y7hWkUYlDK46I7qq6QF4\n HYN7RnuBOzphiaBngyYWS5piyT03qQqYFb86vRIlhTYA==","X-Gm-Gg":"AY/fxX4D2191+cUSl0hVgfrL8s37XmiCiuBPo/3xiI4M+yJzAG/ApMKsRA0WzDiMcV3\n klVNJJt44tJVaeTweqY+gRCQQt1XB04AwuvPTs/XrPP0yzUEHpKNNThnyBa5XLNTp/ln8UuZOuG\n e0+v45UWEl/R/ki+H2LbthHm+WO4o42GFRF70h7QhtGHZF+LlUGcF259VUOUY6WxFUzAozJ9OFl\n CFBg/r9hAf4vSseUvd5Xax1LVkeG1k75OuIvSt8mmTKsUKu3RjL7l53ZKal2LfLwwy8OVkVqQPC\n X7PKbbgUZmfFMHnBOlq6LCS/fPCVKuxijDg9Z1eIjtb+QvovZvq6iCwWLbD2SHX9Rw==","X-Received":["by 2002:a05:622a:491:b0:4f0:2211:d08b with SMTP id\n d75a77b69052e-4f35f46abbamr507421cf.33.1765989925254;\n Wed, 17 Dec 2025 08:45:25 -0800 (PST)","by 2002:a05:622a:491:b0:4f0:2211:d08b with SMTP id\n d75a77b69052e-4f35f46abbamr504461cf.33.1765989922721;\n Wed, 17 Dec 2025 08:45:22 -0800 (PST)"],"X-Google-Smtp-Source":"\n AGHT+IHCFz27Rx19Cfen+UoRz0PUIHtXg/lXBkPT2QCIHIueLbdT7QnIqOihFg5xShCNWoJdq14jgg==","Date":"Wed, 17 Dec 2025 11:45:19 -0500","From":"Marek Polacek ","To":"GCC Patches , Jason Merrill ,\n Jakub Jelinek , Jonathan Wakely ","Subject":"[PATCH 1/9 v2] c++: C++26 Reflection [PR120775]","Message-ID":"","References":"","MIME-Version":"1.0","In-Reply-To":"","User-Agent":"Mutt/2.2.14 (2025-02-20)","X-Mimecast-Spam-Score":"0","X-Mimecast-MFC-PROC-ID":"Qstd5czxjM7PChGF84pLiAucyOxE1B7U9L_Khn6pG1s_1765989929","X-Mimecast-Originator":"redhat.com","Content-Type":"text/plain; charset=us-ascii","Content-Disposition":"inline","X-BeenThere":"gcc-patches@gcc.gnu.org","X-Mailman-Version":"2.1.30","Precedence":"list","List-Id":"Gcc-patches mailing list ","List-Unsubscribe":",\n ","List-Archive":"","List-Post":"","List-Help":"","List-Subscribe":",\n ","Errors-To":"gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org"},"content":"This patch contains the middle-end, libcpp/, c-family/, and cp/ bits\n(besides reflect.cc and the gperf bits).\n\n-- >8 --","diff":"diff --git a/gcc/attribs.cc b/gcc/attribs.cc\nindex 51c7f46a00f..073fdde045b 100644\n--- a/gcc/attribs.cc\n+++ b/gcc/attribs.cc\n@@ -1458,6 +1458,10 @@ attribute_value_equal (const_tree attr1, const_tree attr2)\n && TREE_VALUE (attr2) != NULL_TREE\n && TREE_CODE (TREE_VALUE (attr2)) == TREE_LIST)\n {\n+ if (ATTR_UNIQUE_VALUE_P (TREE_VALUE (attr1))\n+\t || ATTR_UNIQUE_VALUE_P (TREE_VALUE (attr2)))\n+\treturn false;\n+\n /* Handle attribute format. */\n if (is_attribute_p (\"format\", get_attribute_name (attr1)))\n \t{\n@@ -1739,11 +1743,34 @@ merge_attributes (tree a1, tree a2)\n \tattributes = a2;\n else\n \t{\n-\t /* Pick the longest list, and hang on the other list. */\n+\t /* Pick the longest list, and hang on the other list,\n+\t unless both lists contain ATTR_UNIQUE_VALUE_P values.\n+\t In that case a1 list needs to go after the a2 list\n+\t because attributes from a single declaration are stored\n+\t in reverse order of their declarations. */\n+\t bool a1_unique_value_p = false, a2_unique_value_p = false;\n+\t tree aa1 = a1, aa2 = a2;\n+\t for (; aa1 && aa2; aa1 = TREE_CHAIN (aa1), aa2 = TREE_CHAIN (aa2))\n+\t {\n+\t if (!a1_unique_value_p\n+\t\t && TREE_VALUE (aa1)\n+\t\t && TREE_CODE (TREE_VALUE (aa1)) == TREE_LIST\n+\t\t && ATTR_UNIQUE_VALUE_P (TREE_VALUE (aa1)))\n+\t\ta1_unique_value_p = true;\n+\t if (!a2_unique_value_p\n+\t\t && TREE_VALUE (aa2)\n+\t\t && TREE_CODE (TREE_VALUE (aa2)) == TREE_LIST\n+\t\t && ATTR_UNIQUE_VALUE_P (TREE_VALUE (aa2)))\n+\t\ta2_unique_value_p = true;\n+\t }\n \n-\t if (list_length (a1) < list_length (a2))\n-\t attributes = a2, a2 = a1;\n+\t if (aa2 && (!a1_unique_value_p || !a2_unique_value_p))\n+\t {\n+\t attributes = a2;\n+\t a2 = a1;\n+\t }\n \n+\t tree a3 = NULL_TREE, *pa = &a3;\n \t for (; a2 != 0; a2 = TREE_CHAIN (a2))\n \t {\n \t tree a;\n@@ -1756,10 +1783,15 @@ merge_attributes (tree a1, tree a2)\n \t if (a == NULL_TREE)\n \t\t{\n \t\t a1 = copy_node (a2);\n-\t\t TREE_CHAIN (a1) = attributes;\n-\t\t attributes = a1;\n+\t\t *pa = a1;\n+\t\t pa = &TREE_CHAIN (a1);\n \t\t}\n \t }\n+\t if (a3)\n+\t {\n+\t *pa = attributes;\n+\t attributes = a3;\n+\t }\n \t}\n }\n return attributes;\ndiff --git a/gcc/c-family/c-attribs.cc b/gcc/c-family/c-attribs.cc\nindex 28a034f6c06..353d5aac8ad 100644\n--- a/gcc/c-family/c-attribs.cc\n+++ b/gcc/c-family/c-attribs.cc\n@@ -715,14 +715,20 @@ attribute_takes_identifier_p (const_tree attr_id)\n {\n const struct attribute_spec *spec = lookup_attribute_spec (attr_id);\n if (spec == NULL)\n- /* Unknown attribute that we'll end up ignoring, return true so we\n- don't complain about an identifier argument. */\n- return true;\n+ {\n+ /* Unknown attribute that we'll end up ignoring, return true so we\n+\t don't complain about an identifier argument. Except C++\n+\t annotations. */\n+ if (c_dialect_cxx () && id_equal (attr_id, \"annotation \"))\n+\treturn false;\n+ return true;\n+ }\n else if (!strcmp (\"mode\", spec->name)\n \t || !strcmp (\"format\", spec->name)\n \t || !strcmp (\"cleanup\", spec->name)\n \t || !strcmp (\"access\", spec->name)\n-\t || !strcmp (\"counted_by\", spec->name))\n+\t || !strcmp (\"counted_by\", spec->name)\n+\t || !strcmp (\"old parm name\", spec->name))\n return true;\n else\n return targetm.attribute_takes_identifier_p (attr_id);\ndiff --git a/gcc/c-family/c-cppbuiltin.cc b/gcc/c-family/c-cppbuiltin.cc\nindex f3a3ad855e0..b4e2b95a812 100644\n--- a/gcc/c-family/c-cppbuiltin.cc\n+++ b/gcc/c-family/c-cppbuiltin.cc\n@@ -1116,6 +1116,10 @@ c_cpp_builtins (cpp_reader *pfile)\n \t cpp_define (pfile, \"__cpp_pp_embed=202502L\");\n \t cpp_define (pfile, \"__cpp_constexpr_virtual_inheritance=202506L\");\n \t cpp_define (pfile, \"__cpp_expansion_statements=202506L\");\n+\t if (flag_reflection)\n+\t cpp_define (pfile, \"__cpp_impl_reflection=202506L\");\n+\t else\n+\t cpp_warn (pfile, \"__cpp_impl_reflection\");\n \t}\n if (flag_concepts && cxx_dialect > cxx14)\n \tcpp_define (pfile, \"__cpp_concepts=202002L\");\ndiff --git a/gcc/c-family/c.opt b/gcc/c-family/c.opt\nindex a4cb755b0b9..7f24edcd704 100644\n--- a/gcc/c-family/c.opt\n+++ b/gcc/c-family/c.opt\n@@ -2329,6 +2329,10 @@ frange-for-ext-temps\n C++ ObjC++ Var(flag_range_for_ext_temps)\n Enable lifetime extension of range based for temporaries.\n \n+freflection\n+C++ ObjC++ Var(flag_reflection) Init(0)\n+Enable experimental C++26 Reflection.\n+\n freplace-objc-classes\n ObjC ObjC++ LTO Var(flag_replace_objc_classes)\n Used in Fix-and-Continue mode to indicate that object files may be swapped in at runtime.\ndiff --git a/gcc/cp/Make-lang.in b/gcc/cp/Make-lang.in\nindex 70cfe2b1663..37dd833df95 100644\n--- a/gcc/cp/Make-lang.in\n+++ b/gcc/cp/Make-lang.in\n@@ -107,7 +107,7 @@ CXX_AND_OBJCXX_OBJS = \\\n \tcp/method.o cp/module.o \\\n \tcp/name-lookup.o cp/optimize.o \\\n \tcp/parser.o cp/pt.o cp/ptree.o \\\n-\tcp/rtti.o \\\n+\tcp/reflect.o cp/rtti.o \\\n \tcp/search.o cp/semantics.o \\\n \tcp/tree.o cp/typeck.o cp/typeck2.o \\\n \tcp/vtable-class-hierarchy.o $(CXX_C_OBJS)\n@@ -188,6 +188,24 @@ endif\n # This is the file that depends on the generated header file.\n cp/name-lookup.o: $(srcdir)/cp/std-name-hint.h\n \n+ifeq ($(ENABLE_MAINTAINER_RULES), true)\n+# Special build rule. This is a maintainer rule, that is only\n+# available when GCC is configured with --enable-maintainer-mode. In\n+# other cases, it is not available to avoid triggering rebuilds if a\n+# user has the source checked out with unusual timestamps.\n+$(srcdir)/cp/metafns.h: $(srcdir)/cp/metafns.gperf\n+else\n+# We keep the rule so that you can still force a rebuild, even if you\n+# didn't configure GCC with --enable-maintainer-mode, by manually\n+# deleting the $(srcdir)/cp/metafns.h file.\n+$(srcdir)/cp/metafns.h:\n+endif\n+\tcd $(srcdir)/cp; gperf -o -C -E -k '1,4,5,11,14,$$' -D -N find -L C++ \\\n+\t\tmetafns.gperf --output-file metafns.h\n+\n+# This is the file that depends on the generated header file.\n+cp/reflect.o: $(srcdir)/cp/metafns.h\n+\n components_in_prev = \"bfd opcodes binutils fixincludes gas gcc gmp mpfr mpc isl gold intl ld libbacktrace libcpp libcody libdecnumber libiberty libiberty-linker-plugin libiconv zlib lto-plugin libctf libsframe\"\n components_in_prev_target = \"libstdc++-v3 libsanitizer libvtv libgcc libbacktrace libphobos zlib libgomp libatomic\"\n \ndiff --git a/gcc/cp/config-lang.in b/gcc/cp/config-lang.in\nindex 599d1364b35..b0653e8b795 100644\n--- a/gcc/cp/config-lang.in\n+++ b/gcc/cp/config-lang.in\n@@ -51,7 +51,7 @@ gtfiles=\"\\\n \\$(srcdir)/cp/mangle.cc \\$(srcdir)/cp/method.cc \\$(srcdir)/cp/module.cc \\\n \\$(srcdir)/cp/name-lookup.cc \\\n \\$(srcdir)/cp/parser.cc \\$(srcdir)/cp/pt.cc \\\n-\\$(srcdir)/cp/rtti.cc \\\n+\\$(srcdir)/cp/reflect.cc \\$(srcdir)/cp/rtti.cc \\\n \\$(srcdir)/cp/semantics.cc \\\n \\$(srcdir)/cp/tree.cc \\$(srcdir)/cp/typeck2.cc \\\n \\$(srcdir)/cp/vtable-class-hierarchy.cc \\\ndiff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc\nindex e091e8643a0..de9be778a13 100644\n--- a/gcc/cp/constexpr.cc\n+++ b/gcc/cp/constexpr.cc\n@@ -1200,15 +1200,29 @@ public:\n /* If non-null, only allow modification of existing values of the variables\n in this set. Set by modifiable_tracker, below. */\n hash_set *modifiable;\n+ /* If cxx_eval_outermost_constant_expr is called on the consteval block\n+ operator (), this is the FUNCTION_DECL of that operator (). */\n+ tree consteval_block;\n /* Number of heap VAR_DECL deallocations. */\n unsigned heap_dealloc_count;\n /* Number of uncaught exceptions. */\n unsigned uncaught_exceptions;\n+ /* Some metafunctions aren't dependent just on their arguments, but also\n+ on various other dependencies, e.g. has_identifier on a function parameter\n+ reflection can change depending on further declarations of corresponding\n+ function, is_complete_type depends on type definitions and template\n+ specializations in between the calls, define_aggregate even defines\n+ class types, etc. Thus, we need to arrange for calls which call\n+ at least some metafunctions to be non-cacheable, because their behavior\n+ might not be the same. Until we figure out which exact metafunctions\n+ need this and which don't, do it for all of them. */\n+ bool metafns_called;\n \n /* Constructor. */\n constexpr_global_ctx ()\n : constexpr_ops_count (0), cleanups (NULL), modifiable (nullptr),\n- heap_dealloc_count (0), uncaught_exceptions (0) {}\n+ consteval_block (NULL_TREE), heap_dealloc_count (0),\n+ uncaught_exceptions (0), metafns_called (false) {}\n \n bool is_outside_lifetime (tree t)\n {\n@@ -1322,6 +1336,42 @@ struct constexpr_ctx {\n mce_value manifestly_const_eval;\n };\n \n+/* Return ctx->quiet. For use in reflect.cc. */\n+\n+bool\n+cxx_constexpr_quiet_p (const constexpr_ctx *ctx)\n+{\n+ return ctx->quiet;\n+}\n+\n+/* Return ctx->manifestly_const_eval. For use in reflect.cc. */\n+\n+mce_value\n+cxx_constexpr_manifestly_const_eval (const constexpr_ctx *ctx)\n+{\n+ return ctx->manifestly_const_eval;\n+}\n+\n+/* Return ctx->call->fundef->decl or NULL_TREE. For use in\n+ reflect.cc. */\n+\n+tree\n+cxx_constexpr_caller (const constexpr_ctx *ctx)\n+{\n+ if (ctx->call)\n+ return ctx->call->fundef->decl;\n+ else\n+ return NULL_TREE;\n+}\n+\n+/* Return ctx->global->consteval_block. For use in reflect.cc. */\n+\n+tree\n+cxx_constexpr_consteval_block (const constexpr_ctx *ctx)\n+{\n+ return ctx->global->consteval_block;\n+}\n+\n /* Predicates for the meaning of *jump_target. */\n \n static bool\n@@ -1589,17 +1639,6 @@ save_fundef_copy (tree fun, tree copy)\n *slot = copy;\n }\n \n-/* Whether our evaluation wants a prvalue (e.g. CONSTRUCTOR or _CST),\n- a glvalue (e.g. VAR_DECL or _REF), or nothing. */\n-\n-enum value_cat {\n- vc_prvalue = 0,\n- vc_glvalue = 1,\n- vc_discard = 2\n-};\n-\n-static tree cxx_eval_constant_expression (const constexpr_ctx *, tree,\n-\t\t\t\t\t value_cat, bool *, bool *, tree *);\n static tree cxx_eval_bare_aggregate (const constexpr_ctx *, tree,\n \t\t\t\t value_cat, bool *, bool *, tree *);\n static tree cxx_fold_indirect_ref (const constexpr_ctx *, location_t, tree, tree,\n@@ -2034,6 +2073,10 @@ cxx_eval_cxa_builtin_fn (const constexpr_ctx *ctx, tree call,\n \t {\n \t if (type_build_dtor_call (TREE_TYPE (arg)))\n \t\t{\n+\t\t /* So that we don't complain about out-of-consteval use. */\n+\t\t temp_override ovr (current_function_decl);\n+\t\t if (ctx->call && ctx->call->fundef)\n+\t\t current_function_decl = ctx->call->fundef->decl;\n \t\t tree cleanup\n \t\t = cxx_maybe_build_cleanup (arg, (ctx->quiet ? tf_none\n \t\t\t\t\t\t : tf_warning_or_error));\n@@ -2457,6 +2500,22 @@ cxx_eval_builtin_function_call (const constexpr_ctx *ctx, tree t, tree fun,\n \t}\n new_call = fold_builtin_is_corresponding_member (loc, nargs, args);\n }\n+ else if (fndecl_built_in_p (fun, CP_BUILT_IN_IS_STRING_LITERAL,\n+\t\t\t BUILT_IN_FRONTEND))\n+ {\n+ location_t loc = EXPR_LOCATION (t);\n+ if (nargs >= 1)\n+\t{\n+\t tree arg = CALL_EXPR_ARG (t, 0);\n+\t arg = cxx_eval_constant_expression (ctx, arg, vc_prvalue,\n+\t\t\t\t\t non_constant_p, overflow_p,\n+\t\t\t\t\t jump_target);\n+\t if (*jump_target)\n+\t return NULL_TREE;\n+\t args[0] = arg;\n+\t}\n+ new_call = fold_builtin_is_string_literal (loc, nargs, args);\n+ }\n else\n new_call = fold_builtin_call_array (EXPR_LOCATION (t), TREE_TYPE (t),\n \t\t\t\t\tCALL_EXPR_FN (t), nargs, args);\n@@ -3184,12 +3243,14 @@ is_std_class (tree ctx, const char *name)\n bool\n is_std_allocator (tree ctx)\n {\n- return is_std_class (ctx, \"allocator\");\n+ return (is_std_class (ctx, \"allocator\")\n+\t || (flag_reflection\n+\t && is_std_class (ctx, \"__new_allocator\")));\n }\n \n /* Return true if FNDECL is std::allocator::{,de}allocate. */\n \n-static inline bool\n+bool\n is_std_allocator_allocate (tree fndecl)\n {\n tree name = DECL_NAME (fndecl);\n@@ -3670,6 +3731,43 @@ cxx_set_object_constness (const constexpr_ctx *ctx, tree object,\n }\n }\n \n+/* Allocate an exception for OBJECT and throw it. */\n+\n+tree\n+cxa_allocate_and_throw_exception (location_t loc, const constexpr_ctx *ctx,\n+\t\t\t\t tree object)\n+{\n+ tree type = TREE_TYPE (object);\n+ /* This simulates a call to __cxa_allocate_exception. We need\n+ (struct exception *) &heap -- memory on the heap so that\n+ it can survive the stack being unwound. */\n+ tree arr = build_array_of_n_type (type, 1);\n+ tree var = cxa_allocate_exception (loc, ctx, arr, size_zero_node);\n+ DECL_NAME (var) = heap_identifier;\n+ ctx->global->put_value (var, NULL_TREE);\n+\n+ /* *(struct exception *) &heap = exc{ ... } */\n+ tree ptr = build_nop (build_pointer_type (type), build_address (var));\n+ object = cp_build_init_expr (cp_build_fold_indirect_ref (ptr), object);\n+ bool non_constant_p = false, overflow_p = false;\n+ tree jump_target = NULL_TREE;\n+ cxx_eval_constant_expression (ctx, object, vc_prvalue, &non_constant_p,\n+\t\t\t\t&overflow_p, &jump_target);\n+ if (non_constant_p)\n+ {\n+ if (!ctx->quiet)\n+\terror_at (loc, \"couldn%'t throw %qT\", type);\n+ return NULL_TREE;\n+ }\n+\n+ /* Now we can __cxa_throw. */\n+ DECL_EXCEPTION_REFCOUNT (var)\n+ = size_binop (PLUS_EXPR, DECL_EXCEPTION_REFCOUNT (var), size_one_node);\n+ ++ctx->global->uncaught_exceptions;\n+\n+ return var;\n+}\n+\n /* Subroutine of cxx_eval_constant_expression.\n Evaluate the call expression tree T in the context of OLD_CALL expression\n evaluation. */\n@@ -3752,6 +3850,35 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,\n if (DECL_THUNK_P (fun))\n return cxx_eval_thunk_call (ctx, t, fun, lval, non_constant_p, overflow_p,\n \t\t\t\tjump_target);\n+ if (metafunction_p (fun))\n+ {\n+ /* To be able to evaluate a metafunction, we may have to instantiate\n+\t constexpr functions. If we're not allowed to instantiate, leave\n+\t this for later. Don't evaluate metafunctions at all when mce_unknown,\n+\t otherwise we might fold those prematurely. See\n+\t g++.dg/reflect/p2996-17.C. */\n+ if (uid_sensitive_constexpr_evaluation_p ()\n+\t || ctx->manifestly_const_eval == mce_unknown)\n+\t{\n+\t *non_constant_p = true;\n+\t return t;\n+\t}\n+ ctx->global->metafns_called = true;\n+ tree e = process_metafunction (ctx, fun, t, non_constant_p, overflow_p,\n+\t\t\t\t jump_target);\n+ if (*jump_target)\n+\treturn NULL_TREE;\n+ if (*non_constant_p)\n+\treturn t;\n+ e = cxx_eval_constant_expression (ctx, e, vc_prvalue,\n+\t\t\t\t\tnon_constant_p, overflow_p,\n+\t\t\t\t\tjump_target);\n+ if (*jump_target)\n+\treturn NULL_TREE;\n+ if (*non_constant_p)\n+\treturn t;\n+ return e;\n+ }\n bool non_constexpr_call = false;\n if (!maybe_constexpr_fn (fun))\n {\n@@ -4201,6 +4328,7 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,\n \t call_ctx.call = &new_call;\n \t unsigned save_heap_alloc_count = ctx->global->heap_vars.length ();\n \t unsigned save_heap_dealloc_count = ctx->global->heap_dealloc_count;\n+\t bool save_metafns_called = ctx->global->metafns_called;\n \n \t /* Make sure we fold std::is_constant_evaluated to true in an\n \t immediate function. */\n@@ -4232,6 +4360,8 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,\n \t\treturn NULL_TREE;\n \t }\n \n+\t ctx->global->metafns_called = false;\n+\n \t tree jmp_target = NULL_TREE;\n \t cxx_eval_constant_expression (&call_ctx, body,\n \t\t\t\t\tvc_discard, non_constant_p, overflow_p,\n@@ -4265,6 +4395,10 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,\n \t\t}\n \t }\n \n+\t if (ctx->global->metafns_called)\n+\t cacheable = false;\n+\t ctx->global->metafns_called |= save_metafns_called;\n+\n \t /* At this point, the object's constructor will have run, so\n \t the object is no longer under construction, and its possible\n \t 'const' semantics now apply. Make a note of this fact by\n@@ -4405,6 +4539,7 @@ reduced_constant_expression_p (tree t, tree sz /* = NULL_TREE */)\n switch (TREE_CODE (t))\n {\n case PTRMEM_CST:\n+ case REFLECT_EXPR:\n /* Even if we can't lower this yet, it's constant. */\n return true;\n \n@@ -4879,6 +5014,11 @@ cxx_eval_binary_expression (const constexpr_ctx *ctx, tree t,\n \tlhs = cplus_expand_constant (lhs);\n else if (TREE_CODE (rhs) == PTRMEM_CST)\n \trhs = cplus_expand_constant (rhs);\n+ else if (REFLECT_EXPR_P (lhs) && REFLECT_EXPR_P (rhs))\n+\t{\n+\t const bool eq = compare_reflections (lhs, rhs);\n+\t r = constant_boolean_node (eq == is_code_eq, type);\n+\t}\n }\n if (r == NULL_TREE\n && TREE_CODE_CLASS (code) == tcc_comparison\n@@ -8816,7 +8956,7 @@ merge_jump_target (location_t loc, const constexpr_ctx *ctx, tree r,\n /* FIXME unify with c_fully_fold */\n /* FIXME overflow_p is too global */\n \n-static tree\n+tree\n cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,\n \t\t\t value_cat lval,\n \t\t\t bool *non_constant_p, bool *overflow_p,\n@@ -9009,6 +9149,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,\n case CASE_LABEL_EXPR:\n case PREDICT_EXPR:\n case OMP_DECLARE_MAPPER:\n+ case REFLECT_EXPR:\n return t;\n \n case PARM_DECL:\n@@ -9801,6 +9942,14 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,\n \t return t;\n \t }\n \n+\t/* This can happen for std::meta::info(^^int) where the cast has no\n+\t meaning. */\n+\tif (REFLECTION_TYPE_P (type) && REFLECT_EXPR_P (op))\n+\t {\n+\t r = op;\n+\t break;\n+\t }\n+\n \t/* [expr.const]: a conversion from type cv void* to a pointer-to-object\n \t type cannot be part of a core constant expression as a resolution to\n \t DR 1312. */\n@@ -10374,7 +10523,7 @@ find_heap_var_refs (tree *tp, int *walk_subtrees, void */*data*/)\n /* Find immediate function decls in *TP if any. */\n \n static tree\n-find_immediate_fndecl (tree *tp, int */*walk_subtrees*/, void */*data*/)\n+find_immediate_fndecl (tree *tp, int *walk_subtrees, void */*data*/)\n {\n if (TREE_CODE (*tp) == FUNCTION_DECL && DECL_IMMEDIATE_FUNCTION_P (*tp))\n return *tp;\n@@ -10382,6 +10531,8 @@ find_immediate_fndecl (tree *tp, int */*walk_subtrees*/, void */*data*/)\n && TREE_CODE (PTRMEM_CST_MEMBER (*tp)) == FUNCTION_DECL\n && DECL_IMMEDIATE_FUNCTION_P (PTRMEM_CST_MEMBER (*tp)))\n return PTRMEM_CST_MEMBER (*tp);\n+ if (REFLECT_EXPR_P (*tp))\n+ *walk_subtrees = 0;\n return NULL_TREE;\n }\n \n@@ -10466,6 +10617,12 @@ cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant,\n \t return t;\n \t else\n \t is_consteval = true;\n+\t tree lam;\n+\t if (manifestly_const_eval == mce_true\n+\t && LAMBDA_FUNCTION_P (fndecl)\n+\t && (lam = CLASSTYPE_LAMBDA_EXPR (CP_DECL_CONTEXT (fndecl)))\n+\t && LAMBDA_EXPR_CONSTEVAL_BLOCK_P (lam))\n+\t global_ctx.consteval_block = fndecl;\n \t}\n }\n else if (cxx_dialect >= cxx20\n@@ -10682,6 +10839,37 @@ cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant,\n non_constant_p = true;\n }\n \n+ /* Detect consteval-only smuggling: turning a consteval-only object\n+ into one that is not. For instance, in\n+ struct B { };\n+ struct D : B { info r; };\n+ constexpr D d{^^::};\n+ constexpr const B &b = d; // #1\n+ #1 is wrong because D is a consteval-only type but B is not. */\n+ if (flag_reflection\n+ && !non_constant_p\n+ && object\n+ && POINTER_TYPE_P (TREE_TYPE (object))\n+ && !consteval_only_p (object)\n+ && check_out_of_consteval_use (r, /*complain=*/false))\n+ {\n+ if (!allow_non_constant)\n+\t{\n+\t if (TYPE_REF_P (TREE_TYPE (object)))\n+\t error_at (cp_expr_loc_or_input_loc (t),\n+\t\t \"reference into an object of consteval-only type is \"\n+\t\t \"not a constant expression unless it also has \"\n+\t\t \"consteval-only type\");\n+\t else\n+\t error_at (cp_expr_loc_or_input_loc (t),\n+\t\t \"pointer into an object of consteval-only type is \"\n+\t\t \"not a constant expression unless it also has \"\n+\t\t \"consteval-only type\");\n+\t}\n+ r = t;\n+ non_constant_p = true;\n+ }\n+\n if (!non_constant_p && !constexpr_dtor)\n verify_constant (r, allow_non_constant, &non_constant_p, &overflow_p);\n \n@@ -11473,6 +11661,7 @@ potential_constant_expression_1 (tree t, bool want_rval, bool strict, bool now,\n case REQUIRES_EXPR:\n case STATIC_ASSERT:\n case DEBUG_BEGIN_STMT:\n+ case REFLECT_EXPR:\n return true;\n \n case RETURN_EXPR:\n@@ -12566,6 +12755,11 @@ potential_constant_expression_1 (tree t, bool want_rval, bool strict, bool now,\n case TU_LOCAL_ENTITY:\n return false;\n \n+ /* A splice expression is dependent, but will be constant after\n+ substitution. */\n+ case SPLICE_EXPR:\n+ return true;\n+\n case NONTYPE_ARGUMENT_PACK:\n {\n \ttree args = ARGUMENT_PACK_ARGS (t);\ndiff --git a/gcc/cp/constraint.cc b/gcc/cp/constraint.cc\nindex 92a3a780008..f45a8ad5bbd 100644\n--- a/gcc/cp/constraint.cc\n+++ b/gcc/cp/constraint.cc\n@@ -3316,6 +3316,9 @@ diagnose_trait_expr (location_t loc, tree expr, tree args)\n case CPTK_IS_VOLATILE:\n inform (loc, \"%qT is not a volatile type\", t1);\n break;\n+ case CPTK_IS_CONSTEVAL_ONLY:\n+ inform (decl_loc, \"%qT is not consteval-only\", t1);\n+ break;\n case CPTK_RANK:\n inform (loc, \"%qT cannot yield a rank\", t1);\n break;\ndiff --git a/gcc/cp/cp-gimplify.cc b/gcc/cp/cp-gimplify.cc\nindex 994d4deb0f1..9eb27deb923 100644\n--- a/gcc/cp/cp-gimplify.cc\n+++ b/gcc/cp/cp-gimplify.cc\n@@ -477,7 +477,7 @@ lvalue_has_side_effects (tree e)\n \n /* Return true if FN is an immediate-escalating function. */\n \n-static bool\n+bool\n immediate_escalating_function_p (tree fn)\n {\n if (!fn || !flag_immediate_escalation)\n@@ -515,7 +515,7 @@ unchecked_immediate_escalating_function_p (tree fn)\n \n /* Promote FN to an immediate function, including its clones. */\n \n-static void\n+void\n promote_function_to_consteval (tree fn)\n {\n SET_DECL_IMMEDIATE_FUNCTION_P (fn);\n@@ -847,6 +847,13 @@ cp_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)\n \n case CALL_EXPR:\n ret = GS_OK;\n+ /* At this point any function that takes/returns a consteval-only\n+\t expression is a problem. */\n+ for (int i = 0; i < call_expr_nargs (*expr_p); ++i)\n+\tif (check_out_of_consteval_use (CALL_EXPR_ARG (*expr_p, i)))\n+\t ret = GS_ERROR;\n+ if (consteval_only_p (TREE_TYPE (*expr_p)))\n+\tret = GS_ERROR;\n if (flag_strong_eval_order == 2\n \t && CALL_EXPR_FN (*expr_p)\n \t && !CALL_EXPR_OPERATOR_SYNTAX (*expr_p)\n@@ -956,6 +963,13 @@ cp_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)\n \t\t\t \"__builtin_eh_ptr_adjust_ref\");\n \t\t*expr_p = void_node;\n \t\tbreak;\n+\t case CP_BUILT_IN_IS_STRING_LITERAL:\n+\t\t*expr_p\n+\t\t = fold_builtin_is_string_literal (EXPR_LOCATION (*expr_p),\n+\t\t\t\t\t\t call_expr_nargs (*expr_p),\n+\t\t\t\t\t\t &CALL_EXPR_ARG (*expr_p,\n+\t\t\t\t\t\t\t\t 0));\n+\t\tbreak;\n \t default:\n \t\tbreak;\n \t }\n@@ -1284,6 +1298,23 @@ cp_build_init_expr_for_ctor (tree call, tree init)\n return init;\n }\n \n+/* For every DECL_EXPR check if it declares a consteval-only variable and\n+ if so, overwrite it with a no-op. The point here is not to leak\n+ consteval-only variables into the middle end. */\n+\n+static tree\n+wipe_consteval_only_r (tree *stmt_p, int *, void *)\n+{\n+ if (TREE_CODE (*stmt_p) == DECL_EXPR)\n+ {\n+ tree d = DECL_EXPR_DECL (*stmt_p);\n+ if (VAR_P (d) && consteval_only_p (d))\n+\t/* Wipe the DECL_EXPR so that it doesn't get into gimple. */\n+\t*stmt_p = void_node;\n+ }\n+ return NULL_TREE;\n+}\n+\n /* A walk_tree callback for cp_fold_function and cp_fully_fold_init to handle\n immediate functions. */\n \n@@ -1311,12 +1342,43 @@ cp_fold_immediate_r (tree *stmt_p, int *walk_subtrees, void *data_)\n return NULL_TREE;\n }\n \n+ /* Most invalid uses of consteval-only types should have been already\n+ detected at this point. And the valid ones won't be needed\n+ anymore. */\n+ if (flag_reflection && (data->flags & ff_genericize))\n+ {\n+ /* We still may have some wrong uses that persisted until now. */\n+ if (complain && TREE_CODE (stmt) == STATEMENT_LIST)\n+\tfor (tree s : tsi_range (stmt))\n+\t if (check_out_of_consteval_use (s))\n+\t *stmt_p = void_node;\n+ /* We can't resolve all TEMPLATE_ID_EXPRs while creating reflections\n+\t because cp_parser_postfix_dot_deref_expression wants to see the\n+\t original TEMPLATE_ID_EXPR. Resolve them now so that we don't crash\n+\t in gimple. (The resolution shouldn't fail here because the bad ones\n+\t won't get this far.) */\n+ if (REFLECT_EXPR_P (stmt))\n+\t{\n+\t tree &h = REFLECT_EXPR_HANDLE (stmt);\n+\t h = resolve_nondeduced_context (h, tf_none);\n+\t}\n+ }\n+\n tree decl = NULL_TREE;\n bool call_p = false;\n \n /* We are looking for &fn or fn(). */\n switch (code)\n {\n+ case DECL_EXPR:\n+ /* Clear consteval-only DECL_EXPRs. */\n+ if (flag_reflection)\n+\t{\n+\t tree d = DECL_EXPR_DECL (stmt);\n+\t if (VAR_P (d) && consteval_only_p (d))\n+\t *stmt_p = void_node;\n+\t}\n+ break;\n case CALL_EXPR:\n case AGGR_INIT_EXPR:\n if (tree fn = cp_get_callee (stmt))\n@@ -1335,8 +1397,15 @@ cp_fold_immediate_r (tree *stmt_p, int *walk_subtrees, void *data_)\n if (IF_STMT_CONSTEVAL_P (stmt))\n \t{\n \t if (!data->pset.add (stmt))\n-\t cp_walk_tree (&ELSE_CLAUSE (stmt), cp_fold_immediate_r, data_,\n-\t\t\t NULL);\n+\t {\n+\t cp_walk_tree (&ELSE_CLAUSE (stmt), cp_fold_immediate_r, data_,\n+\t\t\t nullptr);\n+\t if (flag_reflection)\n+\t\t/* Check & clear consteval-only DECL_EXPRs even here,\n+\t\t because we wouldn't be walking this subtree otherwise. */\n+\t\tcp_walk_tree (&THEN_CLAUSE (stmt), wipe_consteval_only_r,\n+\t\t\t data_, nullptr);\n+\t }\n \t *walk_subtrees = 0;\n \t return NULL_TREE;\n \t}\n@@ -1410,6 +1479,22 @@ cp_fold_immediate_r (tree *stmt_p, int *walk_subtrees, void *data_)\n \t *walk_subtrees = 0;\n \t return stmt;\n \t}\n+ /* If we called a consteval function and it evaluated to a consteval-only\n+\t expression, it could be a problem if we are outside a manifestly\n+\t constant-evaluated context. */\n+ else if ((data->flags & ff_genericize)\n+\t && check_out_of_consteval_use (e, complain))\n+\t{\n+\t *stmt_p = void_node;\n+\t if (complain & tf_error)\n+\t return NULL_TREE;\n+\t else\n+\t {\n+\t *walk_subtrees = 0;\n+\t return stmt;\n+\t }\n+\t}\n+\n /* We've evaluated the consteval function call. */\n if (call_p)\n \t{\n@@ -1962,6 +2047,20 @@ cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)\n \t cp_walk_tree (&DECL_INITIAL (decl), cp_genericize_r, data, NULL);\n \t wtd->no_sanitize_p = no_sanitize_p;\n \t}\n+ if (flag_reflection)\n+\t/* Wipe consteval-only vars from BIND_EXPR_VARS and BLOCK_VARS. */\n+\tfor (tree *p = &BIND_EXPR_VARS (stmt); *p; )\n+\t {\n+\t if (VAR_P (*p) && consteval_only_p (*p))\n+\t {\n+\t\tif (BIND_EXPR_BLOCK (stmt)\n+\t\t && *p == BLOCK_VARS (BIND_EXPR_BLOCK (stmt)))\n+\t\t BLOCK_VARS (BIND_EXPR_BLOCK (stmt)) = DECL_CHAIN (*p);\n+\t\t*p = DECL_CHAIN (*p);\n+\t\tcontinue;\n+\t }\n+\t p = &DECL_CHAIN (*p);\n+\t }\n wtd->bind_expr_stack.safe_push (stmt);\n cp_walk_tree (&BIND_EXPR_BODY (stmt),\n \t\t cp_genericize_r, data, NULL);\ndiff --git a/gcc/cp/cp-objcp-common.cc b/gcc/cp/cp-objcp-common.cc\nindex 859c7d69746..b18e152bef8 100644\n--- a/gcc/cp/cp-objcp-common.cc\n+++ b/gcc/cp/cp-objcp-common.cc\n@@ -646,6 +646,8 @@ cp_common_init_ts (void)\n MARK_TS_TYPE_NON_COMMON (TEMPLATE_TYPE_PARM);\n MARK_TS_TYPE_NON_COMMON (TYPE_PACK_EXPANSION);\n MARK_TS_TYPE_NON_COMMON (PACK_INDEX_TYPE);\n+ MARK_TS_TYPE_NON_COMMON (META_TYPE);\n+ MARK_TS_TYPE_NON_COMMON (SPLICE_SCOPE);\n \n /* Statements. */\n MARK_TS_EXP (CLEANUP_STMT);\n@@ -696,6 +698,8 @@ cp_common_init_ts (void)\n MARK_TS_EXP (VEC_INIT_EXPR);\n MARK_TS_EXP (VEC_NEW_EXPR);\n MARK_TS_EXP (SPACESHIP_EXPR);\n+ MARK_TS_EXP (SPLICE_EXPR);\n+ MARK_TS_EXP (REFLECT_EXPR);\n \n /* Fold expressions. */\n MARK_TS_EXP (BINARY_LEFT_FOLD_EXPR);\ndiff --git a/gcc/cp/cp-trait.def b/gcc/cp/cp-trait.def\nindex c7fc40d0544..395cadc5767 100644\n--- a/gcc/cp/cp-trait.def\n+++ b/gcc/cp/cp-trait.def\n@@ -69,6 +69,7 @@ DEFTRAIT_EXPR (IS_BASE_OF, \"__is_base_of\", 2)\n DEFTRAIT_EXPR (IS_BOUNDED_ARRAY, \"__is_bounded_array\", 1)\n DEFTRAIT_EXPR (IS_CLASS, \"__is_class\", 1)\n DEFTRAIT_EXPR (IS_CONST, \"__is_const\", 1)\n+DEFTRAIT_EXPR (IS_CONSTEVAL_ONLY, \"__builtin_is_consteval_only\", 1)\n DEFTRAIT_EXPR (IS_CONSTRUCTIBLE, \"__is_constructible\", -1)\n DEFTRAIT_EXPR (IS_CONVERTIBLE, \"__is_convertible\", 2)\n DEFTRAIT_EXPR (IS_DESTRUCTIBLE, \"__is_destructible\", 1)\ndiff --git a/gcc/cp/cp-tree.def b/gcc/cp/cp-tree.def\nindex b1e369738fa..c050b55abb8 100644\n--- a/gcc/cp/cp-tree.def\n+++ b/gcc/cp/cp-tree.def\n@@ -586,6 +586,24 @@ DEFTREECODE (POSTCONDITION_STMT, \"postcondition_stmt\", tcc_statement, 4)\n wasn't an exposure (e.g. in a non-inline function template). */\n DEFTREECODE (TU_LOCAL_ENTITY, \"tu_local_entity\", tcc_exceptional, 0)\n \n+/* C++26 reflection expression. */\n+DEFTREECODE (REFLECT_EXPR, \"reflect_expr\", tcc_expression, 1)\n+\n+/* Represents the std::meta::info type. */\n+DEFTREECODE (META_TYPE, \"meta_type\", tcc_type, 0)\n+\n+/* Represents a dependent splice expression. If SPLICE_EXPR_EXPRESSION_P\n+ is set, this tree represents a splice-expression (as opposed to\n+ a splice-specifier). */\n+DEFTREECODE (SPLICE_EXPR, \"splice_expr\", tcc_expression, 1)\n+\n+/* Represents a dependent splice scope, or a dependent splice type\n+ (SPLICE_SCOPE_TYPE_P says which one it is). Its operand can be accessed\n+ using SPLICE_SCOPE_EXPR. The operand can be a SPLICE_EXPR or a\n+ TEMPLATE_ID_EXPR; the SPLICE_SCOPE is necessary to denote that this\n+ tree should expand to a type/scope. */\n+DEFTREECODE (SPLICE_SCOPE, \"splice_scope\", tcc_type, 0)\n+\n /*\n Local variables:\n mode:c\ndiff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h\nindex 1f00898cfad..a3e3f05e4e9 100644\n--- a/gcc/cp/cp-tree.h\n+++ b/gcc/cp/cp-tree.h\n@@ -175,6 +175,7 @@ enum cp_tree_index\n CPTI_FOR_END_IDENTIFIER,\n CPTI_ABI_TAG_IDENTIFIER,\n CPTI_ALIGNED_IDENTIFIER,\n+ CPTI_ANNOTATION_IDENTIFIER,\n CPTI_BEGIN_IDENTIFIER,\n CPTI_END_IDENTIFIER,\n CPTI_GET_IDENTIFIER,\n@@ -211,6 +212,7 @@ enum cp_tree_index\n \n /* We must find these via the global namespace. */\n CPTI_STD,\n+ CPTI_STD_META,\n CPTI_ABI,\n \n /* These are created at init time, but the library/headers provide\n@@ -236,6 +238,7 @@ enum cp_tree_index\n CPTI_DCAST,\n \n CPTI_PSEUDO_CONTRACT_VIOLATION,\n+ CPTI_META_INFO_TYPE,\n \n CPTI_MAX\n };\n@@ -257,6 +260,7 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];\n #define vtbl_type_node\t\t\tcp_global_trees[CPTI_VTBL_TYPE]\n #define vtbl_ptr_type_node\t\tcp_global_trees[CPTI_VTBL_PTR_TYPE]\n #define std_node\t\t\tcp_global_trees[CPTI_STD]\n+#define std_meta_node\t\t\tcp_global_trees[CPTI_STD_META]\n #define abi_node\t\t\tcp_global_trees[CPTI_ABI]\n #define global_namespace\t\tcp_global_trees[CPTI_GLOBAL]\n #define const_type_info_type_node\tcp_global_trees[CPTI_CONST_TYPE_INFO_TYPE]\n@@ -266,6 +270,7 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];\n /* std::align_val_t */\n #define align_type_node\t\t\tcp_global_trees[CPTI_ALIGN_TYPE]\n #define pseudo_contract_violation_type\tcp_global_trees[CPTI_PSEUDO_CONTRACT_VIOLATION]\n+#define meta_info_type_node\t\tcp_global_trees[CPTI_META_INFO_TYPE]\n \n /* We cache these tree nodes so as to call get_identifier less frequently.\n For identifiers for functions, including special member functions such\n@@ -329,6 +334,7 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];\n #define for_end_identifier\t\tcp_global_trees[CPTI_FOR_END_IDENTIFIER]\n #define abi_tag_identifier\t\tcp_global_trees[CPTI_ABI_TAG_IDENTIFIER]\n #define aligned_identifier\t\tcp_global_trees[CPTI_ALIGNED_IDENTIFIER]\n+#define annotation_identifier\t\tcp_global_trees[CPTI_ANNOTATION_IDENTIFIER]\n #define begin_identifier\t\tcp_global_trees[CPTI_BEGIN_IDENTIFIER]\n #define end_identifier\t\t\tcp_global_trees[CPTI_END_IDENTIFIER]\n #define get__identifier\t\t\tcp_global_trees[CPTI_GET_IDENTIFIER]\n@@ -454,6 +460,9 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];\n MUST_NOT_THROW_NOEXCEPT_P (in MUST_NOT_THROW_EXPR)\n CONSTEVAL_BLOCK_P (in STATIC_ASSERT)\n LAMBDA_EXPR_CONSTEVAL_BLOCK_P (in LAMBDA_EXPR)\n+ SPLICE_EXPR_EXPRESSION_P (in SPLICE_EXPR)\n+ OLD_PARM_DECL_P (in PARM_DECL)\n+ COMPONENT_REF_SPLICE_P (in COMPONENT_REF)\n 1: IDENTIFIER_KIND_BIT_1 (in IDENTIFIER_NODE)\n TI_PENDING_TEMPLATE_FLAG.\n TEMPLATE_PARMS_FOR_INLINE.\n@@ -476,6 +485,7 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];\n STATIC_INIT_DECOMP_BASE_P (in the TREE_LIST for {static,tls}_aggregates)\n MUST_NOT_THROW_THROW_P (in MUST_NOT_THROW_EXPR)\n LAMBDA_EXPR_CONST_QUAL_P (in LAMBDA_EXPR)\n+ SPLICE_EXPR_MEMBER_ACCESS_P (in SPLICE_EXPR)\n 2: IDENTIFIER_KIND_BIT_2 (in IDENTIFIER_NODE)\n ICS_THIS_FLAG (in _CONV)\n DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (in VAR_DECL)\n@@ -499,6 +509,8 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];\n STATIC_INIT_DECOMP_NONBASE_P (in the TREE_LIST\n \t\t\t\t for {static,tls}_aggregates)\n MUST_NOT_THROW_CATCH_P (in MUST_NOT_THROW_EXPR)\n+ MULTIPLE_NAMES_PARM_P (in PARM_DECL)\n+ SPLICE_EXPR_ADDRESS_P (in SPLICE_EXPR)\n 3: IMPLICIT_RVALUE_P (in NON_LVALUE_EXPR or STATIC_CAST_EXPR)\n ICS_BAD_FLAG (in _CONV)\n FN_TRY_BLOCK_P (in TRY_BLOCK)\n@@ -541,6 +553,7 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];\n 1: TYPE_HAS_USER_CONSTRUCTOR.\n 2: TYPE_HAS_LATE_RETURN_TYPE (in FUNCTION_TYPE, METHOD_TYPE)\n TYPE_PTRMEMFUNC_FLAG (in RECORD_TYPE)\n+ ENUM_BEING_DEFINED_P (in ENUMERAL_TYPE)\n 4: TYPE_HAS_NONTRIVIAL_DESTRUCTOR\n 5: CLASS_TYPE_P (in RECORD_TYPE and UNION_TYPE)\n ENUM_FIXED_UNDERLYING_TYPE_P (in ENUMERAL_TYPE)\n@@ -1883,6 +1896,98 @@ struct GTY(()) tree_tu_local_entity {\n #define REQUIRES_EXPR_EXTRA_ARGS(NODE) \\\n TREE_OPERAND (TREE_CHECK (NODE, REQUIRES_EXPR), 2)\n \n+/* True iff TYPE is cv decltype(^^int). */\n+#define REFLECTION_TYPE_P(TYPE) (TREE_CODE (TYPE) == META_TYPE)\n+\n+/* True if NODE is a REFLECT_EXPR. */\n+#define REFLECT_EXPR_P(NODE) (TREE_CODE (NODE) == REFLECT_EXPR)\n+\n+/* The handle of a reflection expression. */\n+#define REFLECT_EXPR_HANDLE(NODE) \\\n+ TREE_OPERAND (TREE_CHECK (NODE, REFLECT_EXPR), 0)\n+\n+/* Various kinds of reflections. Sometimes we cannot simply look at the\n+ handle and figure out the kind from it. For instance,\n+\n+ consteval void fn(int p) {\n+ constexpr auto rp = parameters_of(^^fn)[0];\n+ // is_variable(^^p) is true\n+ // is_function_parameter(^^p) is false\n+ // is_variable(rp) is false\n+ // is_function_parameter(rp) is true\n+ }\n+\n+ but we represent the handle p with a PARM_DECL in all cases.\n+\n+ The size is limited to addr_space_t because we only have 8 bits. */\n+\n+enum reflect_kind : addr_space_t {\n+ /* Detect the category from the handle. */\n+ REFLECT_UNDEF,\n+ /* The reflection represents an object. */\n+ REFLECT_OBJECT,\n+ /* The reflection represents a value. */\n+ REFLECT_VALUE,\n+ /* The reflection represents a variable. Used for underlying\n+ variable of tuple structured binding. */\n+ REFLECT_VAR,\n+ /* The reflection represents a function parameter. */\n+ REFLECT_PARM,\n+ /* The reflection represents a data member description. */\n+ REFLECT_DATA_MEMBER_SPEC,\n+ /* The reflection represents a direct base relationship. */\n+ REFLECT_BASE,\n+ /* The reflection represents an annotation. */\n+ REFLECT_ANNOTATION\n+};\n+\n+/* The reflect_kind of a REFLECT_EXPR. */\n+#define REFLECT_EXPR_KIND(NODE) \\\n+ (static_cast \\\n+ (REFLECT_EXPR_CHECK (NODE)->base.u.bits.address_space))\n+\n+#define SET_REFLECT_EXPR_KIND(NODE, VAL) \\\n+ (REFLECT_EXPR_CHECK (NODE)->base.u.bits.address_space = VAL)\n+\n+/* True if this SPLICE_EXPR represents a splice-expression (as opposed to\n+ a splice-specifier), so it cannot expand to e.g. a type. */\n+#define SPLICE_EXPR_EXPRESSION_P(NODE) \\\n+ TREE_LANG_FLAG_0 (SPLICE_EXPR_CHECK (NODE))\n+\n+/* Helper macro to set SPLICE_EXPR_EXPRESSION_P. This macro handles\n+ dependent_splice_p trees: either [:T:] or [:T:]. */\n+#define SET_SPLICE_EXPR_EXPRESSION_P(NODE) \\\n+ (SPLICE_EXPR_EXPRESSION_P (TREE_CODE (NODE) == SPLICE_EXPR \\\n+\t\t\t ? NODE : TREE_OPERAND (NODE, 0)) = true)\n+\n+/* True if this SPLICE_EXPR is used in foo.[: bar :] or foo->[: bar :]\n+ context. */\n+#define SPLICE_EXPR_MEMBER_ACCESS_P(NODE) \\\n+ TREE_LANG_FLAG_1 (SPLICE_EXPR_CHECK (NODE))\n+\n+/* Helper macro to set SPLICE_EXPR_MEMBER_ACCESS_P. */\n+#define SET_SPLICE_EXPR_MEMBER_ACCESS_P(NODE, VAL) \\\n+ (SPLICE_EXPR_MEMBER_ACCESS_P (TREE_CODE (NODE) == SPLICE_EXPR \\\n+\t\t\t\t? NODE : TREE_OPERAND (NODE, 0)) = (VAL))\n+\n+/* True if we are taking the address of this SPLICE_EXPR. */\n+#define SPLICE_EXPR_ADDRESS_P(NODE) \\\n+ TREE_LANG_FLAG_2 (SPLICE_EXPR_CHECK (NODE))\n+\n+/* Helper macro to set SPLICE_EXPR_ADDRESS_P. */\n+#define SET_SPLICE_EXPR_ADDRESS_P(NODE, VAL) \\\n+ (SPLICE_EXPR_ADDRESS_P (TREE_CODE (NODE) == SPLICE_EXPR \\\n+\t\t\t ? NODE : TREE_OPERAND (NODE, 0)) = (VAL))\n+\n+/* The expression in question for a SPLICE_SCOPE. */\n+#define SPLICE_SCOPE_EXPR(NODE) \\\n+ (TYPE_VALUES_RAW (SPLICE_SCOPE_CHECK (NODE)))\n+\n+/* True if this splice represents a splice-type-specifier rather than\n+ a splice-scope-specifier. */\n+#define SPLICE_SCOPE_TYPE_P(NODE) \\\n+ (SPLICE_SCOPE_CHECK (NODE))->type_common.string_flag\n+\n enum cp_tree_node_structure_enum {\n TS_CP_GENERIC,\n TS_CP_IDENTIFIER,\n@@ -2366,6 +2471,7 @@ enum languages { lang_c, lang_cplusplus };\n || TREE_CODE (T) == DECLTYPE_TYPE\t\t\t\\\n || TREE_CODE (T) == TRAIT_TYPE\t\t\t\\\n || TREE_CODE (T) == DEPENDENT_OPERATOR_TYPE\t\t\\\n+ || TREE_CODE (T) == SPLICE_SCOPE\t\t\t\\\n || TREE_CODE (T) == PACK_INDEX_TYPE)\n \n /* Nonzero if T is a class (or struct or union) type. Also nonzero\n@@ -4372,6 +4478,11 @@ templated_operator_saved_lookups (tree t)\n #define REF_PARENTHESIZED_P(NODE) \\\n TREE_LANG_FLAG_2 (TREE_CHECK5 ((NODE), COMPONENT_REF, INDIRECT_REF, SCOPE_REF, VIEW_CONVERT_EXPR, PAREN_EXPR))\n \n+/* True on a dependent COMPONENT_REF with a splice expression. */\n+\n+#define COMPONENT_REF_SPLICE_P(NODE) \\\n+ TREE_LANG_FLAG_0 (COMPONENT_REF_CHECK (NODE))\n+\n /* Nonzero if this AGGR_INIT_EXPR provides for initialization via a\n constructor call, rather than an ordinary function call. */\n #define AGGR_INIT_VIA_CTOR_P(NODE) \\\n@@ -4749,9 +4860,9 @@ get_vec_init_expr (tree t)\n \n /* [basic.types]\n \n- Arithmetic types, enumeration types, pointer types,\n- pointer-to-member types, and std::nullptr_t are collectively called\n- scalar types.\n+ Arithmetic types, enumeration types, pointer types, pointer-to-member types,\n+ std::meta::info, std::nullptr_t and cv-qualified versions of these types\n+ are collectively called scalar types.\n \n Keep these checks in ascending code order. */\n #define SCALAR_TYPE_P(TYPE)\t\t\t\\\n@@ -4760,7 +4871,8 @@ get_vec_init_expr (tree t)\n || ARITHMETIC_TYPE_P (TYPE)\t\t\t\\\n || TYPE_PTR_P (TYPE)\t\t\t\t\\\n || TYPE_PTRMEMFUNC_P (TYPE) \\\n- || NULLPTR_TYPE_P (TYPE))\n+ || NULLPTR_TYPE_P (TYPE)\t\t\t\\\n+ || REFLECTION_TYPE_P (TYPE))\n \n /* Determines whether this type is a C++0x scoped enumeration\n type. Scoped enumerations types are introduced via \"enum class\" or\n@@ -4801,6 +4913,11 @@ get_vec_init_expr (tree t)\n #define OPAQUE_ENUM_P(TYPE)\t\t\t\t\\\n (TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_OPAQUE (TYPE))\n \n+/* Nonzero when the ENUMERAL_TYPE is being defined (enumerators parsed\n+ or instantiated). */\n+#define ENUM_BEING_DEFINED_P(NODE) \\\n+ (TYPE_LANG_FLAG_2 (ENUMERAL_TYPE_CHECK (NODE)))\n+\n /* [dcl.init.aggr]\n \n An aggregate is an array or a class with no user-provided\n@@ -5168,6 +5285,18 @@ get_vec_init_expr (tree t)\n #define DECL_ARRAY_PARAMETER_P(NODE) \\\n DECL_LANG_FLAG_1 (PARM_DECL_CHECK (NODE))\n \n+/* Nonzero for PARM_DECL node means it is a parameter of an earlier\n+ declaration which is no longer in DECL_ARGUMENTS (DECL_CONTEXT (NODE))\n+ chain because a function definition has been parsed later. */\n+#define OLD_PARM_DECL_P(NODE) \\\n+ TREE_LANG_FLAG_0 (PARM_DECL_CHECK (NODE))\n+\n+/* Nonzero for PARM_DECL node means it has different names on different\n+ declarations of the same FUNCTION_DECL. If it is unnamed on one and\n+ named on another, that is still fine. */\n+#define MULTIPLE_NAMES_PARM_P(NODE) \\\n+ TREE_LANG_FLAG_2 (PARM_DECL_CHECK (NODE))\n+\n /* Nonzero for a FIELD_DECL who's NSMDI is currently being\n instantiated. */\n #define DECL_INSTANTIATING_NSDMI_P(NODE) \\\n@@ -6029,6 +6158,8 @@ extern bool comparing_override_contracts;\n \n /* In parser.cc. */\n \n+extern bool cp_preserve_using_decl;\n+\n /* Nonzero if we are parsing an unevaluated operand: an operand to\n sizeof, typeof, or alignof. This is a count since operands to\n sizeof can be nested. */\n@@ -6526,8 +6657,8 @@ enum ovl_op_flags {\n enum ovl_op_code {\n OVL_OP_ERROR_MARK,\n OVL_OP_NOP_EXPR,\n-#define DEF_OPERATOR(NAME, CODE, MANGLING, FLAGS) OVL_OP_##CODE,\n-#define DEF_ASSN_OPERATOR(NAME, CODE, MANGLING) /* NOTHING */\n+#define DEF_OPERATOR(NAME, CODE, MANGLING, FLAGS, META) OVL_OP_##CODE,\n+#define DEF_ASSN_OPERATOR(NAME, CODE, MANGLING, META) /* NOTHING */\n #include \"operators.def\"\n OVL_OP_MAX\n };\n@@ -6542,6 +6673,9 @@ struct GTY(()) ovl_op_info_t {\n const char *name;\n /* The mangled name of the operator. */\n const char *mangled_name;\n+ /* The name of the std::meta::operators enumerator without\n+ the \"op_\" prefix if any (otherwise NULL). */\n+ const char *meta_name;\n /* The (regular) tree code. */\n enum tree_code tree_code : 16;\n /* The (compressed) operator code. */\n@@ -6933,6 +7067,7 @@ enum cp_built_in_function {\n CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS,\n CP_BUILT_IN_SOURCE_LOCATION,\n CP_BUILT_IN_EH_PTR_ADJUST_REF,\n+ CP_BUILT_IN_IS_STRING_LITERAL,\n CP_BUILT_IN_LAST\n };\n \n@@ -7844,6 +7979,7 @@ extern void remove_dummy_lambda_op (tree, tree);\n extern tree canonical_type_parameter\t\t(tree);\n extern void push_access_scope\t\t\t(tree);\n extern void pop_access_scope\t\t\t(tree);\n+extern tree current_function_decl_without_access_scope ();\n extern bool check_template_shadow\t\t(tree);\n extern tree get_innermost_template_args\t\t(tree, int);\n extern void maybe_begin_member_template_processing (tree);\n@@ -7963,6 +8099,7 @@ extern int processing_template_parmlist;\n extern bool dependent_type_p\t\t\t(tree);\n extern bool dependent_scope_p\t\t\t(tree);\n extern bool dependentish_scope_p\t\t(tree);\n+extern bool dependent_namespace_p\t\t(tree);\n extern bool any_dependent_template_arguments_p (const_tree);\n extern bool any_erroneous_template_args_p (const_tree);\n extern bool dependent_template_p\t\t(tree);\n@@ -8045,6 +8182,7 @@ extern tree add_outermost_template_args\t\t(tree, tree);\n extern tree add_extra_args\t\t\t(tree, tree, tsubst_flags_t, tree);\n extern tree build_extra_args\t\t\t(tree, tree, tsubst_flags_t);\n extern void finish_expansion_stmt\t\t(tree, tree, tsubst_flags_t, tree);\n+extern tree convert_reflect_constant_arg\t(tree, tree);\n \n /* in rtti.cc */\n /* A vector of all tinfo decls that haven't been emitted yet. */\n@@ -8243,9 +8381,10 @@ extern tree finish_template_template_parm (tree, tree);\n extern tree begin_class_definition\t\t(tree);\n extern void finish_template_decl\t\t(tree);\n extern tree finish_template_type\t\t(tree, tree, int);\n-extern tree finish_base_specifier\t\t(tree, tree, bool);\n+extern tree finish_base_specifier\t\t(tree, tree, bool, tree);\n extern void finish_member_declaration\t\t(tree);\n extern bool outer_automatic_var_p\t\t(tree);\n+extern bool parsing_lambda_declarator\t\t();\n extern tree process_outer_var_ref\t\t(tree, tsubst_flags_t, bool force_use = false);\n extern cp_expr finish_id_expression\t\t(tree, tree, tree,\n \t\t\t\t\t\t cp_id_kind *,\n@@ -8326,6 +8465,7 @@ extern tree finish_decltype_type (tree, bool, tsubst_flags_t);\n extern tree fold_builtin_is_corresponding_member (location_t, int, tree *);\n extern bool pointer_interconvertible_base_of_p\t(tree, tree, bool = false);\n extern tree fold_builtin_is_pointer_inverconvertible_with_class (location_t, int, tree *);\n+extern tree fold_builtin_is_string_literal\t(location_t, int, tree *);\n extern tree finish_structured_binding_size\t(location_t, tree, tsubst_flags_t);\n extern tree finish_trait_expr\t\t\t(location_t, enum cp_trait_kind, tree, tree);\n extern tree finish_trait_type\t\t\t(enum cp_trait_kind, tree, tree, tsubst_flags_t);\n@@ -8540,6 +8680,7 @@ extern tree cxx_copy_lang_qualifiers\t\t(const_tree, const_tree);\n \n extern void cxx_print_statistics\t\t(void);\n extern bool maybe_warn_zero_as_null_pointer_constant (tree, location_t);\n+extern bool annotation_p\t\t\t(tree) ATTRIBUTE_PURE;\n \n /* in ptree.cc */\n extern void cxx_print_xnode\t\t\t(FILE *, tree, int);\n@@ -8593,7 +8734,7 @@ extern tree decay_conversion\t\t\t(tree,\n extern tree build_class_member_access_expr (cp_expr, tree, tree, bool,\n \t\t\t\t\t\t tsubst_flags_t);\n extern tree finish_class_member_access_expr (cp_expr, tree, bool,\n-\t\t\t\t\t\t tsubst_flags_t);\n+\t\t\t\t\t\t tsubst_flags_t, bool = false);\n extern tree lookup_destructor\t\t\t(tree, tree, tree, tsubst_flags_t);\n extern tree build_dependent_operator_type\t(tree, enum tree_code, bool);\n extern tree build_x_indirect_ref\t\t(location_t, tree,\n@@ -8902,6 +9043,8 @@ extern tree process_stmt_assume_attribute\t(tree, tree, location_t);\n extern bool simple_empty_class_p\t\t(tree, tree, tree_code);\n extern tree fold_builtin_source_location\t(const_tree);\n extern tree get_source_location_impl_type\t();\n+extern bool immediate_escalating_function_p\t(tree);\n+extern void promote_function_to_consteval\t(tree);\n extern tree cp_fold_immediate\t\t\t(tree *, mce_value,\n \t\t\t\t\t\t tree = current_function_decl);\n extern void process_and_check_pending_immediate_escalating_fns ();\n@@ -9058,6 +9201,7 @@ extern bool is_nondependent_static_init_expression (tree);\n extern bool is_static_init_expression (tree);\n extern bool is_std_class (tree, const char *);\n extern bool is_std_allocator (tree);\n+extern bool is_std_allocator_allocate (tree);\n extern bool potential_rvalue_constant_expression (tree);\n extern bool require_potential_constant_expression (tree);\n extern bool require_constant_expression (tree);\n@@ -9099,6 +9243,24 @@ extern tree find_failing_clause\t\t\t(const constexpr_ctx *ctx, tree);\n extern void diagnose_failing_condition\t\t(tree, location_t, bool,\n \t\t\t\t\t\t const constexpr_ctx * = nullptr);\n extern bool replace_decl\t\t\t(tree *, tree, tree);\n+extern tree cxa_allocate_and_throw_exception\t(location_t, const constexpr_ctx *,\n+\t\t\t\t\t\t tree);\n+\n+/* Whether our evaluation wants a prvalue (e.g. CONSTRUCTOR or _CST),\n+ a glvalue (e.g. VAR_DECL or _REF), or nothing. */\n+enum value_cat {\n+ vc_prvalue = 0,\n+ vc_glvalue = 1,\n+ vc_discard = 2\n+};\n+\n+extern tree cxx_eval_constant_expression\t(const constexpr_ctx *, tree,\n+\t\t\t\t\t\t value_cat, bool *, bool *,\n+\t\t\t\t\t\t tree *);\n+extern bool cxx_constexpr_quiet_p\t\t(const constexpr_ctx *);\n+extern mce_value cxx_constexpr_manifestly_const_eval (const constexpr_ctx *);\n+extern tree cxx_constexpr_caller\t\t(const constexpr_ctx *);\n+extern tree cxx_constexpr_consteval_block\t(const constexpr_ctx *);\n \n /* An RAII sentinel used to restrict constexpr evaluation so that it\n doesn't do anything that causes extra DECL_UID generation. */\n@@ -9142,6 +9304,27 @@ extern tree coro_get_ramp_function\t\t(tree);\n \n extern tree co_await_get_resume_call\t\t(tree await_expr);\n \n+\n+/* In reflect.cc */\n+extern void init_reflection ();\n+extern bool metafunction_p (tree) ATTRIBUTE_PURE;\n+extern tree process_metafunction (const constexpr_ctx *, tree, tree,\n+\t\t\t\t bool *, bool *, tree *);\n+extern tree get_reflection (location_t, tree, reflect_kind = REFLECT_UNDEF);\n+extern tree get_null_reflection () ATTRIBUTE_PURE;\n+extern tree splice (tree);\n+extern bool check_out_of_consteval_use (tree, bool = true);\n+extern bool consteval_only_p (tree) ATTRIBUTE_PURE;\n+extern bool compare_reflections (tree, tree) ATTRIBUTE_PURE;\n+extern bool valid_splice_type_p (const_tree) ATTRIBUTE_PURE;\n+extern bool valid_splice_scope_p (const_tree) ATTRIBUTE_PURE;\n+extern bool check_splice_expr (location_t, location_t, tree, bool, bool, bool)\n+ ATTRIBUTE_PURE;\n+extern tree make_splice_scope (tree, bool);\n+extern bool dependent_splice_p (const_tree) ATTRIBUTE_PURE;\n+extern tree reflection_mangle_prefix (tree, char [3]);\n+extern void check_consteval_only_fn (tree);\n+\n /* Inline bodies. */\n \n inline tree\ndiff --git a/gcc/cp/cvt.cc b/gcc/cp/cvt.cc\nindex 68d51b61375..78719260506 100644\n--- a/gcc/cp/cvt.cc\n+++ b/gcc/cp/cvt.cc\n@@ -1207,6 +1207,12 @@ convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain)\n if (concept_check_p (expr))\n expr = evaluate_concept_check (expr);\n \n+ /* Detect using expressions of consteval-only types outside manifestly\n+ constant-evaluated contexts. We are going to discard this expression,\n+ so we can't wait till cp_fold_immediate_r. */\n+ if (check_out_of_consteval_use (expr))\n+ return error_mark_node;\n+\n if (VOID_TYPE_P (TREE_TYPE (expr)))\n return expr;\n \ndiff --git a/gcc/cp/cxx-pretty-print.cc b/gcc/cp/cxx-pretty-print.cc\nindex 4916bf66ee2..65f5e2816e3 100644\n--- a/gcc/cp/cxx-pretty-print.cc\n+++ b/gcc/cp/cxx-pretty-print.cc\n@@ -813,6 +813,7 @@ pp_cxx_delete_expression (cxx_pretty_printer *pp, tree t)\n sizeof ... ( identifier )\n new-expression\n delete-expression\n+ reflect-expression\n \n unary-operator: one of\n * & + - !\n@@ -898,6 +899,19 @@ cxx_pretty_printer::unary_expression (tree t)\n pp_cxx_cast_expression (this, TREE_OPERAND (t, 0));\n break;\n \n+ case REFLECT_EXPR:\n+ {\n+\tpp_cxx_ws_string (this, \"^^\");\n+\ttree h = REFLECT_EXPR_HANDLE (t);\n+\tif (DECL_P (h))\n+\t declaration (h);\n+\telse if (TYPE_P (h))\n+\t type_id (h);\n+\telse\n+\t expression (h);\n+ }\n+ break;\n+\n default:\n c_pretty_printer::unary_expression (t);\n break;\n@@ -1184,6 +1198,7 @@ cxx_pretty_printer::expression (tree t)\n case ALIGNOF_EXPR:\n case NOEXCEPT_EXPR:\n case UNARY_PLUS_EXPR:\n+ case REFLECT_EXPR:\n unary_expression (t);\n break;\n \n@@ -1427,6 +1442,10 @@ cxx_pretty_printer::simple_type_specifier (tree t)\n pp_cxx_trait (this, t);\n break;\n \n+ case META_TYPE:\n+ pp_cxx_ws_string (this, \"std::meta::info\");\n+ break;\n+\n default:\n c_pretty_printer::simple_type_specifier (t);\n break;\n@@ -1923,6 +1942,7 @@ cxx_pretty_printer::type_id (tree t)\n case NULLPTR_TYPE:\n case TEMPLATE_ID_EXPR:\n case OFFSET_TYPE:\n+ case META_TYPE:\n pp_cxx_type_specifier_seq (this, t);\n if (TYPE_PTRMEM_P (t))\n \tabstract_declarator (t);\ndiff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc\nindex 30f38f1e099..88d0a3fe59a 100644\n--- a/gcc/cp/decl.cc\n+++ b/gcc/cp/decl.cc\n@@ -134,6 +134,7 @@ static bool identify_goto (tree, location_t, const location_t *,\n Namespaces,\n \n \ttree std_node;\n+\ttree std_meta_node;\n \ttree abi_node;\n \n A FUNCTION_DECL which can call `abort'. Not necessarily the\n@@ -3042,9 +3043,10 @@ duplicate_decls (tree newdecl, tree olddecl, bool hiding, bool was_hidden)\n \n /* Merge parameter attributes. */\n tree oldarg, newarg;\n- for (oldarg = DECL_ARGUMENTS(olddecl), newarg = DECL_ARGUMENTS(newdecl);\n- oldarg && newarg;\n- oldarg = DECL_CHAIN(oldarg), newarg = DECL_CHAIN(newarg))\n+ for (oldarg = DECL_ARGUMENTS (olddecl),\n+\t newarg = DECL_ARGUMENTS (newdecl);\n+\t oldarg && newarg;\n+\t oldarg = DECL_CHAIN (oldarg), newarg = DECL_CHAIN (newarg))\n \t{\n DECL_ATTRIBUTES (newarg)\n \t = (*targetm.merge_decl_attributes) (oldarg, newarg);\n@@ -3062,6 +3064,62 @@ duplicate_decls (tree newdecl, tree olddecl, bool hiding, bool was_hidden)\n \t\t \"earlier declaration\");\n \t }\n DECL_ATTRIBUTES (oldarg) = DECL_ATTRIBUTES (newarg);\n+\t /* Merge names for std::meta::has_identifier and\n+\t std::meta::{,u8}identifier_of purposes. If they are different\n+\t and both oldarg and newarg are named, add flag to force that\n+\t std::meta::has_identifier returns false. If one is named and\n+\t one is unnamed, if neither is a olddecl nor newdecl is definition,\n+\t propagate DECL_NAME to both. Otherwise stash the old name into\n+\t \"old parm name\" artificial attribute. */\n+\t if (flag_reflection && DECL_NAME (oldarg) != DECL_NAME (newarg))\n+\t {\n+\t if (DECL_NAME (oldarg) && DECL_NAME (newarg))\n+\t\t{\n+\t\t /* Different names. */\n+\t\t MULTIPLE_NAMES_PARM_P (oldarg) = 1;\n+\t\t MULTIPLE_NAMES_PARM_P (newarg) = 1;\n+\t\t}\n+\t else if (!new_defines_function\n+\t\t && types_match\n+\t\t && DECL_INITIAL (olddecl) == NULL_TREE)\n+\t\t{\n+\t\t /* For 2 non-definitions with matching types,\n+\t\t one is named and one unnamed, propagate name\n+\t\t to both. */\n+\t\t if (DECL_NAME (oldarg))\n+\t\t DECL_NAME (newarg) = DECL_NAME (oldarg);\n+\t\t else\n+\t\t DECL_NAME (oldarg) = DECL_NAME (newarg);\n+\t\t}\n+\t /* Depending on which PARM_DECL we'll keep, look at the other\n+\t\t PARM_DECL's name. */\n+\t else if (tree name = ((new_defines_function || !types_match)\n+\t\t\t\t ? DECL_NAME (oldarg) : DECL_NAME (newarg)))\n+\t\t{\n+\t\t tree opn = lookup_attribute (\"old parm name\",\n+\t\t\t\t\t DECL_ATTRIBUTES (oldarg));\n+\t\t if (opn)\n+\t\t {\n+\t\t if (TREE_VALUE (TREE_VALUE (opn)) == name)\n+\t\t\t/* Name already in \"old parm name\" attribute. */;\n+\t\t else\n+\t\t\t{\n+\t\t\t /* Different names. */\n+\t\t\t MULTIPLE_NAMES_PARM_P (oldarg) = 1;\n+\t\t\t MULTIPLE_NAMES_PARM_P (newarg) = 1;\n+\t\t\t}\n+\t\t }\n+\t\t else\n+\t\t {\n+\t\t /* Save name into attribute. */\n+\t\t DECL_ATTRIBUTES (newarg)\n+\t\t\t= tree_cons (get_identifier (\"old parm name\"),\n+\t\t\t\t tree_cons (NULL_TREE, name, NULL_TREE),\n+\t\t\t\t DECL_ATTRIBUTES (newarg));\n+\t\t DECL_ATTRIBUTES (oldarg) = DECL_ATTRIBUTES (newarg);\n+\t\t }\n+\t\t}\n+\t }\n \t}\n \n if (DECL_TEMPLATE_INSTANTIATION (olddecl)\n@@ -3159,6 +3217,15 @@ duplicate_decls (tree newdecl, tree olddecl, bool hiding, bool was_hidden)\n \t if (tree contracts = DECL_CONTRACTS (newdecl))\n \t remap_contracts (olddecl, newdecl, contracts, true);\n \n+\t /* Mark the old PARM_DECLs in case std::meta::parameters_of has\n+\t been called on the old declaration and reflections of those\n+\t arguments are held across this point and used later.\n+\t Such PARM_DECLs are no longer present in\n+\t DECL_ARGUMENTS (DECL_CONTEXT (oldarg)) chain. */\n+\t for (tree oldarg = DECL_ARGUMENTS (olddecl);\n+\t oldarg; oldarg = DECL_CHAIN (oldarg))\n+\t OLD_PARM_DECL_P (oldarg) = 1;\n+\n \t /* These need to be copied so that the names are available.\n \t Note that if the types do match, we'll preserve inline\n \t info and other bits, but if not, we won't. */\n@@ -5329,6 +5396,7 @@ initialize_predefined_identifiers (void)\n {\"heap []\", &heap_vec_identifier, cik_normal},\n {\"omp\", &omp_identifier, cik_normal},\n {\"internal \", &internal_identifier, cik_normal},\n+ {\"annotation \", &annotation_identifier, cik_normal},\n {NULL, NULL, cik_normal}\n };\n \n@@ -5511,6 +5579,15 @@ cxx_init_decl_processing (void)\n /* Create the `std' namespace. */\n push_namespace (get_identifier (\"std\"));\n std_node = current_namespace;\n+ if (flag_reflection)\n+ {\n+ /* Note that we haven't initialized void_type_node yet, so\n+\t std_meta_node will be initially typeless; its type will be\n+\t set a little later in init_reflection. */\n+ push_namespace (get_identifier (\"meta\"), /*inline*/false);\n+ std_meta_node = current_namespace;\n+ pop_namespace ();\n+ }\n pop_namespace ();\n \n flag_noexcept_type = (cxx_dialect >= cxx17);\n@@ -5562,6 +5639,13 @@ cxx_init_decl_processing (void)\n set_call_expr_flags (decl, ECF_NOTHROW | ECF_LEAF);\n }\n \n+ decl\n+ = add_builtin_function (\"__builtin_is_string_literal\",\n+\t\t\t bool_vaftype,\n+\t\t\t CP_BUILT_IN_IS_STRING_LITERAL,\n+\t\t\t BUILT_IN_FRONTEND, NULL, NULL_TREE);\n+ set_call_expr_flags (decl, ECF_CONST | ECF_NOTHROW | ECF_LEAF);\n+\n integer_two_node = build_int_cst (NULL_TREE, 2);\n \n /* Guess at the initial static decls size. */\n@@ -5692,6 +5776,9 @@ cxx_init_decl_processing (void)\n if (modules_p ())\n init_modules (parse_in);\n \n+ if (flag_reflection)\n+ init_reflection ();\n+\n make_fname_decl = cp_make_fname_decl;\n start_fname_decls ();\n \n@@ -7219,6 +7306,10 @@ maybe_commonize_var (tree decl)\n if (DECL_ARTIFICIAL (decl) && !DECL_DECOMPOSITION_P (decl))\n return;\n \n+ /* These are not output at all. */\n+ if (consteval_only_p (decl))\n+ return;\n+\n /* Static data in a function with comdat linkage also has comdat\n linkage. */\n if ((TREE_STATIC (decl)\n@@ -8576,6 +8667,16 @@ check_initializer (tree decl, tree init, int flags, vec **cleanups)\n \t init = NULL_TREE;\n \t}\n }\n+ else if (!init && REFLECTION_TYPE_P (type))\n+ {\n+ /* [dcl.init.general]: To default-initialize an object of type\n+\t std::meta::info means that the object is zero-initialized. */\n+ DECL_INITIAL (decl)\n+\t= build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);\n+ DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = true;\n+ TREE_CONSTANT (decl) = true;\n+ init = NULL_TREE;\n+ }\n else\n {\n if (CLASS_TYPE_P (core_type = strip_array_types (type))\n@@ -8695,6 +8796,14 @@ make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)\n if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))\n return;\n \n+ /* Don't output reflection variables. */\n+ if (consteval_only_p (decl))\n+ {\n+ /* Disable assemble_variable. */\n+ DECL_EXTERNAL (decl) = true;\n+ return;\n+ }\n+\n /* We defer emission of local statics until the corresponding\n DECL_EXPR is expanded. But with constexpr its function might never\n be expanded, so go ahead and tell cgraph about the variable now. */\n@@ -9742,6 +9851,10 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p,\n \t }\n \t}\n \n+ /* Detect stuff like 'info r = ^^int;' outside a manifestly\n+\t constant-evaluated context. */\n+ check_out_of_consteval_use (decl);\n+\n /* If this is a local variable that will need a mangled name,\n \t register it now. We must do this before processing the\n \t initializer for the variable, since the initialization might\n@@ -9750,7 +9863,8 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p,\n \t variable. */\n if (DECL_FUNCTION_SCOPE_P (decl)\n \t && TREE_STATIC (decl)\n-\t && !DECL_ARTIFICIAL (decl))\n+\t && !DECL_ARTIFICIAL (decl)\n+\t && !consteval_only_p (decl))\n \t{\n \t /* The variable holding an anonymous union will have had its\n \t discriminator set in finish_anon_union, after which it's\n@@ -10279,7 +10393,7 @@ get_tuple_size (tree type)\n inst = complete_type (inst);\n if (inst == error_mark_node\n || !COMPLETE_TYPE_P (inst)\n- || !CLASS_TYPE_P (type))\n+ || !CLASS_TYPE_P (inst))\n return NULL_TREE;\n tree val = lookup_qualified_name (inst, value_identifier,\n \t\t\t\t LOOK_want::NORMAL, /*complain*/false);\n@@ -12556,6 +12670,8 @@ grokfndecl (tree ctype,\n if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))\n return NULL_TREE;\n \n+ check_consteval_only_fn (decl);\n+\n if (ctype == NULL_TREE || check)\n return decl;\n \n@@ -18351,6 +18467,8 @@ xref_basetypes (tree ref, tree base_list)\n unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */\n unsigned max_bases = 0; /* Maximum direct bases. */\n unsigned max_dvbases = 0; /* Maximum direct virtual bases. */\n+ /* Highest direct base index with annotations. */\n+ unsigned max_annotated_base = 0;\n int i;\n tree default_access;\n tree igo_prev; /* Track Inheritance Graph Order. */\n@@ -18388,6 +18506,8 @@ xref_basetypes (tree ref, tree base_list)\n else\n \t{\n \t max_bases++;\n+\t if (TREE_CODE (TREE_PURPOSE (*basep)) == TREE_LIST)\n+\t max_annotated_base = max_bases;\n \t if (TREE_TYPE (*basep))\n \t max_dvbases++;\n \t if (CLASS_TYPE_P (basetype))\n@@ -18416,7 +18536,8 @@ xref_basetypes (tree ref, tree base_list)\n \n if (max_bases)\n {\n- vec_alloc (BINFO_BASE_ACCESSES (binfo), max_bases);\n+ vec_alloc (BINFO_BASE_ACCESSES (binfo), max_bases + max_annotated_base);\n+ BINFO_BASE_ACCESSES (binfo)->quick_grow (max_bases + max_annotated_base);\n /* A C++98 POD cannot have base classes. */\n CLASSTYPE_NON_LAYOUT_POD_P (ref) = true;\n \n@@ -18446,6 +18567,30 @@ xref_basetypes (tree ref, tree base_list)\n for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))\n {\n tree access = TREE_PURPOSE (base_list);\n+ tree annotations = NULL_TREE;\n+ if (TREE_CODE (access) == TREE_LIST)\n+\t{\n+\t annotations = TREE_VALUE (access);\n+\t access = TREE_PURPOSE (access);\n+\t for (tree *d = &annotations; *d; )\n+\t {\n+\t if (annotation_p (*d))\n+\t\t{\n+\t\t tree name = get_attribute_name (*d);\n+\t\t tree args = TREE_VALUE (*d);\n+\t\t const attribute_spec *as\n+\t\t = lookup_attribute_spec (TREE_PURPOSE (*d));\n+\t\t bool no_add_attrs = false;\n+\t\t as->handler (&binfo, name, args, 0, &no_add_attrs);\n+\t\t if (no_add_attrs)\n+\t\t {\n+\t\t *d = TREE_CHAIN (*d);\n+\t\t continue;\n+\t\t }\n+\t\t}\n+\t d = &TREE_CHAIN (*d);\n+\t }\n+\t}\n int via_virtual = TREE_TYPE (base_list) != NULL_TREE;\n tree basetype = TREE_VALUE (base_list);\n \n@@ -18512,8 +18657,12 @@ xref_basetypes (tree ref, tree base_list)\n if (!BINFO_INHERITANCE_CHAIN (base_binfo))\n \tBINFO_INHERITANCE_CHAIN (base_binfo) = binfo;\n \n+ unsigned len;\n+ len = BINFO_N_BASE_BINFOS (binfo);\n BINFO_BASE_APPEND (binfo, base_binfo);\n- BINFO_BASE_ACCESS_APPEND (binfo, access);\n+ BINFO_BASE_ACCESS (binfo, len) = access;\n+ if (len < max_annotated_base)\n+\tBINFO_BASE_ACCESS (binfo, max_bases + len) = annotations;\n continue;\n \n dropped_base:\n@@ -18529,6 +18678,17 @@ xref_basetypes (tree ref, tree base_list)\n \t -= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype));\n }\n \n+ unsigned len = BINFO_N_BASE_BINFOS (binfo);\n+ if (len < max_bases)\n+ {\n+ if (len && max_annotated_base)\n+\tmemmove (&BINFO_BASE_ACCESS (binfo, len),\n+\t\t &BINFO_BASE_ACCESS (binfo, max_bases),\n+\t\t MIN (max_annotated_base, len) * sizeof (tree));\n+ BINFO_BASE_ACCESSES (binfo)->truncate (len + MIN (max_annotated_base,\n+\t\t\t\t\t\t\tlen));\n+ }\n+\n if (CLASSTYPE_VBASECLASSES (ref)\n && max_vbases == 0)\n vec_free (CLASSTYPE_VBASECLASSES (ref));\n@@ -18798,6 +18958,8 @@ finish_enum_value_list (tree enumtype)\n tree minnode, maxnode;\n tree t;\n \n+ ENUM_BEING_DEFINED_P (enumtype) = 0;\n+\n bool fixed_underlying_type_p\n = ENUM_UNDERLYING_TYPE (enumtype) != NULL_TREE;\n \ndiff --git a/gcc/cp/decl2.cc b/gcc/cp/decl2.cc\nindex 8ec9740c8a9..25daf43945b 100644\n--- a/gcc/cp/decl2.cc\n+++ b/gcc/cp/decl2.cc\n@@ -1472,6 +1472,11 @@ is_late_template_attribute (tree attr, tree decl)\n = lookup_attribute_spec (TREE_PURPOSE (attr));\n tree arg;\n \n+ /* Handle all annotations as late, so that they aren't incorrectly\n+ reordered if some have dependent expressions and others don't. */\n+ if (annotation_p (attr))\n+ return true;\n+\n if (!spec)\n /* Unknown attribute. */\n return false;\n@@ -1747,6 +1752,10 @@ cp_check_const_attributes (tree attributes)\n if (cxx_contract_attribute_p (attr))\n \tcontinue;\n \n+ /* Annotation arguments are handled in handle_annotation_attribute. */\n+ if (annotation_p (attr))\n+\tcontinue;\n+\n tree arg;\n /* As we implement alignas using gnu::aligned attribute and\n \t alignas argument is a constant expression, force manifestly\n@@ -2457,6 +2466,10 @@ maybe_make_one_only (tree decl)\n if (! flag_weak)\n return;\n \n+ /* These are not to be output. */\n+ if (consteval_only_p (decl))\n+ return;\n+\n /* We can't set DECL_COMDAT on functions, or cp_finish_file will think\n we can get away with not emitting them if they aren't used. We need\n to for variables so that cp_finish_decl will update their linkage,\n@@ -2613,6 +2626,10 @@ var_finalized_p (tree var)\n void\n mark_needed (tree decl)\n {\n+ /* These are not to be output. */\n+ if (consteval_only_p (decl))\n+ return;\n+\n TREE_USED (decl) = 1;\n if (TREE_CODE (decl) == FUNCTION_DECL)\n {\n@@ -2831,7 +2848,7 @@ min_vis_r (tree *tp, int *walk_subtrees, void *data)\n /* walk_tree helper function for expr_visibility. */\n \n static tree\n-min_vis_expr_r (tree *tp, int */*walk_subtrees*/, void *data)\n+min_vis_expr_r (tree *tp, int *walk_subtrees, void *data)\n {\n int *vis_p = (int *)data;\n int tpvis = VISIBILITY_DEFAULT;\n@@ -2903,6 +2920,63 @@ min_vis_expr_r (tree *tp, int */*walk_subtrees*/, void *data)\n tpvis = type_visibility (DECL_CONTEXT (t));\n break;\n \n+ case REFLECT_EXPR:\n+ tree r, c;\n+ r = REFLECT_EXPR_HANDLE (t);\n+ switch (REFLECT_EXPR_KIND (t))\n+\t{\n+\tcase REFLECT_BASE:\n+\t /* For direct base class relationship, determine visibility\n+\t from both D and B types. */\n+\t tpvis = type_visibility (BINFO_TYPE (r));\n+\t if (tpvis > *vis_p)\n+\t *vis_p = tpvis;\n+\t c = r;\n+\t /* Looping needed for multiple virtual inheritance. */\n+\t while (BINFO_INHERITANCE_CHAIN (c))\n+\t c = BINFO_INHERITANCE_CHAIN (c);\n+\t tpvis = type_visibility (BINFO_TYPE (c));\n+\t *walk_subtrees = 0;\n+\t break;\n+\tcase REFLECT_DATA_MEMBER_SPEC:\n+\t /* For data member description determine visibility\n+\t from the type. */\n+\t tpvis = type_visibility (TREE_VEC_ELT (r, 0));\n+\t *walk_subtrees = 0;\n+\t break;\n+\tcase REFLECT_PARM:\n+\t /* For function parameter reflection determine visibility\n+\t based on parent_of. */\n+\t tpvis = expr_visibility (DECL_CONTEXT (r));\n+\t *walk_subtrees = 0;\n+\t break;\n+\tcase REFLECT_ANNOTATION:\n+\t /* Annotations are always local to the TU. */\n+\t tpvis = VISIBILITY_ANON;\n+\t *walk_subtrees = 0;\n+\t break;\n+\tcase REFLECT_OBJECT:\n+\t r = get_base_address (r);\n+\t gcc_fallthrough ();\n+\tdefault:\n+\t if (TYPE_P (r))\n+\t {\n+\t tpvis = type_visibility (r);\n+\t *walk_subtrees = 0;\n+\t break;\n+\t }\n+\t if ((VAR_P (r) && decl_function_context (r))\n+\t || TREE_CODE (r) == PARM_DECL)\n+\t {\n+\t /* Block scope variables are local to the TU. */\n+\t tpvis = VISIBILITY_ANON;\n+\t *walk_subtrees = 0;\n+\t break;\n+\t }\n+\t break;\n+\t}\n+ break;\n+\n default:\n break;\n }\n@@ -4785,6 +4859,14 @@ prune_vars_needing_no_initialization (tree *vars)\n \t continue;\n \t}\n \n+ /* Reflections are consteval-only types and we don't want them\n+\t to survive until gimplification. */\n+ if (consteval_only_p (decl))\n+\t{\n+\t var = &TREE_CHAIN (t);\n+\t continue;\n+\t}\n+\n /* This variable is going to need initialization and/or\n \t finalization, so we add it to the list. */\n *var = TREE_CHAIN (t);\n@@ -5133,6 +5215,12 @@ no_linkage_error (tree decl)\n /* An imported decl is ok. */\n return;\n \n+ /* Metafunctions are magic and should be considered defined even though\n+ they have no bodies. ??? This can't be checked in decl_defined_p;\n+ we'd get redefinition errors for some of our metafunctions. */\n+ if (TREE_CODE (decl) == FUNCTION_DECL && metafunction_p (decl))\n+ return;\n+\n tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);\n if (t == NULL_TREE)\n /* The type that got us on no_linkage_decls must have gotten a name for\n@@ -5807,7 +5895,9 @@ c_parse_final_cleanups (void)\n /* Static data members are just like namespace-scope globals. */\n FOR_EACH_VEC_SAFE_ELT (pending_statics, i, decl)\n \t{\n-\t if (var_finalized_p (decl) || DECL_REALLY_EXTERN (decl)\n+\t if (consteval_only_p (decl)\n+\t || var_finalized_p (decl)\n+\t || DECL_REALLY_EXTERN (decl)\n \t /* Don't write it out if we haven't seen a definition. */\n \t || DECL_IN_AGGR_P (decl))\n \t continue;\n@@ -5849,6 +5939,8 @@ c_parse_final_cleanups (void)\n \t should have synthesized it above.) */\n \t && !(header_module_p ()\n \t && (DECL_DEFAULTED_FN (decl) || decl_tls_wrapper_p (decl)))\n+\t /* Metafunctions are never defined. */\n+\t && !metafunction_p (decl)\n \t /* Don't complain if the template was defined. */\n \t && !((DECL_TEMPLATE_INSTANTIATION (decl)\n \t\t|| DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))\ndiff --git a/gcc/cp/error.cc b/gcc/cp/error.cc\nindex 4e35a4fcbc2..8bb2476ee5f 100644\n--- a/gcc/cp/error.cc\n+++ b/gcc/cp/error.cc\n@@ -749,6 +749,7 @@ dump_type (cxx_pretty_printer *pp, tree t, int flags)\n \n case TEMPLATE_DECL:\n case NAMESPACE_DECL:\n+ case CONST_DECL:\n dump_decl (pp, t, flags & ~TFF_DECL_SPECIFIERS);\n break;\n \n@@ -877,6 +878,14 @@ dump_type (cxx_pretty_printer *pp, tree t, int flags)\n pp_string (pp, \"std::nullptr_t\");\n break;\n \n+ case META_TYPE:\n+ pp_string (pp, \"std::meta::info\");\n+ break;\n+\n+ case SPLICE_SCOPE:\n+ dump_expr (pp, SPLICE_SCOPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);\n+ break;\n+\n default:\n pp_unsupported_tree (pp, t);\n /* Fall through. */\n@@ -1136,6 +1145,8 @@ dump_type_prefix (cxx_pretty_printer *pp, tree t, int flags)\n case FIXED_POINT_TYPE:\n case NULLPTR_TYPE:\n case PACK_INDEX_TYPE:\n+ case META_TYPE:\n+ case SPLICE_SCOPE:\n dump_type (pp, t, flags);\n pp->set_padding (pp_before);\n break;\n@@ -1269,6 +1280,8 @@ dump_type_suffix (cxx_pretty_printer *pp, tree t, int flags)\n case FIXED_POINT_TYPE:\n case NULLPTR_TYPE:\n case PACK_INDEX_TYPE:\n+ case META_TYPE:\n+ case SPLICE_SCOPE:\n break;\n \n default:\n@@ -1615,9 +1628,14 @@ dump_decl (cxx_pretty_printer *pp, tree t, int flags)\n \ttree name = TREE_OPERAND (t, 0);\n \ttree args = TREE_OPERAND (t, 1);\n \n-\tif (!identifier_p (name))\n-\t name = OVL_NAME (name);\n-\tdump_decl (pp, name, flags);\n+\tif (TREE_CODE (name) == SPLICE_EXPR)\n+\t dump_expr (pp, name, flags);\n+\telse\n+\t {\n+\t if (!identifier_p (name))\n+\t name = OVL_NAME (name);\n+\t dump_decl (pp, name, flags);\n+\t }\n \tpp_cxx_begin_template_argument_list (pp);\n \tif (args == error_mark_node)\n \t pp_string (pp, M_(\"