diff options
Diffstat (limited to 'demangle/third_party/llvm')
14 files changed, 0 insertions, 11576 deletions
diff --git a/demangle/third_party/llvm/LICENSE.txt b/demangle/third_party/llvm/LICENSE.txt deleted file mode 100644 index fa6ac540..00000000 --- a/demangle/third_party/llvm/LICENSE.txt +++ /dev/null @@ -1,279 +0,0 @@ -============================================================================== -The LLVM Project is under the Apache License v2.0 with LLVM Exceptions: -============================================================================== - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - - ----- LLVM Exceptions to the Apache 2.0 License ---- - -As an exception, if, as a result of your compiling your source code, portions -of this Software are embedded into an Object form of such source code, you -may redistribute such embedded portions in such Object form without complying -with the conditions of Sections 4(a), 4(b) and 4(d) of the License. - -In addition, if you combine or link compiled forms of this Software with -software that is licensed under the GPLv2 ("Combined Software") and if a -court of competent jurisdiction determines that the patent provision (Section -3), the indemnity provision (Section 9) or other Section of the License -conflicts with the conditions of the GPLv2, you may retroactively and -prospectively choose to deem waived or otherwise exclude such Section(s) of -the License, but only in their entirety and only with respect to the Combined -Software. - -============================================================================== -Software from third parties included in the LLVM Project: -============================================================================== -The LLVM Project contains third party software which is under different license -terms. All such code will be identified clearly using at least one of two -mechanisms: -1) It will be in a separate directory tree with its own `LICENSE.txt` or - `LICENSE` file at the top containing the specific license and restrictions - which apply to that software, or -2) It will contain specific license and restriction terms at the top of every - file. - -============================================================================== -Legacy LLVM License (https://llvm.org/docs/DeveloperPolicy.html#legacy): -============================================================================== -University of Illinois/NCSA -Open Source License - -Copyright (c) 2003-2019 University of Illinois at Urbana-Champaign. -All rights reserved. - -Developed by: - - LLVM Team - - University of Illinois at Urbana-Champaign - - http://llvm.org - -Permission is hereby granted, free of charge, to any person obtaining a copy of -this software and associated documentation files (the "Software"), to deal with -the Software without restriction, including without limitation the rights to -use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies -of the Software, and to permit persons to whom the Software is furnished to do -so, subject to the following conditions: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimers. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimers in the - documentation and/or other materials provided with the distribution. - - * Neither the names of the LLVM Team, University of Illinois at - Urbana-Champaign, nor the names of its contributors may be used to - endorse or promote products derived from this Software without specific - prior written permission. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS -FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE -SOFTWARE. - diff --git a/demangle/third_party/llvm/include/llvm/Demangle/Compiler.h b/demangle/third_party/llvm/include/llvm/Demangle/Compiler.h deleted file mode 100644 index c17ff4ca..00000000 --- a/demangle/third_party/llvm/include/llvm/Demangle/Compiler.h +++ /dev/null @@ -1,549 +0,0 @@ -//===--- Compiler.h ---------------------------------------------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -// -// This file contains a variety of feature test macros copied from -// include/llvm/Support/Compiler.h so that LLVMDemangle does not need to take -// a dependency on LLVMSupport. -//===----------------------------------------------------------------------===// - -#ifndef LLVM_DEMANGLE_COMPILER_H -#define LLVM_DEMANGLE_COMPILER_H - -#ifdef __cplusplus -#include <new> -#endif -#include <stddef.h> - -#if defined(_MSC_VER) -#include <sal.h> -#endif - -#ifndef __has_feature -# define __has_feature(x) 0 -#endif - -#ifndef __has_extension -# define __has_extension(x) 0 -#endif - -#ifndef __has_attribute -# define __has_attribute(x) 0 -#endif - -#ifndef __has_builtin -# define __has_builtin(x) 0 -#endif - -// Only use __has_cpp_attribute in C++ mode. GCC defines __has_cpp_attribute in -// C mode, but the :: in __has_cpp_attribute(scoped::attribute) is invalid. -#ifndef LLVM_HAS_CPP_ATTRIBUTE -#if defined(__cplusplus) && defined(__has_cpp_attribute) -# define LLVM_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) -#else -# define LLVM_HAS_CPP_ATTRIBUTE(x) 0 -#endif -#endif - -/// \macro LLVM_GNUC_PREREQ -/// Extend the default __GNUC_PREREQ even if glibc's features.h isn't -/// available. -#ifndef LLVM_GNUC_PREREQ -# if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) -# define LLVM_GNUC_PREREQ(maj, min, patch) \ - ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >= \ - ((maj) << 20) + ((min) << 10) + (patch)) -# elif defined(__GNUC__) && defined(__GNUC_MINOR__) -# define LLVM_GNUC_PREREQ(maj, min, patch) \ - ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10)) -# else -# define LLVM_GNUC_PREREQ(maj, min, patch) 0 -# endif -#endif - -/// \macro LLVM_MSC_PREREQ -/// Is the compiler MSVC of at least the specified version? -/// The common \param version values to check for are: -/// * 1910: VS2017, version 15.1 & 15.2 -/// * 1911: VS2017, version 15.3 & 15.4 -/// * 1912: VS2017, version 15.5 -/// * 1913: VS2017, version 15.6 -/// * 1914: VS2017, version 15.7 -/// * 1915: VS2017, version 15.8 -/// * 1916: VS2017, version 15.9 -/// * 1920: VS2019, version 16.0 -/// * 1921: VS2019, version 16.1 -#ifdef _MSC_VER -#define LLVM_MSC_PREREQ(version) (_MSC_VER >= (version)) - -// We require at least MSVC 2017. -#if !LLVM_MSC_PREREQ(1910) -#error LLVM requires at least MSVC 2017. -#endif - -#else -#define LLVM_MSC_PREREQ(version) 0 -#endif - -/// Does the compiler support ref-qualifiers for *this? -/// -/// Sadly, this is separate from just rvalue reference support because GCC -/// and MSVC implemented this later than everything else. This appears to be -/// corrected in MSVC 2019 but not MSVC 2017. -#if __has_feature(cxx_rvalue_references) || LLVM_GNUC_PREREQ(4, 8, 1) || \ - LLVM_MSC_PREREQ(1920) -#define LLVM_HAS_RVALUE_REFERENCE_THIS 1 -#else -#define LLVM_HAS_RVALUE_REFERENCE_THIS 0 -#endif - -/// Expands to '&' if ref-qualifiers for *this are supported. -/// -/// This can be used to provide lvalue/rvalue overrides of member functions. -/// The rvalue override should be guarded by LLVM_HAS_RVALUE_REFERENCE_THIS -#if LLVM_HAS_RVALUE_REFERENCE_THIS -#define LLVM_LVALUE_FUNCTION & -#else -#define LLVM_LVALUE_FUNCTION -#endif - -/// LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked -/// into a shared library, then the class should be private to the library and -/// not accessible from outside it. Can also be used to mark variables and -/// functions, making them private to any shared library they are linked into. -/// On PE/COFF targets, library visibility is the default, so this isn't needed. -/// -/// LLVM_EXTERNAL_VISIBILITY - classes, functions, and variables marked with -/// this attribute will be made public and visible outside of any shared library -/// they are linked in to. -#if (__has_attribute(visibility) || LLVM_GNUC_PREREQ(4, 0, 0)) && \ - !defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(_WIN32) -#define LLVM_LIBRARY_VISIBILITY __attribute__ ((visibility("hidden"))) -#define LLVM_EXTERNAL_VISIBILITY __attribute__ ((visibility("default"))) -#else -#define LLVM_LIBRARY_VISIBILITY -#define LLVM_EXTERNAL_VISIBILITY -#endif - -#if defined(__GNUC__) -#define LLVM_PREFETCH(addr, rw, locality) __builtin_prefetch(addr, rw, locality) -#else -#define LLVM_PREFETCH(addr, rw, locality) -#endif - -#if __has_attribute(used) || LLVM_GNUC_PREREQ(3, 1, 0) -#define LLVM_ATTRIBUTE_USED __attribute__((__used__)) -#else -#define LLVM_ATTRIBUTE_USED -#endif - -/// LLVM_NODISCARD - Warn if a type or return value is discarded. - -// Use the 'nodiscard' attribute in C++17 or newer mode. -#if defined(__cplusplus) && __cplusplus > 201402L && LLVM_HAS_CPP_ATTRIBUTE(nodiscard) -#define LLVM_NODISCARD [[nodiscard]] -#elif LLVM_HAS_CPP_ATTRIBUTE(clang::warn_unused_result) -#define LLVM_NODISCARD [[clang::warn_unused_result]] -// Clang in C++14 mode claims that it has the 'nodiscard' attribute, but also -// warns in the pedantic mode that 'nodiscard' is a C++17 extension (PR33518). -// Use the 'nodiscard' attribute in C++14 mode only with GCC. -// TODO: remove this workaround when PR33518 is resolved. -#elif defined(__GNUC__) && LLVM_HAS_CPP_ATTRIBUTE(nodiscard) -#define LLVM_NODISCARD [[nodiscard]] -#else -#define LLVM_NODISCARD -#endif - -// Indicate that a non-static, non-const C++ member function reinitializes -// the entire object to a known state, independent of the previous state of -// the object. -// -// The clang-tidy check bugprone-use-after-move recognizes this attribute as a -// marker that a moved-from object has left the indeterminate state and can be -// reused. -#if LLVM_HAS_CPP_ATTRIBUTE(clang::reinitializes) -#define LLVM_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]] -#else -#define LLVM_ATTRIBUTE_REINITIALIZES -#endif - -// Some compilers warn about unused functions. When a function is sometimes -// used or not depending on build settings (e.g. a function only called from -// within "assert"), this attribute can be used to suppress such warnings. -// -// However, it shouldn't be used for unused *variables*, as those have a much -// more portable solution: -// (void)unused_var_name; -// Prefer cast-to-void wherever it is sufficient. -#if __has_attribute(unused) || LLVM_GNUC_PREREQ(3, 1, 0) -#define LLVM_ATTRIBUTE_UNUSED __attribute__((__unused__)) -#else -#define LLVM_ATTRIBUTE_UNUSED -#endif - -// FIXME: Provide this for PE/COFF targets. -#if (__has_attribute(weak) || LLVM_GNUC_PREREQ(4, 0, 0)) && \ - (!defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(_WIN32)) -#define LLVM_ATTRIBUTE_WEAK __attribute__((__weak__)) -#else -#define LLVM_ATTRIBUTE_WEAK -#endif - -// Prior to clang 3.2, clang did not accept any spelling of -// __has_attribute(const), so assume it is supported. -#if defined(__clang__) || defined(__GNUC__) -// aka 'CONST' but following LLVM Conventions. -#define LLVM_READNONE __attribute__((__const__)) -#else -#define LLVM_READNONE -#endif - -#if __has_attribute(pure) || defined(__GNUC__) -// aka 'PURE' but following LLVM Conventions. -#define LLVM_READONLY __attribute__((__pure__)) -#else -#define LLVM_READONLY -#endif - -#if __has_builtin(__builtin_expect) || LLVM_GNUC_PREREQ(4, 0, 0) -#define LLVM_LIKELY(EXPR) __builtin_expect((bool)(EXPR), true) -#define LLVM_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false) -#else -#define LLVM_LIKELY(EXPR) (EXPR) -#define LLVM_UNLIKELY(EXPR) (EXPR) -#endif - -/// LLVM_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so, -/// mark a method "not for inlining". -#if __has_attribute(noinline) || LLVM_GNUC_PREREQ(3, 4, 0) -#define LLVM_ATTRIBUTE_NOINLINE __attribute__((noinline)) -#elif defined(_MSC_VER) -#define LLVM_ATTRIBUTE_NOINLINE __declspec(noinline) -#else -#define LLVM_ATTRIBUTE_NOINLINE -#endif - -/// LLVM_ATTRIBUTE_ALWAYS_INLINE - On compilers where we have a directive to do -/// so, mark a method "always inline" because it is performance sensitive. GCC -/// 3.4 supported this but is buggy in various cases and produces unimplemented -/// errors, just use it in GCC 4.0 and later. -#if __has_attribute(always_inline) || LLVM_GNUC_PREREQ(4, 0, 0) -#define LLVM_ATTRIBUTE_ALWAYS_INLINE inline __attribute__((always_inline)) -#elif defined(_MSC_VER) -#define LLVM_ATTRIBUTE_ALWAYS_INLINE __forceinline -#else -#define LLVM_ATTRIBUTE_ALWAYS_INLINE inline -#endif - -#ifdef __GNUC__ -#define LLVM_ATTRIBUTE_NORETURN __attribute__((noreturn)) -#elif defined(_MSC_VER) -#define LLVM_ATTRIBUTE_NORETURN __declspec(noreturn) -#else -#define LLVM_ATTRIBUTE_NORETURN -#endif - -#if __has_attribute(returns_nonnull) || LLVM_GNUC_PREREQ(4, 9, 0) -#define LLVM_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull)) -#elif defined(_MSC_VER) -#define LLVM_ATTRIBUTE_RETURNS_NONNULL _Ret_notnull_ -#else -#define LLVM_ATTRIBUTE_RETURNS_NONNULL -#endif - -/// \macro LLVM_ATTRIBUTE_RETURNS_NOALIAS Used to mark a function as returning a -/// pointer that does not alias any other valid pointer. -#ifdef __GNUC__ -#define LLVM_ATTRIBUTE_RETURNS_NOALIAS __attribute__((__malloc__)) -#elif defined(_MSC_VER) -#define LLVM_ATTRIBUTE_RETURNS_NOALIAS __declspec(restrict) -#else -#define LLVM_ATTRIBUTE_RETURNS_NOALIAS -#endif - -/// LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements. -#if defined(__cplusplus) && __cplusplus > 201402L && LLVM_HAS_CPP_ATTRIBUTE(fallthrough) -#define LLVM_FALLTHROUGH [[fallthrough]] -#elif LLVM_HAS_CPP_ATTRIBUTE(gnu::fallthrough) -#define LLVM_FALLTHROUGH [[gnu::fallthrough]] -#elif __has_attribute(fallthrough) -#define LLVM_FALLTHROUGH __attribute__((fallthrough)) -#elif LLVM_HAS_CPP_ATTRIBUTE(clang::fallthrough) -#define LLVM_FALLTHROUGH [[clang::fallthrough]] -#else -#define LLVM_FALLTHROUGH -#endif - -/// LLVM_REQUIRE_CONSTANT_INITIALIZATION - Apply this to globals to ensure that -/// they are constant initialized. -#if LLVM_HAS_CPP_ATTRIBUTE(clang::require_constant_initialization) -#define LLVM_REQUIRE_CONSTANT_INITIALIZATION \ - [[clang::require_constant_initialization]] -#else -#define LLVM_REQUIRE_CONSTANT_INITIALIZATION -#endif - -/// LLVM_GSL_OWNER - Apply this to owning classes like SmallVector to enable -/// lifetime warnings. -#if LLVM_HAS_CPP_ATTRIBUTE(gsl::Owner) -#define LLVM_GSL_OWNER [[gsl::Owner]] -#else -#define LLVM_GSL_OWNER -#endif - -/// LLVM_GSL_POINTER - Apply this to non-owning classes like -/// StringRef to enable lifetime warnings. -#if LLVM_HAS_CPP_ATTRIBUTE(gsl::Pointer) -#define LLVM_GSL_POINTER [[gsl::Pointer]] -#else -#define LLVM_GSL_POINTER -#endif - -/// LLVM_EXTENSION - Support compilers where we have a keyword to suppress -/// pedantic diagnostics. -#ifdef __GNUC__ -#define LLVM_EXTENSION __extension__ -#else -#define LLVM_EXTENSION -#endif - -// LLVM_ATTRIBUTE_DEPRECATED(decl, "message") -// This macro will be removed. -// Use C++14's attribute instead: [[deprecated("message")]] -#define LLVM_ATTRIBUTE_DEPRECATED(decl, message) [[deprecated(message)]] decl - -/// LLVM_BUILTIN_UNREACHABLE - On compilers which support it, expands -/// to an expression which states that it is undefined behavior for the -/// compiler to reach this point. Otherwise is not defined. -#if __has_builtin(__builtin_unreachable) || LLVM_GNUC_PREREQ(4, 5, 0) -# define LLVM_BUILTIN_UNREACHABLE __builtin_unreachable() -#elif defined(_MSC_VER) -# define LLVM_BUILTIN_UNREACHABLE __assume(false) -#endif - -/// LLVM_BUILTIN_TRAP - On compilers which support it, expands to an expression -/// which causes the program to exit abnormally. -#if __has_builtin(__builtin_trap) || LLVM_GNUC_PREREQ(4, 3, 0) -# define LLVM_BUILTIN_TRAP __builtin_trap() -#elif defined(_MSC_VER) -// The __debugbreak intrinsic is supported by MSVC, does not require forward -// declarations involving platform-specific typedefs (unlike RaiseException), -// results in a call to vectored exception handlers, and encodes to a short -// instruction that still causes the trapping behavior we want. -# define LLVM_BUILTIN_TRAP __debugbreak() -#else -# define LLVM_BUILTIN_TRAP *(volatile int*)0x11 = 0 -#endif - -/// LLVM_BUILTIN_DEBUGTRAP - On compilers which support it, expands to -/// an expression which causes the program to break while running -/// under a debugger. -#if __has_builtin(__builtin_debugtrap) -# define LLVM_BUILTIN_DEBUGTRAP __builtin_debugtrap() -#elif defined(_MSC_VER) -// The __debugbreak intrinsic is supported by MSVC and breaks while -// running under the debugger, and also supports invoking a debugger -// when the OS is configured appropriately. -# define LLVM_BUILTIN_DEBUGTRAP __debugbreak() -#else -// Just continue execution when built with compilers that have no -// support. This is a debugging aid and not intended to force the -// program to abort if encountered. -# define LLVM_BUILTIN_DEBUGTRAP -#endif - -/// \macro LLVM_ASSUME_ALIGNED -/// Returns a pointer with an assumed alignment. -#if __has_builtin(__builtin_assume_aligned) || LLVM_GNUC_PREREQ(4, 7, 0) -# define LLVM_ASSUME_ALIGNED(p, a) __builtin_assume_aligned(p, a) -#elif defined(LLVM_BUILTIN_UNREACHABLE) -# define LLVM_ASSUME_ALIGNED(p, a) \ - (((uintptr_t(p) % (a)) == 0) ? (p) : (LLVM_BUILTIN_UNREACHABLE, (p))) -#else -# define LLVM_ASSUME_ALIGNED(p, a) (p) -#endif - -/// \macro LLVM_PACKED -/// Used to specify a packed structure. -/// LLVM_PACKED( -/// struct A { -/// int i; -/// int j; -/// int k; -/// long long l; -/// }); -/// -/// LLVM_PACKED_START -/// struct B { -/// int i; -/// int j; -/// int k; -/// long long l; -/// }; -/// LLVM_PACKED_END -#ifdef _MSC_VER -# define LLVM_PACKED(d) __pragma(pack(push, 1)) d __pragma(pack(pop)) -# define LLVM_PACKED_START __pragma(pack(push, 1)) -# define LLVM_PACKED_END __pragma(pack(pop)) -#else -# define LLVM_PACKED(d) d __attribute__((packed)) -# define LLVM_PACKED_START _Pragma("pack(push, 1)") -# define LLVM_PACKED_END _Pragma("pack(pop)") -#endif - -/// \macro LLVM_PTR_SIZE -/// A constant integer equivalent to the value of sizeof(void*). -/// Generally used in combination with alignas or when doing computation in the -/// preprocessor. -#ifdef __SIZEOF_POINTER__ -# define LLVM_PTR_SIZE __SIZEOF_POINTER__ -#elif defined(_WIN64) -# define LLVM_PTR_SIZE 8 -#elif defined(_WIN32) -# define LLVM_PTR_SIZE 4 -#elif defined(_MSC_VER) -# error "could not determine LLVM_PTR_SIZE as a constant int for MSVC" -#else -# define LLVM_PTR_SIZE sizeof(void *) -#endif - -/// \macro LLVM_MEMORY_SANITIZER_BUILD -/// Whether LLVM itself is built with MemorySanitizer instrumentation. -#if __has_feature(memory_sanitizer) -# define LLVM_MEMORY_SANITIZER_BUILD 1 -# include <sanitizer/msan_interface.h> -# define LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE __attribute__((no_sanitize_memory)) -#else -# define LLVM_MEMORY_SANITIZER_BUILD 0 -# define __msan_allocated_memory(p, size) -# define __msan_unpoison(p, size) -# define LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE -#endif - -/// \macro LLVM_ADDRESS_SANITIZER_BUILD -/// Whether LLVM itself is built with AddressSanitizer instrumentation. -#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__) -# define LLVM_ADDRESS_SANITIZER_BUILD 1 -# include <sanitizer/asan_interface.h> -#else -# define LLVM_ADDRESS_SANITIZER_BUILD 0 -# define __asan_poison_memory_region(p, size) -# define __asan_unpoison_memory_region(p, size) -#endif - -/// \macro LLVM_THREAD_SANITIZER_BUILD -/// Whether LLVM itself is built with ThreadSanitizer instrumentation. -#if __has_feature(thread_sanitizer) || defined(__SANITIZE_THREAD__) -# define LLVM_THREAD_SANITIZER_BUILD 1 -#else -# define LLVM_THREAD_SANITIZER_BUILD 0 -#endif - -#if LLVM_THREAD_SANITIZER_BUILD -// Thread Sanitizer is a tool that finds races in code. -// See http://code.google.com/p/data-race-test/wiki/DynamicAnnotations . -// tsan detects these exact functions by name. -#ifdef __cplusplus -extern "C" { -#endif -void AnnotateHappensAfter(const char *file, int line, const volatile void *cv); -void AnnotateHappensBefore(const char *file, int line, const volatile void *cv); -void AnnotateIgnoreWritesBegin(const char *file, int line); -void AnnotateIgnoreWritesEnd(const char *file, int line); -#ifdef __cplusplus -} -#endif - -// This marker is used to define a happens-before arc. The race detector will -// infer an arc from the begin to the end when they share the same pointer -// argument. -# define TsanHappensBefore(cv) AnnotateHappensBefore(__FILE__, __LINE__, cv) - -// This marker defines the destination of a happens-before arc. -# define TsanHappensAfter(cv) AnnotateHappensAfter(__FILE__, __LINE__, cv) - -// Ignore any races on writes between here and the next TsanIgnoreWritesEnd. -# define TsanIgnoreWritesBegin() AnnotateIgnoreWritesBegin(__FILE__, __LINE__) - -// Resume checking for racy writes. -# define TsanIgnoreWritesEnd() AnnotateIgnoreWritesEnd(__FILE__, __LINE__) -#else -# define TsanHappensBefore(cv) -# define TsanHappensAfter(cv) -# define TsanIgnoreWritesBegin() -# define TsanIgnoreWritesEnd() -#endif - -/// \macro LLVM_NO_SANITIZE -/// Disable a particular sanitizer for a function. -#if __has_attribute(no_sanitize) -#define LLVM_NO_SANITIZE(KIND) __attribute__((no_sanitize(KIND))) -#else -#define LLVM_NO_SANITIZE(KIND) -#endif - -/// Mark debug helper function definitions like dump() that should not be -/// stripped from debug builds. -/// Note that you should also surround dump() functions with -/// `#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)` so they do always -/// get stripped in release builds. -// FIXME: Move this to a private config.h as it's not usable in public headers. -#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) -#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED -#else -#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE -#endif - -/// \macro LLVM_PRETTY_FUNCTION -/// Gets a user-friendly looking function signature for the current scope -/// using the best available method on each platform. The exact format of the -/// resulting string is implementation specific and non-portable, so this should -/// only be used, for example, for logging or diagnostics. -#if defined(_MSC_VER) -#define LLVM_PRETTY_FUNCTION __FUNCSIG__ -#elif defined(__GNUC__) || defined(__clang__) -#define LLVM_PRETTY_FUNCTION __PRETTY_FUNCTION__ -#else -#define LLVM_PRETTY_FUNCTION __func__ -#endif - -/// \macro LLVM_THREAD_LOCAL -/// A thread-local storage specifier which can be used with globals, -/// extern globals, and static globals. -/// -/// This is essentially an extremely restricted analog to C++11's thread_local -/// support. It uses thread_local if available, falling back on gcc __thread -/// if not. __thread doesn't support many of the C++11 thread_local's -/// features. You should only use this for PODs that you can statically -/// initialize to some constant value. In almost all circumstances this is most -/// appropriate for use with a pointer, integer, or small aggregation of -/// pointers and integers. -#if LLVM_ENABLE_THREADS -#if __has_feature(cxx_thread_local) || defined(_MSC_VER) -#define LLVM_THREAD_LOCAL thread_local -#else -// Clang, GCC, and other compatible compilers used __thread prior to C++11 and -// we only need the restricted functionality that provides. -#define LLVM_THREAD_LOCAL __thread -#endif -#else // !LLVM_ENABLE_THREADS -// If threading is disabled entirely, this compiles to nothing and you get -// a normal global variable. -#define LLVM_THREAD_LOCAL -#endif - -/// \macro LLVM_ENABLE_EXCEPTIONS -/// Whether LLVM is built with exception support. -#if __has_feature(cxx_exceptions) -#define LLVM_ENABLE_EXCEPTIONS 1 -#elif defined(__GNUC__) && defined(__EXCEPTIONS) -#define LLVM_ENABLE_EXCEPTIONS 1 -#elif defined(_MSC_VER) && defined(_CPPUNWIND) -#define LLVM_ENABLE_EXCEPTIONS 1 -#endif - -#endif diff --git a/demangle/third_party/llvm/include/llvm/Demangle/Demangle.h b/demangle/third_party/llvm/include/llvm/Demangle/Demangle.h deleted file mode 100644 index 6133d0b9..00000000 --- a/demangle/third_party/llvm/include/llvm/Demangle/Demangle.h +++ /dev/null @@ -1,133 +0,0 @@ -//===--- Demangle.h ---------------------------------------------*- C++ -*-===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_DEMANGLE_DEMANGLE_H -#define LLVM_DEMANGLE_DEMANGLE_H - -#include <cstddef> -#include <string> - -namespace llvm { -/// This is a llvm local version of __cxa_demangle. Other than the name and -/// being in the llvm namespace it is identical. -/// -/// The mangled_name is demangled into buf and returned. If the buffer is not -/// large enough, realloc is used to expand it. -/// -/// The *status will be set to a value from the following enumeration -enum : int { - demangle_unknown_error = -4, - demangle_invalid_args = -3, - demangle_invalid_mangled_name = -2, - demangle_memory_alloc_failure = -1, - demangle_success = 0, -}; - -char *itaniumDemangle(const char *mangled_name, char *buf, size_t *n, - int *status); - -enum MSDemangleFlags { - MSDF_None = 0, - MSDF_DumpBackrefs = 1 << 0, - MSDF_NoAccessSpecifier = 1 << 1, - MSDF_NoCallingConvention = 1 << 2, - MSDF_NoReturnType = 1 << 3, - MSDF_NoMemberType = 1 << 4, - MSDF_NoVariableType = 1 << 5, -}; - -/// Demangles the Microsoft symbol pointed at by mangled_name and returns it. -/// Returns a pointer to the start of a null-terminated demangled string on -/// success, or nullptr on error. -/// If n_read is non-null and demangling was successful, it receives how many -/// bytes of the input string were consumed. -/// buf can point to a *n_buf bytes large buffer where the demangled name is -/// stored. If the buffer is too small, it is grown with realloc(). If buf is -/// nullptr, then this malloc()s memory for the result. -/// *n_buf stores the size of buf on input if buf is non-nullptr, and it -/// receives the size of the demangled string on output if n_buf is not nullptr. -/// status receives one of the demangle_ enum entries above if it's not nullptr. -/// Flags controls various details of the demangled representation. -char *microsoftDemangle(const char *mangled_name, size_t *n_read, char *buf, - size_t *n_buf, int *status, - MSDemangleFlags Flags = MSDF_None); - -// Demangles a Rust v0 mangled symbol. -char *rustDemangle(const char *MangledName); - -// Demangles a D mangled symbol. -char *dlangDemangle(const char *MangledName); - -/// Attempt to demangle a string using different demangling schemes. -/// The function uses heuristics to determine which demangling scheme to use. -/// \param MangledName - reference to string to demangle. -/// \returns - the demangled string, or a copy of the input string if no -/// demangling occurred. -std::string demangle(const std::string &MangledName); - -bool nonMicrosoftDemangle(const char *MangledName, std::string &Result); - -/// "Partial" demangler. This supports demangling a string into an AST -/// (typically an intermediate stage in itaniumDemangle) and querying certain -/// properties or partially printing the demangled name. -struct ItaniumPartialDemangler { - ItaniumPartialDemangler(); - - ItaniumPartialDemangler(ItaniumPartialDemangler &&Other); - ItaniumPartialDemangler &operator=(ItaniumPartialDemangler &&Other); - - /// Demangle into an AST. Subsequent calls to the rest of the member functions - /// implicitly operate on the AST this produces. - /// \return true on error, false otherwise - bool partialDemangle(const char *MangledName); - - /// Just print the entire mangled name into Buf. Buf and N behave like the - /// second and third parameters to itaniumDemangle. - char *finishDemangle(char *Buf, size_t *N) const; - - /// Get the base name of a function. This doesn't include trailing template - /// arguments, ie for "a::b<int>" this function returns "b". - char *getFunctionBaseName(char *Buf, size_t *N) const; - - /// Get the context name for a function. For "a::b::c", this function returns - /// "a::b". - char *getFunctionDeclContextName(char *Buf, size_t *N) const; - - /// Get the entire name of this function. - char *getFunctionName(char *Buf, size_t *N) const; - - /// Get the parameters for this function. - char *getFunctionParameters(char *Buf, size_t *N) const; - char *getFunctionReturnType(char *Buf, size_t *N) const; - - /// If this function has any any cv or reference qualifiers. These imply that - /// the function is a non-static member function. - bool hasFunctionQualifiers() const; - - /// If this symbol describes a constructor or destructor. - bool isCtorOrDtor() const; - - /// If this symbol describes a function. - bool isFunction() const; - - /// If this symbol describes a variable. - bool isData() const; - - /// If this symbol is a <special-name>. These are generally implicitly - /// generated by the implementation, such as vtables and typeinfo names. - bool isSpecialName() const; - - ~ItaniumPartialDemangler(); - -private: - void *RootNode; - void *Context; -}; -} // namespace llvm - -#endif diff --git a/demangle/third_party/llvm/include/llvm/Demangle/DemangleConfig.h b/demangle/third_party/llvm/include/llvm/Demangle/DemangleConfig.h deleted file mode 100644 index 2ff95dd8..00000000 --- a/demangle/third_party/llvm/include/llvm/Demangle/DemangleConfig.h +++ /dev/null @@ -1,92 +0,0 @@ -//===--- DemangleConfig.h ---------------------------------------*- C++ -*-===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file contains a variety of feature test macros copied from -// include/llvm/Support/Compiler.h so that LLVMDemangle does not need to take -// a dependency on LLVMSupport. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_DEMANGLE_DEMANGLECONFIG_H -#define LLVM_DEMANGLE_DEMANGLECONFIG_H - -#ifndef __has_feature -#define __has_feature(x) 0 -#endif - -#ifndef __has_cpp_attribute -#define __has_cpp_attribute(x) 0 -#endif - -#ifndef __has_attribute -#define __has_attribute(x) 0 -#endif - -#ifndef __has_builtin -#define __has_builtin(x) 0 -#endif - -#ifndef DEMANGLE_GNUC_PREREQ -#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) -#define DEMANGLE_GNUC_PREREQ(maj, min, patch) \ - ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >= \ - ((maj) << 20) + ((min) << 10) + (patch)) -#elif defined(__GNUC__) && defined(__GNUC_MINOR__) -#define DEMANGLE_GNUC_PREREQ(maj, min, patch) \ - ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10)) -#else -#define DEMANGLE_GNUC_PREREQ(maj, min, patch) 0 -#endif -#endif - -#if __has_attribute(used) || DEMANGLE_GNUC_PREREQ(3, 1, 0) -#define DEMANGLE_ATTRIBUTE_USED __attribute__((__used__)) -#else -#define DEMANGLE_ATTRIBUTE_USED -#endif - -#if __has_builtin(__builtin_unreachable) || DEMANGLE_GNUC_PREREQ(4, 5, 0) -#define DEMANGLE_UNREACHABLE __builtin_unreachable() -#elif defined(_MSC_VER) -#define DEMANGLE_UNREACHABLE __assume(false) -#else -#define DEMANGLE_UNREACHABLE -#endif - -#if __has_attribute(noinline) || DEMANGLE_GNUC_PREREQ(3, 4, 0) -#define DEMANGLE_ATTRIBUTE_NOINLINE __attribute__((noinline)) -#elif defined(_MSC_VER) -#define DEMANGLE_ATTRIBUTE_NOINLINE __declspec(noinline) -#else -#define DEMANGLE_ATTRIBUTE_NOINLINE -#endif - -#if !defined(NDEBUG) -#define DEMANGLE_DUMP_METHOD DEMANGLE_ATTRIBUTE_NOINLINE DEMANGLE_ATTRIBUTE_USED -#else -#define DEMANGLE_DUMP_METHOD DEMANGLE_ATTRIBUTE_NOINLINE -#endif - -#if __cplusplus > 201402L && __has_cpp_attribute(fallthrough) -#define DEMANGLE_FALLTHROUGH [[fallthrough]] -#elif __has_cpp_attribute(gnu::fallthrough) -#define DEMANGLE_FALLTHROUGH [[gnu::fallthrough]] -#elif !__cplusplus -// Workaround for llvm.org/PR23435, since clang 3.6 and below emit a spurious -// error when __has_cpp_attribute is given a scoped attribute in C mode. -#define DEMANGLE_FALLTHROUGH -#elif __has_cpp_attribute(clang::fallthrough) -#define DEMANGLE_FALLTHROUGH [[clang::fallthrough]] -#else -#define DEMANGLE_FALLTHROUGH -#endif - -#define DEMANGLE_NAMESPACE_BEGIN namespace llvm { namespace itanium_demangle { -#define DEMANGLE_NAMESPACE_END } } - -#endif diff --git a/demangle/third_party/llvm/include/llvm/Demangle/ItaniumDemangle.h b/demangle/third_party/llvm/include/llvm/Demangle/ItaniumDemangle.h deleted file mode 100644 index ea55f4a6..00000000 --- a/demangle/third_party/llvm/include/llvm/Demangle/ItaniumDemangle.h +++ /dev/null @@ -1,5500 +0,0 @@ -//===--- ItaniumDemangle.h -----------*- mode:c++;eval:(read-only-mode) -*-===// -// Do not edit! See README.txt. -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// Generic itanium demangler library. -// There are two copies of this file in the source tree. The one under -// libcxxabi is the original and the one under llvm is the copy. Use -// cp-to-llvm.sh to update the copy. See README.txt for more details. -// -//===----------------------------------------------------------------------===// - -#ifndef DEMANGLE_ITANIUMDEMANGLE_H -#define DEMANGLE_ITANIUMDEMANGLE_H - -#include "DemangleConfig.h" -#include "StringView.h" -#include "Utility.h" -#include <algorithm> -#include <cassert> -#include <cctype> -#include <cstdio> -#include <cstdlib> -#include <cstring> -#include <limits> -#include <new> -#include <utility> - -DEMANGLE_NAMESPACE_BEGIN - -template <class T, size_t N> class PODSmallVector { - static_assert(std::is_pod<T>::value, - "T is required to be a plain old data type"); - - T *First = nullptr; - T *Last = nullptr; - T *Cap = nullptr; - T Inline[N] = {0}; - - bool isInline() const { return First == Inline; } - - void clearInline() { - First = Inline; - Last = Inline; - Cap = Inline + N; - } - - void reserve(size_t NewCap) { - size_t S = size(); - if (isInline()) { - auto *Tmp = static_cast<T *>(std::malloc(NewCap * sizeof(T))); - if (Tmp == nullptr) - std::terminate(); - std::copy(First, Last, Tmp); - First = Tmp; - } else { - First = static_cast<T *>(std::realloc(First, NewCap * sizeof(T))); - if (First == nullptr) - std::terminate(); - } - Last = First + S; - Cap = First + NewCap; - } - -public: - PODSmallVector() : First(Inline), Last(First), Cap(Inline + N) {} - - PODSmallVector(const PODSmallVector &) = delete; - PODSmallVector &operator=(const PODSmallVector &) = delete; - - PODSmallVector(PODSmallVector &&Other) : PODSmallVector() { - if (Other.isInline()) { - std::copy(Other.begin(), Other.end(), First); - Last = First + Other.size(); - Other.clear(); - return; - } - - First = Other.First; - Last = Other.Last; - Cap = Other.Cap; - Other.clearInline(); - } - - PODSmallVector &operator=(PODSmallVector &&Other) { - if (Other.isInline()) { - if (!isInline()) { - std::free(First); - clearInline(); - } - std::copy(Other.begin(), Other.end(), First); - Last = First + Other.size(); - Other.clear(); - return *this; - } - - if (isInline()) { - First = Other.First; - Last = Other.Last; - Cap = Other.Cap; - Other.clearInline(); - return *this; - } - - std::swap(First, Other.First); - std::swap(Last, Other.Last); - std::swap(Cap, Other.Cap); - Other.clear(); - return *this; - } - - // NOLINTNEXTLINE(readability-identifier-naming) - void push_back(const T &Elem) { - if (Last == Cap) - reserve(size() * 2); - *Last++ = Elem; - } - - // NOLINTNEXTLINE(readability-identifier-naming) - void pop_back() { - assert(Last != First && "Popping empty vector!"); - --Last; - } - - void dropBack(size_t Index) { - assert(Index <= size() && "dropBack() can't expand!"); - Last = First + Index; - } - - T *begin() { return First; } - T *end() { return Last; } - - bool empty() const { return First == Last; } - size_t size() const { return static_cast<size_t>(Last - First); } - T &back() { - assert(Last != First && "Calling back() on empty vector!"); - return *(Last - 1); - } - T &operator[](size_t Index) { - assert(Index < size() && "Invalid access!"); - return *(begin() + Index); - } - void clear() { Last = First; } - - ~PODSmallVector() { - if (!isInline()) - std::free(First); - } -}; - -// Base class of all AST nodes. The AST is built by the parser, then is -// traversed by the printLeft/Right functions to produce a demangled string. -class Node { -public: - enum Kind : unsigned char { -#define NODE(NodeKind) K##NodeKind, -#include "ItaniumNodes.def" - }; - - /// Three-way bool to track a cached value. Unknown is possible if this node - /// has an unexpanded parameter pack below it that may affect this cache. - enum class Cache : unsigned char { Yes, No, Unknown, }; - - /// Operator precedence for expression nodes. Used to determine required - /// parens in expression emission. - enum class Prec { - Primary, - Postfix, - Unary, - Cast, - PtrMem, - Multiplicative, - Additive, - Shift, - Spaceship, - Relational, - Equality, - And, - Xor, - Ior, - AndIf, - OrIf, - Conditional, - Assign, - Comma, - Default, - }; - -private: - Kind K; - - Prec Precedence : 6; - - // FIXME: Make these protected. -public: - /// Tracks if this node has a component on its right side, in which case we - /// need to call printRight. - Cache RHSComponentCache : 2; - - /// Track if this node is a (possibly qualified) array type. This can affect - /// how we format the output string. - Cache ArrayCache : 2; - - /// Track if this node is a (possibly qualified) function type. This can - /// affect how we format the output string. - Cache FunctionCache : 2; - -public: - Node(Kind K_, Prec Precedence_ = Prec::Primary, - Cache RHSComponentCache_ = Cache::No, Cache ArrayCache_ = Cache::No, - Cache FunctionCache_ = Cache::No) - : K(K_), Precedence(Precedence_), RHSComponentCache(RHSComponentCache_), - ArrayCache(ArrayCache_), FunctionCache(FunctionCache_) {} - Node(Kind K_, Cache RHSComponentCache_, Cache ArrayCache_ = Cache::No, - Cache FunctionCache_ = Cache::No) - : Node(K_, Prec::Primary, RHSComponentCache_, ArrayCache_, - FunctionCache_) {} - - /// Visit the most-derived object corresponding to this object. - template<typename Fn> void visit(Fn F) const; - - // The following function is provided by all derived classes: - // - // Call F with arguments that, when passed to the constructor of this node, - // would construct an equivalent node. - //template<typename Fn> void match(Fn F) const; - - bool hasRHSComponent(OutputBuffer &OB) const { - if (RHSComponentCache != Cache::Unknown) - return RHSComponentCache == Cache::Yes; - return hasRHSComponentSlow(OB); - } - - bool hasArray(OutputBuffer &OB) const { - if (ArrayCache != Cache::Unknown) - return ArrayCache == Cache::Yes; - return hasArraySlow(OB); - } - - bool hasFunction(OutputBuffer &OB) const { - if (FunctionCache != Cache::Unknown) - return FunctionCache == Cache::Yes; - return hasFunctionSlow(OB); - } - - Kind getKind() const { return K; } - - Prec getPrecedence() const { return Precedence; } - - virtual bool hasRHSComponentSlow(OutputBuffer &) const { return false; } - virtual bool hasArraySlow(OutputBuffer &) const { return false; } - virtual bool hasFunctionSlow(OutputBuffer &) const { return false; } - - // Dig through "glue" nodes like ParameterPack and ForwardTemplateReference to - // get at a node that actually represents some concrete syntax. - virtual const Node *getSyntaxNode(OutputBuffer &) const { return this; } - - // Print this node as an expression operand, surrounding it in parentheses if - // its precedence is [Strictly] weaker than P. - void printAsOperand(OutputBuffer &OB, Prec P = Prec::Default, - bool StrictlyWorse = false) const { - bool Paren = - unsigned(getPrecedence()) >= unsigned(P) + unsigned(StrictlyWorse); - if (Paren) - OB.printOpen(); - print(OB); - if (Paren) - OB.printClose(); - } - - void print(OutputBuffer &OB) const { - printLeft(OB); - if (RHSComponentCache != Cache::No) - printRight(OB); - } - - // Print the "left" side of this Node into OutputBuffer. - virtual void printLeft(OutputBuffer &) const = 0; - - // Print the "right". This distinction is necessary to represent C++ types - // that appear on the RHS of their subtype, such as arrays or functions. - // Since most types don't have such a component, provide a default - // implementation. - virtual void printRight(OutputBuffer &) const {} - - virtual StringView getBaseName() const { return StringView(); } - - // Silence compiler warnings, this dtor will never be called. - virtual ~Node() = default; - -#ifndef NDEBUG - DEMANGLE_DUMP_METHOD void dump() const; -#endif -}; - -class NodeArray { - Node **Elements; - size_t NumElements; - -public: - NodeArray() : Elements(nullptr), NumElements(0) {} - NodeArray(Node **Elements_, size_t NumElements_) - : Elements(Elements_), NumElements(NumElements_) {} - - bool empty() const { return NumElements == 0; } - size_t size() const { return NumElements; } - - Node **begin() const { return Elements; } - Node **end() const { return Elements + NumElements; } - - Node *operator[](size_t Idx) const { return Elements[Idx]; } - - void printWithComma(OutputBuffer &OB) const { - bool FirstElement = true; - for (size_t Idx = 0; Idx != NumElements; ++Idx) { - size_t BeforeComma = OB.getCurrentPosition(); - if (!FirstElement) - OB += ", "; - size_t AfterComma = OB.getCurrentPosition(); - Elements[Idx]->printAsOperand(OB, Node::Prec::Comma); - - // Elements[Idx] is an empty parameter pack expansion, we should erase the - // comma we just printed. - if (AfterComma == OB.getCurrentPosition()) { - OB.setCurrentPosition(BeforeComma); - continue; - } - - FirstElement = false; - } - } -}; - -struct NodeArrayNode : Node { - NodeArray Array; - NodeArrayNode(NodeArray Array_) : Node(KNodeArrayNode), Array(Array_) {} - - template<typename Fn> void match(Fn F) const { F(Array); } - - void printLeft(OutputBuffer &OB) const override { Array.printWithComma(OB); } -}; - -class DotSuffix final : public Node { - const Node *Prefix; - const StringView Suffix; - -public: - DotSuffix(const Node *Prefix_, StringView Suffix_) - : Node(KDotSuffix), Prefix(Prefix_), Suffix(Suffix_) {} - - template<typename Fn> void match(Fn F) const { F(Prefix, Suffix); } - - void printLeft(OutputBuffer &OB) const override { - Prefix->print(OB); - OB += " ("; - OB += Suffix; - OB += ")"; - } -}; - -class VendorExtQualType final : public Node { - const Node *Ty; - StringView Ext; - const Node *TA; - -public: - VendorExtQualType(const Node *Ty_, StringView Ext_, const Node *TA_) - : Node(KVendorExtQualType), Ty(Ty_), Ext(Ext_), TA(TA_) {} - - const Node *getTy() const { return Ty; } - StringView getExt() const { return Ext; } - const Node *getTA() const { return TA; } - - template <typename Fn> void match(Fn F) const { F(Ty, Ext, TA); } - - void printLeft(OutputBuffer &OB) const override { - Ty->print(OB); - OB += " "; - OB += Ext; - if (TA != nullptr) - TA->print(OB); - } -}; - -enum FunctionRefQual : unsigned char { - FrefQualNone, - FrefQualLValue, - FrefQualRValue, -}; - -enum Qualifiers { - QualNone = 0, - QualConst = 0x1, - QualVolatile = 0x2, - QualRestrict = 0x4, -}; - -inline Qualifiers operator|=(Qualifiers &Q1, Qualifiers Q2) { - return Q1 = static_cast<Qualifiers>(Q1 | Q2); -} - -class QualType final : public Node { -protected: - const Qualifiers Quals; - const Node *Child; - - void printQuals(OutputBuffer &OB) const { - if (Quals & QualConst) - OB += " const"; - if (Quals & QualVolatile) - OB += " volatile"; - if (Quals & QualRestrict) - OB += " restrict"; - } - -public: - QualType(const Node *Child_, Qualifiers Quals_) - : Node(KQualType, Child_->RHSComponentCache, - Child_->ArrayCache, Child_->FunctionCache), - Quals(Quals_), Child(Child_) {} - - Qualifiers getQuals() const { return Quals; } - const Node *getChild() const { return Child; } - - template<typename Fn> void match(Fn F) const { F(Child, Quals); } - - bool hasRHSComponentSlow(OutputBuffer &OB) const override { - return Child->hasRHSComponent(OB); - } - bool hasArraySlow(OutputBuffer &OB) const override { - return Child->hasArray(OB); - } - bool hasFunctionSlow(OutputBuffer &OB) const override { - return Child->hasFunction(OB); - } - - void printLeft(OutputBuffer &OB) const override { - Child->printLeft(OB); - printQuals(OB); - } - - void printRight(OutputBuffer &OB) const override { Child->printRight(OB); } -}; - -class ConversionOperatorType final : public Node { - const Node *Ty; - -public: - ConversionOperatorType(const Node *Ty_) - : Node(KConversionOperatorType), Ty(Ty_) {} - - template<typename Fn> void match(Fn F) const { F(Ty); } - - void printLeft(OutputBuffer &OB) const override { - OB += "operator "; - Ty->print(OB); - } -}; - -class PostfixQualifiedType final : public Node { - const Node *Ty; - const StringView Postfix; - -public: - PostfixQualifiedType(const Node *Ty_, StringView Postfix_) - : Node(KPostfixQualifiedType), Ty(Ty_), Postfix(Postfix_) {} - - template<typename Fn> void match(Fn F) const { F(Ty, Postfix); } - - void printLeft(OutputBuffer &OB) const override { - Ty->printLeft(OB); - OB += Postfix; - } -}; - -class NameType final : public Node { - const StringView Name; - -public: - NameType(StringView Name_) : Node(KNameType), Name(Name_) {} - - template<typename Fn> void match(Fn F) const { F(Name); } - - StringView getName() const { return Name; } - StringView getBaseName() const override { return Name; } - - void printLeft(OutputBuffer &OB) const override { OB += Name; } -}; - -class BitIntType final : public Node { - const Node *Size; - bool Signed; - -public: - BitIntType(const Node *Size_, bool Signed_) - : Node(KBitIntType), Size(Size_), Signed(Signed_) {} - - template <typename Fn> void match(Fn F) const { F(Size, Signed); } - - void printLeft(OutputBuffer &OB) const override { - if (!Signed) - OB += "unsigned "; - OB += "_BitInt"; - OB.printOpen(); - Size->printAsOperand(OB); - OB.printClose(); - } -}; - -class ElaboratedTypeSpefType : public Node { - StringView Kind; - Node *Child; -public: - ElaboratedTypeSpefType(StringView Kind_, Node *Child_) - : Node(KElaboratedTypeSpefType), Kind(Kind_), Child(Child_) {} - - template<typename Fn> void match(Fn F) const { F(Kind, Child); } - - void printLeft(OutputBuffer &OB) const override { - OB += Kind; - OB += ' '; - Child->print(OB); - } -}; - -struct AbiTagAttr : Node { - Node *Base; - StringView Tag; - - AbiTagAttr(Node* Base_, StringView Tag_) - : Node(KAbiTagAttr, Base_->RHSComponentCache, - Base_->ArrayCache, Base_->FunctionCache), - Base(Base_), Tag(Tag_) {} - - template<typename Fn> void match(Fn F) const { F(Base, Tag); } - - void printLeft(OutputBuffer &OB) const override { - Base->printLeft(OB); - OB += "[abi:"; - OB += Tag; - OB += "]"; - } -}; - -class EnableIfAttr : public Node { - NodeArray Conditions; -public: - EnableIfAttr(NodeArray Conditions_) - : Node(KEnableIfAttr), Conditions(Conditions_) {} - - template<typename Fn> void match(Fn F) const { F(Conditions); } - - void printLeft(OutputBuffer &OB) const override { - OB += " [enable_if:"; - Conditions.printWithComma(OB); - OB += ']'; - } -}; - -class ObjCProtoName : public Node { - const Node *Ty; - StringView Protocol; - - friend class PointerType; - -public: - ObjCProtoName(const Node *Ty_, StringView Protocol_) - : Node(KObjCProtoName), Ty(Ty_), Protocol(Protocol_) {} - - template<typename Fn> void match(Fn F) const { F(Ty, Protocol); } - - bool isObjCObject() const { - return Ty->getKind() == KNameType && - static_cast<const NameType *>(Ty)->getName() == "objc_object"; - } - - void printLeft(OutputBuffer &OB) const override { - Ty->print(OB); - OB += "<"; - OB += Protocol; - OB += ">"; - } -}; - -class PointerType final : public Node { - const Node *Pointee; - -public: - PointerType(const Node *Pointee_) - : Node(KPointerType, Pointee_->RHSComponentCache), - Pointee(Pointee_) {} - - const Node *getPointee() const { return Pointee; } - - template<typename Fn> void match(Fn F) const { F(Pointee); } - - bool hasRHSComponentSlow(OutputBuffer &OB) const override { - return Pointee->hasRHSComponent(OB); - } - - void printLeft(OutputBuffer &OB) const override { - // We rewrite objc_object<SomeProtocol>* into id<SomeProtocol>. - if (Pointee->getKind() != KObjCProtoName || - !static_cast<const ObjCProtoName *>(Pointee)->isObjCObject()) { - Pointee->printLeft(OB); - if (Pointee->hasArray(OB)) - OB += " "; - if (Pointee->hasArray(OB) || Pointee->hasFunction(OB)) - OB += "("; - OB += "*"; - } else { - const auto *objcProto = static_cast<const ObjCProtoName *>(Pointee); - OB += "id<"; - OB += objcProto->Protocol; - OB += ">"; - } - } - - void printRight(OutputBuffer &OB) const override { - if (Pointee->getKind() != KObjCProtoName || - !static_cast<const ObjCProtoName *>(Pointee)->isObjCObject()) { - if (Pointee->hasArray(OB) || Pointee->hasFunction(OB)) - OB += ")"; - Pointee->printRight(OB); - } - } -}; - -enum class ReferenceKind { - LValue, - RValue, -}; - -// Represents either a LValue or an RValue reference type. -class ReferenceType : public Node { - const Node *Pointee; - ReferenceKind RK; - - mutable bool Printing = false; - - // Dig through any refs to refs, collapsing the ReferenceTypes as we go. The - // rule here is rvalue ref to rvalue ref collapses to a rvalue ref, and any - // other combination collapses to a lvalue ref. - // - // A combination of a TemplateForwardReference and a back-ref Substitution - // from an ill-formed string may have created a cycle; use cycle detection to - // avoid looping forever. - std::pair<ReferenceKind, const Node *> collapse(OutputBuffer &OB) const { - auto SoFar = std::make_pair(RK, Pointee); - // Track the chain of nodes for the Floyd's 'tortoise and hare' - // cycle-detection algorithm, since getSyntaxNode(S) is impure - PODSmallVector<const Node *, 8> Prev; - for (;;) { - const Node *SN = SoFar.second->getSyntaxNode(OB); - if (SN->getKind() != KReferenceType) - break; - auto *RT = static_cast<const ReferenceType *>(SN); - SoFar.second = RT->Pointee; - SoFar.first = std::min(SoFar.first, RT->RK); - - // The middle of Prev is the 'slow' pointer moving at half speed - Prev.push_back(SoFar.second); - if (Prev.size() > 1 && SoFar.second == Prev[(Prev.size() - 1) / 2]) { - // Cycle detected - SoFar.second = nullptr; - break; - } - } - return SoFar; - } - -public: - ReferenceType(const Node *Pointee_, ReferenceKind RK_) - : Node(KReferenceType, Pointee_->RHSComponentCache), - Pointee(Pointee_), RK(RK_) {} - - template<typename Fn> void match(Fn F) const { F(Pointee, RK); } - - bool hasRHSComponentSlow(OutputBuffer &OB) const override { - return Pointee->hasRHSComponent(OB); - } - - void printLeft(OutputBuffer &OB) const override { - if (Printing) - return; - ScopedOverride<bool> SavePrinting(Printing, true); - std::pair<ReferenceKind, const Node *> Collapsed = collapse(OB); - if (!Collapsed.second) - return; - Collapsed.second->printLeft(OB); - if (Collapsed.second->hasArray(OB)) - OB += " "; - if (Collapsed.second->hasArray(OB) || Collapsed.second->hasFunction(OB)) - OB += "("; - - OB += (Collapsed.first == ReferenceKind::LValue ? "&" : "&&"); - } - void printRight(OutputBuffer &OB) const override { - if (Printing) - return; - ScopedOverride<bool> SavePrinting(Printing, true); - std::pair<ReferenceKind, const Node *> Collapsed = collapse(OB); - if (!Collapsed.second) - return; - if (Collapsed.second->hasArray(OB) || Collapsed.second->hasFunction(OB)) - OB += ")"; - Collapsed.second->printRight(OB); - } -}; - -class PointerToMemberType final : public Node { - const Node *ClassType; - const Node *MemberType; - -public: - PointerToMemberType(const Node *ClassType_, const Node *MemberType_) - : Node(KPointerToMemberType, MemberType_->RHSComponentCache), - ClassType(ClassType_), MemberType(MemberType_) {} - - template<typename Fn> void match(Fn F) const { F(ClassType, MemberType); } - - bool hasRHSComponentSlow(OutputBuffer &OB) const override { - return MemberType->hasRHSComponent(OB); - } - - void printLeft(OutputBuffer &OB) const override { - MemberType->printLeft(OB); - if (MemberType->hasArray(OB) || MemberType->hasFunction(OB)) - OB += "("; - else - OB += " "; - ClassType->print(OB); - OB += "::*"; - } - - void printRight(OutputBuffer &OB) const override { - if (MemberType->hasArray(OB) || MemberType->hasFunction(OB)) - OB += ")"; - MemberType->printRight(OB); - } -}; - -class ArrayType final : public Node { - const Node *Base; - Node *Dimension; - -public: - ArrayType(const Node *Base_, Node *Dimension_) - : Node(KArrayType, - /*RHSComponentCache=*/Cache::Yes, - /*ArrayCache=*/Cache::Yes), - Base(Base_), Dimension(Dimension_) {} - - template<typename Fn> void match(Fn F) const { F(Base, Dimension); } - - bool hasRHSComponentSlow(OutputBuffer &) const override { return true; } - bool hasArraySlow(OutputBuffer &) const override { return true; } - - void printLeft(OutputBuffer &OB) const override { Base->printLeft(OB); } - - void printRight(OutputBuffer &OB) const override { - if (OB.back() != ']') - OB += " "; - OB += "["; - if (Dimension) - Dimension->print(OB); - OB += "]"; - Base->printRight(OB); - } -}; - -class FunctionType final : public Node { - const Node *Ret; - NodeArray Params; - Qualifiers CVQuals; - FunctionRefQual RefQual; - const Node *ExceptionSpec; - -public: - FunctionType(const Node *Ret_, NodeArray Params_, Qualifiers CVQuals_, - FunctionRefQual RefQual_, const Node *ExceptionSpec_) - : Node(KFunctionType, - /*RHSComponentCache=*/Cache::Yes, /*ArrayCache=*/Cache::No, - /*FunctionCache=*/Cache::Yes), - Ret(Ret_), Params(Params_), CVQuals(CVQuals_), RefQual(RefQual_), - ExceptionSpec(ExceptionSpec_) {} - - template<typename Fn> void match(Fn F) const { - F(Ret, Params, CVQuals, RefQual, ExceptionSpec); - } - - bool hasRHSComponentSlow(OutputBuffer &) const override { return true; } - bool hasFunctionSlow(OutputBuffer &) const override { return true; } - - // Handle C++'s ... quirky decl grammar by using the left & right - // distinction. Consider: - // int (*f(float))(char) {} - // f is a function that takes a float and returns a pointer to a function - // that takes a char and returns an int. If we're trying to print f, start - // by printing out the return types's left, then print our parameters, then - // finally print right of the return type. - void printLeft(OutputBuffer &OB) const override { - Ret->printLeft(OB); - OB += " "; - } - - void printRight(OutputBuffer &OB) const override { - OB.printOpen(); - Params.printWithComma(OB); - OB.printClose(); - Ret->printRight(OB); - - if (CVQuals & QualConst) - OB += " const"; - if (CVQuals & QualVolatile) - OB += " volatile"; - if (CVQuals & QualRestrict) - OB += " restrict"; - - if (RefQual == FrefQualLValue) - OB += " &"; - else if (RefQual == FrefQualRValue) - OB += " &&"; - - if (ExceptionSpec != nullptr) { - OB += ' '; - ExceptionSpec->print(OB); - } - } -}; - -class NoexceptSpec : public Node { - const Node *E; -public: - NoexceptSpec(const Node *E_) : Node(KNoexceptSpec), E(E_) {} - - template<typename Fn> void match(Fn F) const { F(E); } - - void printLeft(OutputBuffer &OB) const override { - OB += "noexcept"; - OB.printOpen(); - E->printAsOperand(OB); - OB.printClose(); - } -}; - -class DynamicExceptionSpec : public Node { - NodeArray Types; -public: - DynamicExceptionSpec(NodeArray Types_) - : Node(KDynamicExceptionSpec), Types(Types_) {} - - template<typename Fn> void match(Fn F) const { F(Types); } - - void printLeft(OutputBuffer &OB) const override { - OB += "throw"; - OB.printOpen(); - Types.printWithComma(OB); - OB.printClose(); - } -}; - -class FunctionEncoding final : public Node { - const Node *Ret; - const Node *Name; - NodeArray Params; - const Node *Attrs; - Qualifiers CVQuals; - FunctionRefQual RefQual; - -public: - FunctionEncoding(const Node *Ret_, const Node *Name_, NodeArray Params_, - const Node *Attrs_, Qualifiers CVQuals_, - FunctionRefQual RefQual_) - : Node(KFunctionEncoding, - /*RHSComponentCache=*/Cache::Yes, /*ArrayCache=*/Cache::No, - /*FunctionCache=*/Cache::Yes), - Ret(Ret_), Name(Name_), Params(Params_), Attrs(Attrs_), - CVQuals(CVQuals_), RefQual(RefQual_) {} - - template<typename Fn> void match(Fn F) const { - F(Ret, Name, Params, Attrs, CVQuals, RefQual); - } - - Qualifiers getCVQuals() const { return CVQuals; } - FunctionRefQual getRefQual() const { return RefQual; } - NodeArray getParams() const { return Params; } - const Node *getReturnType() const { return Ret; } - - bool hasRHSComponentSlow(OutputBuffer &) const override { return true; } - bool hasFunctionSlow(OutputBuffer &) const override { return true; } - - const Node *getName() const { return Name; } - - void printLeft(OutputBuffer &OB) const override { - if (Ret) { - Ret->printLeft(OB); - if (!Ret->hasRHSComponent(OB)) - OB += " "; - } - Name->print(OB); - } - - void printRight(OutputBuffer &OB) const override { - OB.printOpen(); - Params.printWithComma(OB); - OB.printClose(); - if (Ret) - Ret->printRight(OB); - - if (CVQuals & QualConst) - OB += " const"; - if (CVQuals & QualVolatile) - OB += " volatile"; - if (CVQuals & QualRestrict) - OB += " restrict"; - - if (RefQual == FrefQualLValue) - OB += " &"; - else if (RefQual == FrefQualRValue) - OB += " &&"; - - if (Attrs != nullptr) - Attrs->print(OB); - } -}; - -class LiteralOperator : public Node { - const Node *OpName; - -public: - LiteralOperator(const Node *OpName_) - : Node(KLiteralOperator), OpName(OpName_) {} - - template<typename Fn> void match(Fn F) const { F(OpName); } - - void printLeft(OutputBuffer &OB) const override { - OB += "operator\"\" "; - OpName->print(OB); - } -}; - -class SpecialName final : public Node { - const StringView Special; - const Node *Child; - -public: - SpecialName(StringView Special_, const Node *Child_) - : Node(KSpecialName), Special(Special_), Child(Child_) {} - - template<typename Fn> void match(Fn F) const { F(Special, Child); } - - void printLeft(OutputBuffer &OB) const override { - OB += Special; - Child->print(OB); - } -}; - -class CtorVtableSpecialName final : public Node { - const Node *FirstType; - const Node *SecondType; - -public: - CtorVtableSpecialName(const Node *FirstType_, const Node *SecondType_) - : Node(KCtorVtableSpecialName), - FirstType(FirstType_), SecondType(SecondType_) {} - - template<typename Fn> void match(Fn F) const { F(FirstType, SecondType); } - - void printLeft(OutputBuffer &OB) const override { - OB += "construction vtable for "; - FirstType->print(OB); - OB += "-in-"; - SecondType->print(OB); - } -}; - -struct NestedName : Node { - Node *Qual; - Node *Name; - - NestedName(Node *Qual_, Node *Name_) - : Node(KNestedName), Qual(Qual_), Name(Name_) {} - - template<typename Fn> void match(Fn F) const { F(Qual, Name); } - - StringView getBaseName() const override { return Name->getBaseName(); } - - void printLeft(OutputBuffer &OB) const override { - Qual->print(OB); - OB += "::"; - Name->print(OB); - } -}; - -struct ModuleName : Node { - ModuleName *Parent; - Node *Name; - bool IsPartition; - - ModuleName(ModuleName *Parent_, Node *Name_, bool IsPartition_ = false) - : Node(KModuleName), Parent(Parent_), Name(Name_), - IsPartition(IsPartition_) {} - - template <typename Fn> void match(Fn F) const { - F(Parent, Name, IsPartition); - } - - void printLeft(OutputBuffer &OB) const override { - if (Parent) - Parent->print(OB); - if (Parent || IsPartition) - OB += IsPartition ? ':' : '.'; - Name->print(OB); - } -}; - -struct ModuleEntity : Node { - ModuleName *Module; - Node *Name; - - ModuleEntity(ModuleName *Module_, Node *Name_) - : Node(KModuleEntity), Module(Module_), Name(Name_) {} - - template <typename Fn> void match(Fn F) const { F(Module, Name); } - - StringView getBaseName() const override { return Name->getBaseName(); } - - void printLeft(OutputBuffer &OB) const override { - Name->print(OB); - OB += '@'; - Module->print(OB); - } -}; - -struct LocalName : Node { - Node *Encoding; - Node *Entity; - - LocalName(Node *Encoding_, Node *Entity_) - : Node(KLocalName), Encoding(Encoding_), Entity(Entity_) {} - - template<typename Fn> void match(Fn F) const { F(Encoding, Entity); } - - void printLeft(OutputBuffer &OB) const override { - Encoding->print(OB); - OB += "::"; - Entity->print(OB); - } -}; - -class QualifiedName final : public Node { - // qualifier::name - const Node *Qualifier; - const Node *Name; - -public: - QualifiedName(const Node *Qualifier_, const Node *Name_) - : Node(KQualifiedName), Qualifier(Qualifier_), Name(Name_) {} - - template<typename Fn> void match(Fn F) const { F(Qualifier, Name); } - - StringView getBaseName() const override { return Name->getBaseName(); } - - void printLeft(OutputBuffer &OB) const override { - Qualifier->print(OB); - OB += "::"; - Name->print(OB); - } -}; - -class VectorType final : public Node { - const Node *BaseType; - const Node *Dimension; - -public: - VectorType(const Node *BaseType_, const Node *Dimension_) - : Node(KVectorType), BaseType(BaseType_), Dimension(Dimension_) {} - - const Node *getBaseType() const { return BaseType; } - const Node *getDimension() const { return Dimension; } - - template<typename Fn> void match(Fn F) const { F(BaseType, Dimension); } - - void printLeft(OutputBuffer &OB) const override { - BaseType->print(OB); - OB += " vector["; - if (Dimension) - Dimension->print(OB); - OB += "]"; - } -}; - -class PixelVectorType final : public Node { - const Node *Dimension; - -public: - PixelVectorType(const Node *Dimension_) - : Node(KPixelVectorType), Dimension(Dimension_) {} - - template<typename Fn> void match(Fn F) const { F(Dimension); } - - void printLeft(OutputBuffer &OB) const override { - // FIXME: This should demangle as "vector pixel". - OB += "pixel vector["; - Dimension->print(OB); - OB += "]"; - } -}; - -class BinaryFPType final : public Node { - const Node *Dimension; - -public: - BinaryFPType(const Node *Dimension_) - : Node(KBinaryFPType), Dimension(Dimension_) {} - - template<typename Fn> void match(Fn F) const { F(Dimension); } - - void printLeft(OutputBuffer &OB) const override { - OB += "_Float"; - Dimension->print(OB); - } -}; - -enum class TemplateParamKind { Type, NonType, Template }; - -/// An invented name for a template parameter for which we don't have a -/// corresponding template argument. -/// -/// This node is created when parsing the <lambda-sig> for a lambda with -/// explicit template arguments, which might be referenced in the parameter -/// types appearing later in the <lambda-sig>. -class SyntheticTemplateParamName final : public Node { - TemplateParamKind Kind; - unsigned Index; - -public: - SyntheticTemplateParamName(TemplateParamKind Kind_, unsigned Index_) - : Node(KSyntheticTemplateParamName), Kind(Kind_), Index(Index_) {} - - template<typename Fn> void match(Fn F) const { F(Kind, Index); } - - void printLeft(OutputBuffer &OB) const override { - switch (Kind) { - case TemplateParamKind::Type: - OB += "$T"; - break; - case TemplateParamKind::NonType: - OB += "$N"; - break; - case TemplateParamKind::Template: - OB += "$TT"; - break; - } - if (Index > 0) - OB << Index - 1; - } -}; - -/// A template type parameter declaration, 'typename T'. -class TypeTemplateParamDecl final : public Node { - Node *Name; - -public: - TypeTemplateParamDecl(Node *Name_) - : Node(KTypeTemplateParamDecl, Cache::Yes), Name(Name_) {} - - template<typename Fn> void match(Fn F) const { F(Name); } - - void printLeft(OutputBuffer &OB) const override { OB += "typename "; } - - void printRight(OutputBuffer &OB) const override { Name->print(OB); } -}; - -/// A non-type template parameter declaration, 'int N'. -class NonTypeTemplateParamDecl final : public Node { - Node *Name; - Node *Type; - -public: - NonTypeTemplateParamDecl(Node *Name_, Node *Type_) - : Node(KNonTypeTemplateParamDecl, Cache::Yes), Name(Name_), Type(Type_) {} - - template<typename Fn> void match(Fn F) const { F(Name, Type); } - - void printLeft(OutputBuffer &OB) const override { - Type->printLeft(OB); - if (!Type->hasRHSComponent(OB)) - OB += " "; - } - - void printRight(OutputBuffer &OB) const override { - Name->print(OB); - Type->printRight(OB); - } -}; - -/// A template template parameter declaration, -/// 'template<typename T> typename N'. -class TemplateTemplateParamDecl final : public Node { - Node *Name; - NodeArray Params; - -public: - TemplateTemplateParamDecl(Node *Name_, NodeArray Params_) - : Node(KTemplateTemplateParamDecl, Cache::Yes), Name(Name_), - Params(Params_) {} - - template<typename Fn> void match(Fn F) const { F(Name, Params); } - - void printLeft(OutputBuffer &OB) const override { - ScopedOverride<unsigned> LT(OB.GtIsGt, 0); - OB += "template<"; - Params.printWithComma(OB); - OB += "> typename "; - } - - void printRight(OutputBuffer &OB) const override { Name->print(OB); } -}; - -/// A template parameter pack declaration, 'typename ...T'. -class TemplateParamPackDecl final : public Node { - Node *Param; - -public: - TemplateParamPackDecl(Node *Param_) - : Node(KTemplateParamPackDecl, Cache::Yes), Param(Param_) {} - - template<typename Fn> void match(Fn F) const { F(Param); } - - void printLeft(OutputBuffer &OB) const override { - Param->printLeft(OB); - OB += "..."; - } - - void printRight(OutputBuffer &OB) const override { Param->printRight(OB); } -}; - -/// An unexpanded parameter pack (either in the expression or type context). If -/// this AST is correct, this node will have a ParameterPackExpansion node above -/// it. -/// -/// This node is created when some <template-args> are found that apply to an -/// <encoding>, and is stored in the TemplateParams table. In order for this to -/// appear in the final AST, it has to referenced via a <template-param> (ie, -/// T_). -class ParameterPack final : public Node { - NodeArray Data; - - // Setup OutputBuffer for a pack expansion, unless we're already expanding - // one. - void initializePackExpansion(OutputBuffer &OB) const { - if (OB.CurrentPackMax == std::numeric_limits<unsigned>::max()) { - OB.CurrentPackMax = static_cast<unsigned>(Data.size()); - OB.CurrentPackIndex = 0; - } - } - -public: - ParameterPack(NodeArray Data_) : Node(KParameterPack), Data(Data_) { - ArrayCache = FunctionCache = RHSComponentCache = Cache::Unknown; - if (std::all_of(Data.begin(), Data.end(), [](Node* P) { - return P->ArrayCache == Cache::No; - })) - ArrayCache = Cache::No; - if (std::all_of(Data.begin(), Data.end(), [](Node* P) { - return P->FunctionCache == Cache::No; - })) - FunctionCache = Cache::No; - if (std::all_of(Data.begin(), Data.end(), [](Node* P) { - return P->RHSComponentCache == Cache::No; - })) - RHSComponentCache = Cache::No; - } - - template<typename Fn> void match(Fn F) const { F(Data); } - - bool hasRHSComponentSlow(OutputBuffer &OB) const override { - initializePackExpansion(OB); - size_t Idx = OB.CurrentPackIndex; - return Idx < Data.size() && Data[Idx]->hasRHSComponent(OB); - } - bool hasArraySlow(OutputBuffer &OB) const override { - initializePackExpansion(OB); - size_t Idx = OB.CurrentPackIndex; - return Idx < Data.size() && Data[Idx]->hasArray(OB); - } - bool hasFunctionSlow(OutputBuffer &OB) const override { - initializePackExpansion(OB); - size_t Idx = OB.CurrentPackIndex; - return Idx < Data.size() && Data[Idx]->hasFunction(OB); - } - const Node *getSyntaxNode(OutputBuffer &OB) const override { - initializePackExpansion(OB); - size_t Idx = OB.CurrentPackIndex; - return Idx < Data.size() ? Data[Idx]->getSyntaxNode(OB) : this; - } - - void printLeft(OutputBuffer &OB) const override { - initializePackExpansion(OB); - size_t Idx = OB.CurrentPackIndex; - if (Idx < Data.size()) - Data[Idx]->printLeft(OB); - } - void printRight(OutputBuffer &OB) const override { - initializePackExpansion(OB); - size_t Idx = OB.CurrentPackIndex; - if (Idx < Data.size()) - Data[Idx]->printRight(OB); - } -}; - -/// A variadic template argument. This node represents an occurrence of -/// J<something>E in some <template-args>. It isn't itself unexpanded, unless -/// one of it's Elements is. The parser inserts a ParameterPack into the -/// TemplateParams table if the <template-args> this pack belongs to apply to an -/// <encoding>. -class TemplateArgumentPack final : public Node { - NodeArray Elements; -public: - TemplateArgumentPack(NodeArray Elements_) - : Node(KTemplateArgumentPack), Elements(Elements_) {} - - template<typename Fn> void match(Fn F) const { F(Elements); } - - NodeArray getElements() const { return Elements; } - - void printLeft(OutputBuffer &OB) const override { - Elements.printWithComma(OB); - } -}; - -/// A pack expansion. Below this node, there are some unexpanded ParameterPacks -/// which each have Child->ParameterPackSize elements. -class ParameterPackExpansion final : public Node { - const Node *Child; - -public: - ParameterPackExpansion(const Node *Child_) - : Node(KParameterPackExpansion), Child(Child_) {} - - template<typename Fn> void match(Fn F) const { F(Child); } - - const Node *getChild() const { return Child; } - - void printLeft(OutputBuffer &OB) const override { - constexpr unsigned Max = std::numeric_limits<unsigned>::max(); - ScopedOverride<unsigned> SavePackIdx(OB.CurrentPackIndex, Max); - ScopedOverride<unsigned> SavePackMax(OB.CurrentPackMax, Max); - size_t StreamPos = OB.getCurrentPosition(); - - // Print the first element in the pack. If Child contains a ParameterPack, - // it will set up S.CurrentPackMax and print the first element. - Child->print(OB); - - // No ParameterPack was found in Child. This can occur if we've found a pack - // expansion on a <function-param>. - if (OB.CurrentPackMax == Max) { - OB += "..."; - return; - } - - // We found a ParameterPack, but it has no elements. Erase whatever we may - // of printed. - if (OB.CurrentPackMax == 0) { - OB.setCurrentPosition(StreamPos); - return; - } - - // Else, iterate through the rest of the elements in the pack. - for (unsigned I = 1, E = OB.CurrentPackMax; I < E; ++I) { - OB += ", "; - OB.CurrentPackIndex = I; - Child->print(OB); - } - } -}; - -class TemplateArgs final : public Node { - NodeArray Params; - -public: - TemplateArgs(NodeArray Params_) : Node(KTemplateArgs), Params(Params_) {} - - template<typename Fn> void match(Fn F) const { F(Params); } - - NodeArray getParams() { return Params; } - - void printLeft(OutputBuffer &OB) const override { - ScopedOverride<unsigned> LT(OB.GtIsGt, 0); - OB += "<"; - Params.printWithComma(OB); - OB += ">"; - } -}; - -/// A forward-reference to a template argument that was not known at the point -/// where the template parameter name was parsed in a mangling. -/// -/// This is created when demangling the name of a specialization of a -/// conversion function template: -/// -/// \code -/// struct A { -/// template<typename T> operator T*(); -/// }; -/// \endcode -/// -/// When demangling a specialization of the conversion function template, we -/// encounter the name of the template (including the \c T) before we reach -/// the template argument list, so we cannot substitute the parameter name -/// for the corresponding argument while parsing. Instead, we create a -/// \c ForwardTemplateReference node that is resolved after we parse the -/// template arguments. -struct ForwardTemplateReference : Node { - size_t Index; - Node *Ref = nullptr; - - // If we're currently printing this node. It is possible (though invalid) for - // a forward template reference to refer to itself via a substitution. This - // creates a cyclic AST, which will stack overflow printing. To fix this, bail - // out if more than one print* function is active. - mutable bool Printing = false; - - ForwardTemplateReference(size_t Index_) - : Node(KForwardTemplateReference, Cache::Unknown, Cache::Unknown, - Cache::Unknown), - Index(Index_) {} - - // We don't provide a matcher for these, because the value of the node is - // not determined by its construction parameters, and it generally needs - // special handling. - template<typename Fn> void match(Fn F) const = delete; - - bool hasRHSComponentSlow(OutputBuffer &OB) const override { - if (Printing) - return false; - ScopedOverride<bool> SavePrinting(Printing, true); - return Ref->hasRHSComponent(OB); - } - bool hasArraySlow(OutputBuffer &OB) const override { - if (Printing) - return false; - ScopedOverride<bool> SavePrinting(Printing, true); - return Ref->hasArray(OB); - } - bool hasFunctionSlow(OutputBuffer &OB) const override { - if (Printing) - return false; - ScopedOverride<bool> SavePrinting(Printing, true); - return Ref->hasFunction(OB); - } - const Node *getSyntaxNode(OutputBuffer &OB) const override { - if (Printing) - return this; - ScopedOverride<bool> SavePrinting(Printing, true); - return Ref->getSyntaxNode(OB); - } - - void printLeft(OutputBuffer &OB) const override { - if (Printing) - return; - ScopedOverride<bool> SavePrinting(Printing, true); - Ref->printLeft(OB); - } - void printRight(OutputBuffer &OB) const override { - if (Printing) - return; - ScopedOverride<bool> SavePrinting(Printing, true); - Ref->printRight(OB); - } -}; - -struct NameWithTemplateArgs : Node { - // name<template_args> - Node *Name; - Node *TemplateArgs; - - NameWithTemplateArgs(Node *Name_, Node *TemplateArgs_) - : Node(KNameWithTemplateArgs), Name(Name_), TemplateArgs(TemplateArgs_) {} - - template<typename Fn> void match(Fn F) const { F(Name, TemplateArgs); } - - StringView getBaseName() const override { return Name->getBaseName(); } - - void printLeft(OutputBuffer &OB) const override { - Name->print(OB); - TemplateArgs->print(OB); - } -}; - -class GlobalQualifiedName final : public Node { - Node *Child; - -public: - GlobalQualifiedName(Node* Child_) - : Node(KGlobalQualifiedName), Child(Child_) {} - - template<typename Fn> void match(Fn F) const { F(Child); } - - StringView getBaseName() const override { return Child->getBaseName(); } - - void printLeft(OutputBuffer &OB) const override { - OB += "::"; - Child->print(OB); - } -}; - -enum class SpecialSubKind { - allocator, - basic_string, - string, - istream, - ostream, - iostream, -}; - -class SpecialSubstitution; -class ExpandedSpecialSubstitution : public Node { -protected: - SpecialSubKind SSK; - - ExpandedSpecialSubstitution(SpecialSubKind SSK_, Kind K_) - : Node(K_), SSK(SSK_) {} -public: - ExpandedSpecialSubstitution(SpecialSubKind SSK_) - : ExpandedSpecialSubstitution(SSK_, KExpandedSpecialSubstitution) {} - inline ExpandedSpecialSubstitution(SpecialSubstitution const *); - - template<typename Fn> void match(Fn F) const { F(SSK); } - -protected: - bool isInstantiation() const { - return unsigned(SSK) >= unsigned(SpecialSubKind::string); - } - - StringView getBaseName() const override { - switch (SSK) { - case SpecialSubKind::allocator: - return StringView("allocator"); - case SpecialSubKind::basic_string: - return StringView("basic_string"); - case SpecialSubKind::string: - return StringView("basic_string"); - case SpecialSubKind::istream: - return StringView("basic_istream"); - case SpecialSubKind::ostream: - return StringView("basic_ostream"); - case SpecialSubKind::iostream: - return StringView("basic_iostream"); - } - DEMANGLE_UNREACHABLE; - } - -private: - void printLeft(OutputBuffer &OB) const override { - OB << "std::" << getBaseName(); - if (isInstantiation()) { - OB << "<char, std::char_traits<char>"; - if (SSK == SpecialSubKind::string) - OB << ", std::allocator<char>"; - OB << ">"; - } - } -}; - -class SpecialSubstitution final : public ExpandedSpecialSubstitution { -public: - SpecialSubstitution(SpecialSubKind SSK_) - : ExpandedSpecialSubstitution(SSK_, KSpecialSubstitution) {} - - template<typename Fn> void match(Fn F) const { F(SSK); } - - StringView getBaseName() const override { - auto SV = ExpandedSpecialSubstitution::getBaseName (); - if (isInstantiation()) { - // The instantiations are typedefs that drop the "basic_" prefix. - assert(SV.startsWith("basic_")); - SV = SV.dropFront(sizeof("basic_") - 1); - } - return SV; - } - - void printLeft(OutputBuffer &OB) const override { - OB << "std::" << getBaseName(); - } -}; - -inline ExpandedSpecialSubstitution::ExpandedSpecialSubstitution( - SpecialSubstitution const *SS) - : ExpandedSpecialSubstitution(SS->SSK) {} - -class CtorDtorName final : public Node { - const Node *Basename; - const bool IsDtor; - const int Variant; - -public: - CtorDtorName(const Node *Basename_, bool IsDtor_, int Variant_) - : Node(KCtorDtorName), Basename(Basename_), IsDtor(IsDtor_), - Variant(Variant_) {} - - template<typename Fn> void match(Fn F) const { F(Basename, IsDtor, Variant); } - - void printLeft(OutputBuffer &OB) const override { - if (IsDtor) - OB += "~"; - OB += Basename->getBaseName(); - } -}; - -class DtorName : public Node { - const Node *Base; - -public: - DtorName(const Node *Base_) : Node(KDtorName), Base(Base_) {} - - template<typename Fn> void match(Fn F) const { F(Base); } - - void printLeft(OutputBuffer &OB) const override { - OB += "~"; - Base->printLeft(OB); - } -}; - -class UnnamedTypeName : public Node { - const StringView Count; - -public: - UnnamedTypeName(StringView Count_) : Node(KUnnamedTypeName), Count(Count_) {} - - template<typename Fn> void match(Fn F) const { F(Count); } - - void printLeft(OutputBuffer &OB) const override { - OB += "'unnamed"; - OB += Count; - OB += "\'"; - } -}; - -class ClosureTypeName : public Node { - NodeArray TemplateParams; - NodeArray Params; - StringView Count; - -public: - ClosureTypeName(NodeArray TemplateParams_, NodeArray Params_, - StringView Count_) - : Node(KClosureTypeName), TemplateParams(TemplateParams_), - Params(Params_), Count(Count_) {} - - template<typename Fn> void match(Fn F) const { - F(TemplateParams, Params, Count); - } - - void printDeclarator(OutputBuffer &OB) const { - if (!TemplateParams.empty()) { - ScopedOverride<unsigned> LT(OB.GtIsGt, 0); - OB += "<"; - TemplateParams.printWithComma(OB); - OB += ">"; - } - OB.printOpen(); - Params.printWithComma(OB); - OB.printClose(); - } - - void printLeft(OutputBuffer &OB) const override { - OB += "\'lambda"; - OB += Count; - OB += "\'"; - printDeclarator(OB); - } -}; - -class StructuredBindingName : public Node { - NodeArray Bindings; -public: - StructuredBindingName(NodeArray Bindings_) - : Node(KStructuredBindingName), Bindings(Bindings_) {} - - template<typename Fn> void match(Fn F) const { F(Bindings); } - - void printLeft(OutputBuffer &OB) const override { - OB.printOpen('['); - Bindings.printWithComma(OB); - OB.printClose(']'); - } -}; - -// -- Expression Nodes -- - -class BinaryExpr : public Node { - const Node *LHS; - const StringView InfixOperator; - const Node *RHS; - -public: - BinaryExpr(const Node *LHS_, StringView InfixOperator_, const Node *RHS_, - Prec Prec_) - : Node(KBinaryExpr, Prec_), LHS(LHS_), InfixOperator(InfixOperator_), - RHS(RHS_) {} - - template <typename Fn> void match(Fn F) const { - F(LHS, InfixOperator, RHS, getPrecedence()); - } - - void printLeft(OutputBuffer &OB) const override { - bool ParenAll = OB.isGtInsideTemplateArgs() && - (InfixOperator == ">" || InfixOperator == ">>"); - if (ParenAll) - OB.printOpen(); - // Assignment is right associative, with special LHS precedence. - bool IsAssign = getPrecedence() == Prec::Assign; - LHS->printAsOperand(OB, IsAssign ? Prec::OrIf : getPrecedence(), !IsAssign); - // No space before comma operator - if (!(InfixOperator == ",")) - OB += " "; - OB += InfixOperator; - OB += " "; - RHS->printAsOperand(OB, getPrecedence(), IsAssign); - if (ParenAll) - OB.printClose(); - } -}; - -class ArraySubscriptExpr : public Node { - const Node *Op1; - const Node *Op2; - -public: - ArraySubscriptExpr(const Node *Op1_, const Node *Op2_, Prec Prec_) - : Node(KArraySubscriptExpr, Prec_), Op1(Op1_), Op2(Op2_) {} - - template <typename Fn> void match(Fn F) const { - F(Op1, Op2, getPrecedence()); - } - - void printLeft(OutputBuffer &OB) const override { - Op1->printAsOperand(OB, getPrecedence()); - OB.printOpen('['); - Op2->printAsOperand(OB); - OB.printClose(']'); - } -}; - -class PostfixExpr : public Node { - const Node *Child; - const StringView Operator; - -public: - PostfixExpr(const Node *Child_, StringView Operator_, Prec Prec_) - : Node(KPostfixExpr, Prec_), Child(Child_), Operator(Operator_) {} - - template <typename Fn> void match(Fn F) const { - F(Child, Operator, getPrecedence()); - } - - void printLeft(OutputBuffer &OB) const override { - Child->printAsOperand(OB, getPrecedence(), true); - OB += Operator; - } -}; - -class ConditionalExpr : public Node { - const Node *Cond; - const Node *Then; - const Node *Else; - -public: - ConditionalExpr(const Node *Cond_, const Node *Then_, const Node *Else_, - Prec Prec_) - : Node(KConditionalExpr, Prec_), Cond(Cond_), Then(Then_), Else(Else_) {} - - template <typename Fn> void match(Fn F) const { - F(Cond, Then, Else, getPrecedence()); - } - - void printLeft(OutputBuffer &OB) const override { - Cond->printAsOperand(OB, getPrecedence()); - OB += " ? "; - Then->printAsOperand(OB); - OB += " : "; - Else->printAsOperand(OB, Prec::Assign, true); - } -}; - -class MemberExpr : public Node { - const Node *LHS; - const StringView Kind; - const Node *RHS; - -public: - MemberExpr(const Node *LHS_, StringView Kind_, const Node *RHS_, Prec Prec_) - : Node(KMemberExpr, Prec_), LHS(LHS_), Kind(Kind_), RHS(RHS_) {} - - template <typename Fn> void match(Fn F) const { - F(LHS, Kind, RHS, getPrecedence()); - } - - void printLeft(OutputBuffer &OB) const override { - LHS->printAsOperand(OB, getPrecedence(), true); - OB += Kind; - RHS->printAsOperand(OB, getPrecedence(), false); - } -}; - -class SubobjectExpr : public Node { - const Node *Type; - const Node *SubExpr; - StringView Offset; - NodeArray UnionSelectors; - bool OnePastTheEnd; - -public: - SubobjectExpr(const Node *Type_, const Node *SubExpr_, StringView Offset_, - NodeArray UnionSelectors_, bool OnePastTheEnd_) - : Node(KSubobjectExpr), Type(Type_), SubExpr(SubExpr_), Offset(Offset_), - UnionSelectors(UnionSelectors_), OnePastTheEnd(OnePastTheEnd_) {} - - template<typename Fn> void match(Fn F) const { - F(Type, SubExpr, Offset, UnionSelectors, OnePastTheEnd); - } - - void printLeft(OutputBuffer &OB) const override { - SubExpr->print(OB); - OB += ".<"; - Type->print(OB); - OB += " at offset "; - if (Offset.empty()) { - OB += "0"; - } else if (Offset[0] == 'n') { - OB += "-"; - OB += Offset.dropFront(); - } else { - OB += Offset; - } - OB += ">"; - } -}; - -class EnclosingExpr : public Node { - const StringView Prefix; - const Node *Infix; - const StringView Postfix; - -public: - EnclosingExpr(StringView Prefix_, const Node *Infix_, - Prec Prec_ = Prec::Primary) - : Node(KEnclosingExpr, Prec_), Prefix(Prefix_), Infix(Infix_) {} - - template <typename Fn> void match(Fn F) const { - F(Prefix, Infix, getPrecedence()); - } - - void printLeft(OutputBuffer &OB) const override { - OB += Prefix; - OB.printOpen(); - Infix->print(OB); - OB.printClose(); - OB += Postfix; - } -}; - -class CastExpr : public Node { - // cast_kind<to>(from) - const StringView CastKind; - const Node *To; - const Node *From; - -public: - CastExpr(StringView CastKind_, const Node *To_, const Node *From_, Prec Prec_) - : Node(KCastExpr, Prec_), CastKind(CastKind_), To(To_), From(From_) {} - - template <typename Fn> void match(Fn F) const { - F(CastKind, To, From, getPrecedence()); - } - - void printLeft(OutputBuffer &OB) const override { - OB += CastKind; - { - ScopedOverride<unsigned> LT(OB.GtIsGt, 0); - OB += "<"; - To->printLeft(OB); - OB += ">"; - } - OB.printOpen(); - From->printAsOperand(OB); - OB.printClose(); - } -}; - -class SizeofParamPackExpr : public Node { - const Node *Pack; - -public: - SizeofParamPackExpr(const Node *Pack_) - : Node(KSizeofParamPackExpr), Pack(Pack_) {} - - template<typename Fn> void match(Fn F) const { F(Pack); } - - void printLeft(OutputBuffer &OB) const override { - OB += "sizeof..."; - OB.printOpen(); - ParameterPackExpansion PPE(Pack); - PPE.printLeft(OB); - OB.printClose(); - } -}; - -class CallExpr : public Node { - const Node *Callee; - NodeArray Args; - -public: - CallExpr(const Node *Callee_, NodeArray Args_, Prec Prec_) - : Node(KCallExpr, Prec_), Callee(Callee_), Args(Args_) {} - - template <typename Fn> void match(Fn F) const { - F(Callee, Args, getPrecedence()); - } - - void printLeft(OutputBuffer &OB) const override { - Callee->print(OB); - OB.printOpen(); - Args.printWithComma(OB); - OB.printClose(); - } -}; - -class NewExpr : public Node { - // new (expr_list) type(init_list) - NodeArray ExprList; - Node *Type; - NodeArray InitList; - bool IsGlobal; // ::operator new ? - bool IsArray; // new[] ? -public: - NewExpr(NodeArray ExprList_, Node *Type_, NodeArray InitList_, bool IsGlobal_, - bool IsArray_, Prec Prec_) - : Node(KNewExpr, Prec_), ExprList(ExprList_), Type(Type_), - InitList(InitList_), IsGlobal(IsGlobal_), IsArray(IsArray_) {} - - template<typename Fn> void match(Fn F) const { - F(ExprList, Type, InitList, IsGlobal, IsArray, getPrecedence()); - } - - void printLeft(OutputBuffer &OB) const override { - if (IsGlobal) - OB += "::"; - OB += "new"; - if (IsArray) - OB += "[]"; - if (!ExprList.empty()) { - OB.printOpen(); - ExprList.printWithComma(OB); - OB.printClose(); - } - OB += " "; - Type->print(OB); - if (!InitList.empty()) { - OB.printOpen(); - InitList.printWithComma(OB); - OB.printClose(); - } - } -}; - -class DeleteExpr : public Node { - Node *Op; - bool IsGlobal; - bool IsArray; - -public: - DeleteExpr(Node *Op_, bool IsGlobal_, bool IsArray_, Prec Prec_) - : Node(KDeleteExpr, Prec_), Op(Op_), IsGlobal(IsGlobal_), - IsArray(IsArray_) {} - - template <typename Fn> void match(Fn F) const { - F(Op, IsGlobal, IsArray, getPrecedence()); - } - - void printLeft(OutputBuffer &OB) const override { - if (IsGlobal) - OB += "::"; - OB += "delete"; - if (IsArray) - OB += "[]"; - OB += ' '; - Op->print(OB); - } -}; - -class PrefixExpr : public Node { - StringView Prefix; - Node *Child; - -public: - PrefixExpr(StringView Prefix_, Node *Child_, Prec Prec_) - : Node(KPrefixExpr, Prec_), Prefix(Prefix_), Child(Child_) {} - - template <typename Fn> void match(Fn F) const { - F(Prefix, Child, getPrecedence()); - } - - void printLeft(OutputBuffer &OB) const override { - OB += Prefix; - Child->printAsOperand(OB, getPrecedence()); - } -}; - -class FunctionParam : public Node { - StringView Number; - -public: - FunctionParam(StringView Number_) : Node(KFunctionParam), Number(Number_) {} - - template<typename Fn> void match(Fn F) const { F(Number); } - - void printLeft(OutputBuffer &OB) const override { - OB += "fp"; - OB += Number; - } -}; - -class ConversionExpr : public Node { - const Node *Type; - NodeArray Expressions; - -public: - ConversionExpr(const Node *Type_, NodeArray Expressions_, Prec Prec_) - : Node(KConversionExpr, Prec_), Type(Type_), Expressions(Expressions_) {} - - template <typename Fn> void match(Fn F) const { - F(Type, Expressions, getPrecedence()); - } - - void printLeft(OutputBuffer &OB) const override { - OB.printOpen(); - Type->print(OB); - OB.printClose(); - OB.printOpen(); - Expressions.printWithComma(OB); - OB.printClose(); - } -}; - -class PointerToMemberConversionExpr : public Node { - const Node *Type; - const Node *SubExpr; - StringView Offset; - -public: - PointerToMemberConversionExpr(const Node *Type_, const Node *SubExpr_, - StringView Offset_, Prec Prec_) - : Node(KPointerToMemberConversionExpr, Prec_), Type(Type_), - SubExpr(SubExpr_), Offset(Offset_) {} - - template <typename Fn> void match(Fn F) const { - F(Type, SubExpr, Offset, getPrecedence()); - } - - void printLeft(OutputBuffer &OB) const override { - OB.printOpen(); - Type->print(OB); - OB.printClose(); - OB.printOpen(); - SubExpr->print(OB); - OB.printClose(); - } -}; - -class InitListExpr : public Node { - const Node *Ty; - NodeArray Inits; -public: - InitListExpr(const Node *Ty_, NodeArray Inits_) - : Node(KInitListExpr), Ty(Ty_), Inits(Inits_) {} - - template<typename Fn> void match(Fn F) const { F(Ty, Inits); } - - void printLeft(OutputBuffer &OB) const override { - if (Ty) - Ty->print(OB); - OB += '{'; - Inits.printWithComma(OB); - OB += '}'; - } -}; - -class BracedExpr : public Node { - const Node *Elem; - const Node *Init; - bool IsArray; -public: - BracedExpr(const Node *Elem_, const Node *Init_, bool IsArray_) - : Node(KBracedExpr), Elem(Elem_), Init(Init_), IsArray(IsArray_) {} - - template<typename Fn> void match(Fn F) const { F(Elem, Init, IsArray); } - - void printLeft(OutputBuffer &OB) const override { - if (IsArray) { - OB += '['; - Elem->print(OB); - OB += ']'; - } else { - OB += '.'; - Elem->print(OB); - } - if (Init->getKind() != KBracedExpr && Init->getKind() != KBracedRangeExpr) - OB += " = "; - Init->print(OB); - } -}; - -class BracedRangeExpr : public Node { - const Node *First; - const Node *Last; - const Node *Init; -public: - BracedRangeExpr(const Node *First_, const Node *Last_, const Node *Init_) - : Node(KBracedRangeExpr), First(First_), Last(Last_), Init(Init_) {} - - template<typename Fn> void match(Fn F) const { F(First, Last, Init); } - - void printLeft(OutputBuffer &OB) const override { - OB += '['; - First->print(OB); - OB += " ... "; - Last->print(OB); - OB += ']'; - if (Init->getKind() != KBracedExpr && Init->getKind() != KBracedRangeExpr) - OB += " = "; - Init->print(OB); - } -}; - -class FoldExpr : public Node { - const Node *Pack, *Init; - StringView OperatorName; - bool IsLeftFold; - -public: - FoldExpr(bool IsLeftFold_, StringView OperatorName_, const Node *Pack_, - const Node *Init_) - : Node(KFoldExpr), Pack(Pack_), Init(Init_), OperatorName(OperatorName_), - IsLeftFold(IsLeftFold_) {} - - template<typename Fn> void match(Fn F) const { - F(IsLeftFold, OperatorName, Pack, Init); - } - - void printLeft(OutputBuffer &OB) const override { - auto PrintPack = [&] { - OB.printOpen(); - ParameterPackExpansion(Pack).print(OB); - OB.printClose(); - }; - - OB.printOpen(); - // Either '[init op ]... op pack' or 'pack op ...[ op init]' - // Refactored to '[(init|pack) op ]...[ op (pack|init)]' - // Fold expr operands are cast-expressions - if (!IsLeftFold || Init != nullptr) { - // '(init|pack) op ' - if (IsLeftFold) - Init->printAsOperand(OB, Prec::Cast, true); - else - PrintPack(); - OB << " " << OperatorName << " "; - } - OB << "..."; - if (IsLeftFold || Init != nullptr) { - // ' op (init|pack)' - OB << " " << OperatorName << " "; - if (IsLeftFold) - PrintPack(); - else - Init->printAsOperand(OB, Prec::Cast, true); - } - OB.printClose(); - } -}; - -class ThrowExpr : public Node { - const Node *Op; - -public: - ThrowExpr(const Node *Op_) : Node(KThrowExpr), Op(Op_) {} - - template<typename Fn> void match(Fn F) const { F(Op); } - - void printLeft(OutputBuffer &OB) const override { - OB += "throw "; - Op->print(OB); - } -}; - -class BoolExpr : public Node { - bool Value; - -public: - BoolExpr(bool Value_) : Node(KBoolExpr), Value(Value_) {} - - template<typename Fn> void match(Fn F) const { F(Value); } - - void printLeft(OutputBuffer &OB) const override { - OB += Value ? StringView("true") : StringView("false"); - } -}; - -class StringLiteral : public Node { - const Node *Type; - -public: - StringLiteral(const Node *Type_) : Node(KStringLiteral), Type(Type_) {} - - template<typename Fn> void match(Fn F) const { F(Type); } - - void printLeft(OutputBuffer &OB) const override { - OB += "\"<"; - Type->print(OB); - OB += ">\""; - } -}; - -class LambdaExpr : public Node { - const Node *Type; - -public: - LambdaExpr(const Node *Type_) : Node(KLambdaExpr), Type(Type_) {} - - template<typename Fn> void match(Fn F) const { F(Type); } - - void printLeft(OutputBuffer &OB) const override { - OB += "[]"; - if (Type->getKind() == KClosureTypeName) - static_cast<const ClosureTypeName *>(Type)->printDeclarator(OB); - OB += "{...}"; - } -}; - -class EnumLiteral : public Node { - // ty(integer) - const Node *Ty; - StringView Integer; - -public: - EnumLiteral(const Node *Ty_, StringView Integer_) - : Node(KEnumLiteral), Ty(Ty_), Integer(Integer_) {} - - template<typename Fn> void match(Fn F) const { F(Ty, Integer); } - - void printLeft(OutputBuffer &OB) const override { - OB.printOpen(); - Ty->print(OB); - OB.printClose(); - - if (Integer[0] == 'n') - OB << "-" << Integer.dropFront(1); - else - OB << Integer; - } -}; - -class IntegerLiteral : public Node { - StringView Type; - StringView Value; - -public: - IntegerLiteral(StringView Type_, StringView Value_) - : Node(KIntegerLiteral), Type(Type_), Value(Value_) {} - - template<typename Fn> void match(Fn F) const { F(Type, Value); } - - void printLeft(OutputBuffer &OB) const override { - if (Type.size() > 3) { - OB.printOpen(); - OB += Type; - OB.printClose(); - } - - if (Value[0] == 'n') { - OB += '-'; - OB += Value.dropFront(1); - } else - OB += Value; - - if (Type.size() <= 3) - OB += Type; - } -}; - -template <class Float> struct FloatData; - -namespace float_literal_impl { -constexpr Node::Kind getFloatLiteralKind(float *) { - return Node::KFloatLiteral; -} -constexpr Node::Kind getFloatLiteralKind(double *) { - return Node::KDoubleLiteral; -} -constexpr Node::Kind getFloatLiteralKind(long double *) { - return Node::KLongDoubleLiteral; -} -} - -template <class Float> class FloatLiteralImpl : public Node { - const StringView Contents; - - static constexpr Kind KindForClass = - float_literal_impl::getFloatLiteralKind((Float *)nullptr); - -public: - FloatLiteralImpl(StringView Contents_) - : Node(KindForClass), Contents(Contents_) {} - - template<typename Fn> void match(Fn F) const { F(Contents); } - - void printLeft(OutputBuffer &OB) const override { - const char *first = Contents.begin(); - const char *last = Contents.end() + 1; - - const size_t N = FloatData<Float>::mangled_size; - if (static_cast<std::size_t>(last - first) > N) { - last = first + N; - union { - Float value; - char buf[sizeof(Float)]; - }; - const char *t = first; - char *e = buf; - for (; t != last; ++t, ++e) { - unsigned d1 = isdigit(*t) ? static_cast<unsigned>(*t - '0') - : static_cast<unsigned>(*t - 'a' + 10); - ++t; - unsigned d0 = isdigit(*t) ? static_cast<unsigned>(*t - '0') - : static_cast<unsigned>(*t - 'a' + 10); - *e = static_cast<char>((d1 << 4) + d0); - } -#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ - std::reverse(buf, e); -#endif - char num[FloatData<Float>::max_demangled_size] = {0}; - int n = snprintf(num, sizeof(num), FloatData<Float>::spec, value); - OB += StringView(num, num + n); - } - } -}; - -using FloatLiteral = FloatLiteralImpl<float>; -using DoubleLiteral = FloatLiteralImpl<double>; -using LongDoubleLiteral = FloatLiteralImpl<long double>; - -/// Visit the node. Calls \c F(P), where \c P is the node cast to the -/// appropriate derived class. -template<typename Fn> -void Node::visit(Fn F) const { - switch (K) { -#define NODE(X) \ - case K##X: \ - return F(static_cast<const X *>(this)); -#include "ItaniumNodes.def" - } - assert(0 && "unknown mangling node kind"); -} - -/// Determine the kind of a node from its type. -template<typename NodeT> struct NodeKind; -#define NODE(X) \ - template <> struct NodeKind<X> { \ - static constexpr Node::Kind Kind = Node::K##X; \ - static constexpr const char *name() { return #X; } \ - }; -#include "ItaniumNodes.def" - -template <typename Derived, typename Alloc> struct AbstractManglingParser { - const char *First; - const char *Last; - - // Name stack, this is used by the parser to hold temporary names that were - // parsed. The parser collapses multiple names into new nodes to construct - // the AST. Once the parser is finished, names.size() == 1. - PODSmallVector<Node *, 32> Names; - - // Substitution table. Itanium supports name substitutions as a means of - // compression. The string "S42_" refers to the 44nd entry (base-36) in this - // table. - PODSmallVector<Node *, 32> Subs; - - using TemplateParamList = PODSmallVector<Node *, 8>; - - class ScopedTemplateParamList { - AbstractManglingParser *Parser; - size_t OldNumTemplateParamLists; - TemplateParamList Params; - - public: - ScopedTemplateParamList(AbstractManglingParser *TheParser) - : Parser(TheParser), - OldNumTemplateParamLists(TheParser->TemplateParams.size()) { - Parser->TemplateParams.push_back(&Params); - } - ~ScopedTemplateParamList() { - assert(Parser->TemplateParams.size() >= OldNumTemplateParamLists); - Parser->TemplateParams.dropBack(OldNumTemplateParamLists); - } - }; - - // Template parameter table. Like the above, but referenced like "T42_". - // This has a smaller size compared to Subs and Names because it can be - // stored on the stack. - TemplateParamList OuterTemplateParams; - - // Lists of template parameters indexed by template parameter depth, - // referenced like "TL2_4_". If nonempty, element 0 is always - // OuterTemplateParams; inner elements are always template parameter lists of - // lambda expressions. For a generic lambda with no explicit template - // parameter list, the corresponding parameter list pointer will be null. - PODSmallVector<TemplateParamList *, 4> TemplateParams; - - // Set of unresolved forward <template-param> references. These can occur in a - // conversion operator's type, and are resolved in the enclosing <encoding>. - PODSmallVector<ForwardTemplateReference *, 4> ForwardTemplateRefs; - - bool TryToParseTemplateArgs = true; - bool PermitForwardTemplateReferences = false; - size_t ParsingLambdaParamsAtLevel = (size_t)-1; - - unsigned NumSyntheticTemplateParameters[3] = {}; - - Alloc ASTAllocator; - - AbstractManglingParser(const char *First_, const char *Last_) - : First(First_), Last(Last_) {} - - Derived &getDerived() { return static_cast<Derived &>(*this); } - - void reset(const char *First_, const char *Last_) { - First = First_; - Last = Last_; - Names.clear(); - Subs.clear(); - TemplateParams.clear(); - ParsingLambdaParamsAtLevel = (size_t)-1; - TryToParseTemplateArgs = true; - PermitForwardTemplateReferences = false; - for (int I = 0; I != 3; ++I) - NumSyntheticTemplateParameters[I] = 0; - ASTAllocator.reset(); - } - - template <class T, class... Args> Node *make(Args &&... args) { - return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...); - } - - template <class It> NodeArray makeNodeArray(It begin, It end) { - size_t sz = static_cast<size_t>(end - begin); - void *mem = ASTAllocator.allocateNodeArray(sz); - Node **data = new (mem) Node *[sz]; - std::copy(begin, end, data); - return NodeArray(data, sz); - } - - NodeArray popTrailingNodeArray(size_t FromPosition) { - assert(FromPosition <= Names.size()); - NodeArray res = - makeNodeArray(Names.begin() + (long)FromPosition, Names.end()); - Names.dropBack(FromPosition); - return res; - } - - bool consumeIf(StringView S) { - if (StringView(First, Last).startsWith(S)) { - First += S.size(); - return true; - } - return false; - } - - bool consumeIf(char C) { - if (First != Last && *First == C) { - ++First; - return true; - } - return false; - } - - char consume() { return First != Last ? *First++ : '\0'; } - - char look(unsigned Lookahead = 0) const { - if (static_cast<size_t>(Last - First) <= Lookahead) - return '\0'; - return First[Lookahead]; - } - - size_t numLeft() const { return static_cast<size_t>(Last - First); } - - StringView parseNumber(bool AllowNegative = false); - Qualifiers parseCVQualifiers(); - bool parsePositiveInteger(size_t *Out); - StringView parseBareSourceName(); - - bool parseSeqId(size_t *Out); - Node *parseSubstitution(); - Node *parseTemplateParam(); - Node *parseTemplateParamDecl(); - Node *parseTemplateArgs(bool TagTemplates = false); - Node *parseTemplateArg(); - - /// Parse the <expr> production. - Node *parseExpr(); - Node *parsePrefixExpr(StringView Kind, Node::Prec Prec); - Node *parseBinaryExpr(StringView Kind, Node::Prec Prec); - Node *parseIntegerLiteral(StringView Lit); - Node *parseExprPrimary(); - template <class Float> Node *parseFloatingLiteral(); - Node *parseFunctionParam(); - Node *parseConversionExpr(); - Node *parseBracedExpr(); - Node *parseFoldExpr(); - Node *parsePointerToMemberConversionExpr(Node::Prec Prec); - Node *parseSubobjectExpr(); - - /// Parse the <type> production. - Node *parseType(); - Node *parseFunctionType(); - Node *parseVectorType(); - Node *parseDecltype(); - Node *parseArrayType(); - Node *parsePointerToMemberType(); - Node *parseClassEnumType(); - Node *parseQualifiedType(); - - Node *parseEncoding(); - bool parseCallOffset(); - Node *parseSpecialName(); - - /// Holds some extra information about a <name> that is being parsed. This - /// information is only pertinent if the <name> refers to an <encoding>. - struct NameState { - bool CtorDtorConversion = false; - bool EndsWithTemplateArgs = false; - Qualifiers CVQualifiers = QualNone; - FunctionRefQual ReferenceQualifier = FrefQualNone; - size_t ForwardTemplateRefsBegin; - - NameState(AbstractManglingParser *Enclosing) - : ForwardTemplateRefsBegin(Enclosing->ForwardTemplateRefs.size()) {} - }; - - bool resolveForwardTemplateRefs(NameState &State) { - size_t I = State.ForwardTemplateRefsBegin; - size_t E = ForwardTemplateRefs.size(); - for (; I < E; ++I) { - size_t Idx = ForwardTemplateRefs[I]->Index; - if (TemplateParams.empty() || !TemplateParams[0] || - Idx >= TemplateParams[0]->size()) - return true; - ForwardTemplateRefs[I]->Ref = (*TemplateParams[0])[Idx]; - } - ForwardTemplateRefs.dropBack(State.ForwardTemplateRefsBegin); - return false; - } - - /// Parse the <name> production> - Node *parseName(NameState *State = nullptr); - Node *parseLocalName(NameState *State); - Node *parseOperatorName(NameState *State); - bool parseModuleNameOpt(ModuleName *&Module); - Node *parseUnqualifiedName(NameState *State, Node *Scope, ModuleName *Module); - Node *parseUnnamedTypeName(NameState *State); - Node *parseSourceName(NameState *State); - Node *parseUnscopedName(NameState *State, bool *isSubstName); - Node *parseNestedName(NameState *State); - Node *parseCtorDtorName(Node *&SoFar, NameState *State); - - Node *parseAbiTags(Node *N); - - struct OperatorInfo { - enum OIKind : unsigned char { - Prefix, // Prefix unary: @ expr - Postfix, // Postfix unary: expr @ - Binary, // Binary: lhs @ rhs - Array, // Array index: lhs [ rhs ] - Member, // Member access: lhs @ rhs - New, // New - Del, // Delete - Call, // Function call: expr (expr*) - CCast, // C cast: (type)expr - Conditional, // Conditional: expr ? expr : expr - NameOnly, // Overload only, not allowed in expression. - // Below do not have operator names - NamedCast, // Named cast, @<type>(expr) - OfIdOp, // alignof, sizeof, typeid - - Unnameable = NamedCast, - }; - char Enc[2]; // Encoding - OIKind Kind; // Kind of operator - bool Flag : 1; // Entry-specific flag - Node::Prec Prec : 7; // Precedence - const char *Name; // Spelling - - public: - constexpr OperatorInfo(const char (&E)[3], OIKind K, bool F, Node::Prec P, - const char *N) - : Enc{E[0], E[1]}, Kind{K}, Flag{F}, Prec{P}, Name{N} {} - - public: - bool operator<(const OperatorInfo &Other) const { - return *this < Other.Enc; - } - bool operator<(const char *Peek) const { - return Enc[0] < Peek[0] || (Enc[0] == Peek[0] && Enc[1] < Peek[1]); - } - bool operator==(const char *Peek) const { - return Enc[0] == Peek[0] && Enc[1] == Peek[1]; - } - bool operator!=(const char *Peek) const { return !this->operator==(Peek); } - - public: - StringView getSymbol() const { - StringView Res = Name; - if (Kind < Unnameable) { - assert(Res.startsWith("operator") && - "operator name does not start with 'operator'"); - Res = Res.dropFront(sizeof("operator") - 1); - Res.consumeFront(' '); - } - return Res; - } - StringView getName() const { return Name; } - OIKind getKind() const { return Kind; } - bool getFlag() const { return Flag; } - Node::Prec getPrecedence() const { return Prec; } - }; - static const OperatorInfo Ops[]; - static const size_t NumOps; - const OperatorInfo *parseOperatorEncoding(); - - /// Parse the <unresolved-name> production. - Node *parseUnresolvedName(bool Global); - Node *parseSimpleId(); - Node *parseBaseUnresolvedName(); - Node *parseUnresolvedType(); - Node *parseDestructorName(); - - /// Top-level entry point into the parser. - Node *parse(); -}; - -const char* parse_discriminator(const char* first, const char* last); - -// <name> ::= <nested-name> // N -// ::= <local-name> # See Scope Encoding below // Z -// ::= <unscoped-template-name> <template-args> -// ::= <unscoped-name> -// -// <unscoped-template-name> ::= <unscoped-name> -// ::= <substitution> -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseName(NameState *State) { - if (look() == 'N') - return getDerived().parseNestedName(State); - if (look() == 'Z') - return getDerived().parseLocalName(State); - - Node *Result = nullptr; - bool IsSubst = false; - - Result = getDerived().parseUnscopedName(State, &IsSubst); - if (!Result) - return nullptr; - - if (look() == 'I') { - // ::= <unscoped-template-name> <template-args> - if (!IsSubst) - // An unscoped-template-name is substitutable. - Subs.push_back(Result); - Node *TA = getDerived().parseTemplateArgs(State != nullptr); - if (TA == nullptr) - return nullptr; - if (State) - State->EndsWithTemplateArgs = true; - Result = make<NameWithTemplateArgs>(Result, TA); - } else if (IsSubst) { - // The substitution case must be followed by <template-args>. - return nullptr; - } - - return Result; -} - -// <local-name> := Z <function encoding> E <entity name> [<discriminator>] -// := Z <function encoding> E s [<discriminator>] -// := Z <function encoding> Ed [ <parameter number> ] _ <entity name> -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseLocalName(NameState *State) { - if (!consumeIf('Z')) - return nullptr; - Node *Encoding = getDerived().parseEncoding(); - if (Encoding == nullptr || !consumeIf('E')) - return nullptr; - - if (consumeIf('s')) { - First = parse_discriminator(First, Last); - auto *StringLitName = make<NameType>("string literal"); - if (!StringLitName) - return nullptr; - return make<LocalName>(Encoding, StringLitName); - } - - if (consumeIf('d')) { - parseNumber(true); - if (!consumeIf('_')) - return nullptr; - Node *N = getDerived().parseName(State); - if (N == nullptr) - return nullptr; - return make<LocalName>(Encoding, N); - } - - Node *Entity = getDerived().parseName(State); - if (Entity == nullptr) - return nullptr; - First = parse_discriminator(First, Last); - return make<LocalName>(Encoding, Entity); -} - -// <unscoped-name> ::= <unqualified-name> -// ::= St <unqualified-name> # ::std:: -// [*] extension -template <typename Derived, typename Alloc> -Node * -AbstractManglingParser<Derived, Alloc>::parseUnscopedName(NameState *State, - bool *IsSubst) { - - Node *Std = nullptr; - if (consumeIf("St")) { - Std = make<NameType>("std"); - if (Std == nullptr) - return nullptr; - } - - Node *Res = nullptr; - ModuleName *Module = nullptr; - if (look() == 'S') { - Node *S = getDerived().parseSubstitution(); - if (!S) - return nullptr; - if (S->getKind() == Node::KModuleName) - Module = static_cast<ModuleName *>(S); - else if (IsSubst && Std == nullptr) { - Res = S; - *IsSubst = true; - } else { - return nullptr; - } - } - - if (Res == nullptr || Std != nullptr) { - Res = getDerived().parseUnqualifiedName(State, Std, Module); - } - - return Res; -} - -// <unqualified-name> ::= [<module-name>] L? <operator-name> [<abi-tags>] -// ::= [<module-name>] <ctor-dtor-name> [<abi-tags>] -// ::= [<module-name>] L? <source-name> [<abi-tags>] -// ::= [<module-name>] L? <unnamed-type-name> [<abi-tags>] -// # structured binding declaration -// ::= [<module-name>] L? DC <source-name>+ E -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseUnqualifiedName( - NameState *State, Node *Scope, ModuleName *Module) { - if (getDerived().parseModuleNameOpt(Module)) - return nullptr; - - consumeIf('L'); - - Node *Result; - if (look() >= '1' && look() <= '9') { - Result = getDerived().parseSourceName(State); - } else if (look() == 'U') { - Result = getDerived().parseUnnamedTypeName(State); - } else if (consumeIf("DC")) { - // Structured binding - size_t BindingsBegin = Names.size(); - do { - Node *Binding = getDerived().parseSourceName(State); - if (Binding == nullptr) - return nullptr; - Names.push_back(Binding); - } while (!consumeIf('E')); - Result = make<StructuredBindingName>(popTrailingNodeArray(BindingsBegin)); - } else if (look() == 'C' || look() == 'D') { - // A <ctor-dtor-name>. - if (Scope == nullptr || Module != nullptr) - return nullptr; - Result = getDerived().parseCtorDtorName(Scope, State); - } else { - Result = getDerived().parseOperatorName(State); - } - - if (Result != nullptr && Module != nullptr) - Result = make<ModuleEntity>(Module, Result); - if (Result != nullptr) - Result = getDerived().parseAbiTags(Result); - if (Result != nullptr && Scope != nullptr) - Result = make<NestedName>(Scope, Result); - - return Result; -} - -// <module-name> ::= <module-subname> -// ::= <module-name> <module-subname> -// ::= <substitution> # passed in by caller -// <module-subname> ::= W <source-name> -// ::= W P <source-name> -template <typename Derived, typename Alloc> -bool AbstractManglingParser<Derived, Alloc>::parseModuleNameOpt( - ModuleName *&Module) { - while (consumeIf('W')) { - bool IsPartition = consumeIf('P'); - Node *Sub = getDerived().parseSourceName(nullptr); - if (!Sub) - return true; - Module = - static_cast<ModuleName *>(make<ModuleName>(Module, Sub, IsPartition)); - Subs.push_back(Module); - } - - return false; -} - -// <unnamed-type-name> ::= Ut [<nonnegative number>] _ -// ::= <closure-type-name> -// -// <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ -// -// <lambda-sig> ::= <parameter type>+ # Parameter types or "v" if the lambda has no parameters -template <typename Derived, typename Alloc> -Node * -AbstractManglingParser<Derived, Alloc>::parseUnnamedTypeName(NameState *State) { - // <template-params> refer to the innermost <template-args>. Clear out any - // outer args that we may have inserted into TemplateParams. - if (State != nullptr) - TemplateParams.clear(); - - if (consumeIf("Ut")) { - StringView Count = parseNumber(); - if (!consumeIf('_')) - return nullptr; - return make<UnnamedTypeName>(Count); - } - if (consumeIf("Ul")) { - ScopedOverride<size_t> SwapParams(ParsingLambdaParamsAtLevel, - TemplateParams.size()); - ScopedTemplateParamList LambdaTemplateParams(this); - - size_t ParamsBegin = Names.size(); - while (look() == 'T' && - StringView("yptn").find(look(1)) != StringView::npos) { - Node *T = parseTemplateParamDecl(); - if (!T) - return nullptr; - Names.push_back(T); - } - NodeArray TempParams = popTrailingNodeArray(ParamsBegin); - - // FIXME: If TempParams is empty and none of the function parameters - // includes 'auto', we should remove LambdaTemplateParams from the - // TemplateParams list. Unfortunately, we don't find out whether there are - // any 'auto' parameters until too late in an example such as: - // - // template<typename T> void f( - // decltype([](decltype([]<typename T>(T v) {}), - // auto) {})) {} - // template<typename T> void f( - // decltype([](decltype([]<typename T>(T w) {}), - // int) {})) {} - // - // Here, the type of v is at level 2 but the type of w is at level 1. We - // don't find this out until we encounter the type of the next parameter. - // - // However, compilers can't actually cope with the former example in - // practice, and it's likely to be made ill-formed in future, so we don't - // need to support it here. - // - // If we encounter an 'auto' in the function parameter types, we will - // recreate a template parameter scope for it, but any intervening lambdas - // will be parsed in the 'wrong' template parameter depth. - if (TempParams.empty()) - TemplateParams.pop_back(); - - if (!consumeIf("vE")) { - do { - Node *P = getDerived().parseType(); - if (P == nullptr) - return nullptr; - Names.push_back(P); - } while (!consumeIf('E')); - } - NodeArray Params = popTrailingNodeArray(ParamsBegin); - - StringView Count = parseNumber(); - if (!consumeIf('_')) - return nullptr; - return make<ClosureTypeName>(TempParams, Params, Count); - } - if (consumeIf("Ub")) { - (void)parseNumber(); - if (!consumeIf('_')) - return nullptr; - return make<NameType>("'block-literal'"); - } - return nullptr; -} - -// <source-name> ::= <positive length number> <identifier> -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseSourceName(NameState *) { - size_t Length = 0; - if (parsePositiveInteger(&Length)) - return nullptr; - if (numLeft() < Length || Length == 0) - return nullptr; - StringView Name(First, First + Length); - First += Length; - if (Name.startsWith("_GLOBAL__N")) - return make<NameType>("(anonymous namespace)"); - return make<NameType>(Name); -} - -// Operator encodings -template <typename Derived, typename Alloc> -const typename AbstractManglingParser< - Derived, Alloc>::OperatorInfo AbstractManglingParser<Derived, - Alloc>::Ops[] = { - // Keep ordered by encoding - {"aN", OperatorInfo::Binary, false, Node::Prec::Assign, "operator&="}, - {"aS", OperatorInfo::Binary, false, Node::Prec::Assign, "operator="}, - {"aa", OperatorInfo::Binary, false, Node::Prec::AndIf, "operator&&"}, - {"ad", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator&"}, - {"an", OperatorInfo::Binary, false, Node::Prec::And, "operator&"}, - {"at", OperatorInfo::OfIdOp, /*Type*/ true, Node::Prec::Unary, "alignof "}, - {"aw", OperatorInfo::NameOnly, false, Node::Prec::Primary, - "operator co_await"}, - {"az", OperatorInfo::OfIdOp, /*Type*/ false, Node::Prec::Unary, "alignof "}, - {"cc", OperatorInfo::NamedCast, false, Node::Prec::Postfix, "const_cast"}, - {"cl", OperatorInfo::Call, false, Node::Prec::Postfix, "operator()"}, - {"cm", OperatorInfo::Binary, false, Node::Prec::Comma, "operator,"}, - {"co", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator~"}, - {"cv", OperatorInfo::CCast, false, Node::Prec::Cast, "operator"}, // C Cast - {"dV", OperatorInfo::Binary, false, Node::Prec::Assign, "operator/="}, - {"da", OperatorInfo::Del, /*Ary*/ true, Node::Prec::Unary, - "operator delete[]"}, - {"dc", OperatorInfo::NamedCast, false, Node::Prec::Postfix, "dynamic_cast"}, - {"de", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator*"}, - {"dl", OperatorInfo::Del, /*Ary*/ false, Node::Prec::Unary, - "operator delete"}, - {"ds", OperatorInfo::Member, /*Named*/ false, Node::Prec::PtrMem, - "operator.*"}, - {"dt", OperatorInfo::Member, /*Named*/ false, Node::Prec::Postfix, - "operator."}, - {"dv", OperatorInfo::Binary, false, Node::Prec::Assign, "operator/"}, - {"eO", OperatorInfo::Binary, false, Node::Prec::Assign, "operator^="}, - {"eo", OperatorInfo::Binary, false, Node::Prec::Xor, "operator^"}, - {"eq", OperatorInfo::Binary, false, Node::Prec::Equality, "operator=="}, - {"ge", OperatorInfo::Binary, false, Node::Prec::Relational, "operator>="}, - {"gt", OperatorInfo::Binary, false, Node::Prec::Relational, "operator>"}, - {"ix", OperatorInfo::Array, false, Node::Prec::Postfix, "operator[]"}, - {"lS", OperatorInfo::Binary, false, Node::Prec::Assign, "operator<<="}, - {"le", OperatorInfo::Binary, false, Node::Prec::Relational, "operator<="}, - {"ls", OperatorInfo::Binary, false, Node::Prec::Shift, "operator<<"}, - {"lt", OperatorInfo::Binary, false, Node::Prec::Relational, "operator<"}, - {"mI", OperatorInfo::Binary, false, Node::Prec::Assign, "operator-="}, - {"mL", OperatorInfo::Binary, false, Node::Prec::Assign, "operator*="}, - {"mi", OperatorInfo::Binary, false, Node::Prec::Additive, "operator-"}, - {"ml", OperatorInfo::Binary, false, Node::Prec::Multiplicative, - "operator*"}, - {"mm", OperatorInfo::Postfix, false, Node::Prec::Postfix, "operator--"}, - {"na", OperatorInfo::New, /*Ary*/ true, Node::Prec::Unary, - "operator new[]"}, - {"ne", OperatorInfo::Binary, false, Node::Prec::Equality, "operator!="}, - {"ng", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator-"}, - {"nt", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator!"}, - {"nw", OperatorInfo::New, /*Ary*/ false, Node::Prec::Unary, "operator new"}, - {"oR", OperatorInfo::Binary, false, Node::Prec::Assign, "operator|="}, - {"oo", OperatorInfo::Binary, false, Node::Prec::OrIf, "operator||"}, - {"or", OperatorInfo::Binary, false, Node::Prec::Ior, "operator|"}, - {"pL", OperatorInfo::Binary, false, Node::Prec::Assign, "operator+="}, - {"pl", OperatorInfo::Binary, false, Node::Prec::Additive, "operator+"}, - {"pm", OperatorInfo::Member, /*Named*/ false, Node::Prec::PtrMem, - "operator->*"}, - {"pp", OperatorInfo::Postfix, false, Node::Prec::Postfix, "operator++"}, - {"ps", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator+"}, - {"pt", OperatorInfo::Member, /*Named*/ true, Node::Prec::Postfix, - "operator->"}, - {"qu", OperatorInfo::Conditional, false, Node::Prec::Conditional, - "operator?"}, - {"rM", OperatorInfo::Binary, false, Node::Prec::Assign, "operator%="}, - {"rS", OperatorInfo::Binary, false, Node::Prec::Assign, "operator>>="}, - {"rc", OperatorInfo::NamedCast, false, Node::Prec::Postfix, - "reinterpret_cast"}, - {"rm", OperatorInfo::Binary, false, Node::Prec::Multiplicative, - "operator%"}, - {"rs", OperatorInfo::Binary, false, Node::Prec::Shift, "operator>>"}, - {"sc", OperatorInfo::NamedCast, false, Node::Prec::Postfix, "static_cast"}, - {"ss", OperatorInfo::Binary, false, Node::Prec::Spaceship, "operator<=>"}, - {"st", OperatorInfo::OfIdOp, /*Type*/ true, Node::Prec::Unary, "sizeof "}, - {"sz", OperatorInfo::OfIdOp, /*Type*/ false, Node::Prec::Unary, "sizeof "}, - {"te", OperatorInfo::OfIdOp, /*Type*/ false, Node::Prec::Postfix, - "typeid "}, - {"ti", OperatorInfo::OfIdOp, /*Type*/ true, Node::Prec::Postfix, "typeid "}, -}; -template <typename Derived, typename Alloc> -const size_t AbstractManglingParser<Derived, Alloc>::NumOps = sizeof(Ops) / - sizeof(Ops[0]); - -// If the next 2 chars are an operator encoding, consume them and return their -// OperatorInfo. Otherwise return nullptr. -template <typename Derived, typename Alloc> -const typename AbstractManglingParser<Derived, Alloc>::OperatorInfo * -AbstractManglingParser<Derived, Alloc>::parseOperatorEncoding() { - if (numLeft() < 2) - return nullptr; - - // We can't use lower_bound as that can link to symbols in the C++ library, - // and this must remain independant of that. - size_t lower = 0u, upper = NumOps - 1; // Inclusive bounds. - while (upper != lower) { - size_t middle = (upper + lower) / 2; - if (Ops[middle] < First) - lower = middle + 1; - else - upper = middle; - } - if (Ops[lower] != First) - return nullptr; - - First += 2; - return &Ops[lower]; -} - -// <operator-name> ::= See parseOperatorEncoding() -// ::= li <source-name> # operator "" -// ::= v <digit> <source-name> # vendor extended operator -template <typename Derived, typename Alloc> -Node * -AbstractManglingParser<Derived, Alloc>::parseOperatorName(NameState *State) { - if (const auto *Op = parseOperatorEncoding()) { - if (Op->getKind() == OperatorInfo::CCast) { - // ::= cv <type> # (cast) - ScopedOverride<bool> SaveTemplate(TryToParseTemplateArgs, false); - // If we're parsing an encoding, State != nullptr and the conversion - // operators' <type> could have a <template-param> that refers to some - // <template-arg>s further ahead in the mangled name. - ScopedOverride<bool> SavePermit(PermitForwardTemplateReferences, - PermitForwardTemplateReferences || - State != nullptr); - Node *Ty = getDerived().parseType(); - if (Ty == nullptr) - return nullptr; - if (State) State->CtorDtorConversion = true; - return make<ConversionOperatorType>(Ty); - } - - if (Op->getKind() >= OperatorInfo::Unnameable) - /* Not a nameable operator. */ - return nullptr; - if (Op->getKind() == OperatorInfo::Member && !Op->getFlag()) - /* Not a nameable MemberExpr */ - return nullptr; - - return make<NameType>(Op->getName()); - } - - if (consumeIf("li")) { - // ::= li <source-name> # operator "" - Node *SN = getDerived().parseSourceName(State); - if (SN == nullptr) - return nullptr; - return make<LiteralOperator>(SN); - } - - if (consumeIf('v')) { - // ::= v <digit> <source-name> # vendor extended operator - if (look() >= '0' && look() <= '9') { - First++; - Node *SN = getDerived().parseSourceName(State); - if (SN == nullptr) - return nullptr; - return make<ConversionOperatorType>(SN); - } - return nullptr; - } - - return nullptr; -} - -// <ctor-dtor-name> ::= C1 # complete object constructor -// ::= C2 # base object constructor -// ::= C3 # complete object allocating constructor -// extension ::= C4 # gcc old-style "[unified]" constructor -// extension ::= C5 # the COMDAT used for ctors -// ::= D0 # deleting destructor -// ::= D1 # complete object destructor -// ::= D2 # base object destructor -// extension ::= D4 # gcc old-style "[unified]" destructor -// extension ::= D5 # the COMDAT used for dtors -template <typename Derived, typename Alloc> -Node * -AbstractManglingParser<Derived, Alloc>::parseCtorDtorName(Node *&SoFar, - NameState *State) { - if (SoFar->getKind() == Node::KSpecialSubstitution) { - // Expand the special substitution. - SoFar = make<ExpandedSpecialSubstitution>( - static_cast<SpecialSubstitution *>(SoFar)); - if (!SoFar) - return nullptr; - } - - if (consumeIf('C')) { - bool IsInherited = consumeIf('I'); - if (look() != '1' && look() != '2' && look() != '3' && look() != '4' && - look() != '5') - return nullptr; - int Variant = look() - '0'; - ++First; - if (State) State->CtorDtorConversion = true; - if (IsInherited) { - if (getDerived().parseName(State) == nullptr) - return nullptr; - } - return make<CtorDtorName>(SoFar, /*IsDtor=*/false, Variant); - } - - if (look() == 'D' && (look(1) == '0' || look(1) == '1' || look(1) == '2' || - look(1) == '4' || look(1) == '5')) { - int Variant = look(1) - '0'; - First += 2; - if (State) State->CtorDtorConversion = true; - return make<CtorDtorName>(SoFar, /*IsDtor=*/true, Variant); - } - - return nullptr; -} - -// <nested-name> ::= N [<CV-Qualifiers>] [<ref-qualifier>] <prefix> -// <unqualified-name> E -// ::= N [<CV-Qualifiers>] [<ref-qualifier>] <template-prefix> -// <template-args> E -// -// <prefix> ::= <prefix> <unqualified-name> -// ::= <template-prefix> <template-args> -// ::= <template-param> -// ::= <decltype> -// ::= # empty -// ::= <substitution> -// ::= <prefix> <data-member-prefix> -// [*] extension -// -// <data-member-prefix> := <member source-name> [<template-args>] M -// -// <template-prefix> ::= <prefix> <template unqualified-name> -// ::= <template-param> -// ::= <substitution> -template <typename Derived, typename Alloc> -Node * -AbstractManglingParser<Derived, Alloc>::parseNestedName(NameState *State) { - if (!consumeIf('N')) - return nullptr; - - Qualifiers CVTmp = parseCVQualifiers(); - if (State) State->CVQualifiers = CVTmp; - - if (consumeIf('O')) { - if (State) State->ReferenceQualifier = FrefQualRValue; - } else if (consumeIf('R')) { - if (State) State->ReferenceQualifier = FrefQualLValue; - } else { - if (State) State->ReferenceQualifier = FrefQualNone; - } - - Node *SoFar = nullptr; - while (!consumeIf('E')) { - if (State) - // Only set end-with-template on the case that does that. - State->EndsWithTemplateArgs = false; - - if (look() == 'T') { - // ::= <template-param> - if (SoFar != nullptr) - return nullptr; // Cannot have a prefix. - SoFar = getDerived().parseTemplateParam(); - } else if (look() == 'I') { - // ::= <template-prefix> <template-args> - if (SoFar == nullptr) - return nullptr; // Must have a prefix. - Node *TA = getDerived().parseTemplateArgs(State != nullptr); - if (TA == nullptr) - return nullptr; - if (SoFar->getKind() == Node::KNameWithTemplateArgs) - // Semantically <template-args> <template-args> cannot be generated by a - // C++ entity. There will always be [something like] a name between - // them. - return nullptr; - if (State) - State->EndsWithTemplateArgs = true; - SoFar = make<NameWithTemplateArgs>(SoFar, TA); - } else if (look() == 'D' && (look(1) == 't' || look(1) == 'T')) { - // ::= <decltype> - if (SoFar != nullptr) - return nullptr; // Cannot have a prefix. - SoFar = getDerived().parseDecltype(); - } else { - ModuleName *Module = nullptr; - - if (look() == 'S') { - // ::= <substitution> - Node *S = nullptr; - if (look(1) == 't') { - First += 2; - S = make<NameType>("std"); - } else { - S = getDerived().parseSubstitution(); - } - if (!S) - return nullptr; - if (S->getKind() == Node::KModuleName) { - Module = static_cast<ModuleName *>(S); - } else if (SoFar != nullptr) { - return nullptr; // Cannot have a prefix. - } else { - SoFar = S; - continue; // Do not push a new substitution. - } - } - - // ::= [<prefix>] <unqualified-name> - SoFar = getDerived().parseUnqualifiedName(State, SoFar, Module); - } - - if (SoFar == nullptr) - return nullptr; - Subs.push_back(SoFar); - - // No longer used. - // <data-member-prefix> := <member source-name> [<template-args>] M - consumeIf('M'); - } - - if (SoFar == nullptr || Subs.empty()) - return nullptr; - - Subs.pop_back(); - return SoFar; -} - -// <simple-id> ::= <source-name> [ <template-args> ] -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseSimpleId() { - Node *SN = getDerived().parseSourceName(/*NameState=*/nullptr); - if (SN == nullptr) - return nullptr; - if (look() == 'I') { - Node *TA = getDerived().parseTemplateArgs(); - if (TA == nullptr) - return nullptr; - return make<NameWithTemplateArgs>(SN, TA); - } - return SN; -} - -// <destructor-name> ::= <unresolved-type> # e.g., ~T or ~decltype(f()) -// ::= <simple-id> # e.g., ~A<2*N> -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseDestructorName() { - Node *Result; - if (std::isdigit(look())) - Result = getDerived().parseSimpleId(); - else - Result = getDerived().parseUnresolvedType(); - if (Result == nullptr) - return nullptr; - return make<DtorName>(Result); -} - -// <unresolved-type> ::= <template-param> -// ::= <decltype> -// ::= <substitution> -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseUnresolvedType() { - if (look() == 'T') { - Node *TP = getDerived().parseTemplateParam(); - if (TP == nullptr) - return nullptr; - Subs.push_back(TP); - return TP; - } - if (look() == 'D') { - Node *DT = getDerived().parseDecltype(); - if (DT == nullptr) - return nullptr; - Subs.push_back(DT); - return DT; - } - return getDerived().parseSubstitution(); -} - -// <base-unresolved-name> ::= <simple-id> # unresolved name -// extension ::= <operator-name> # unresolved operator-function-id -// extension ::= <operator-name> <template-args> # unresolved operator template-id -// ::= on <operator-name> # unresolved operator-function-id -// ::= on <operator-name> <template-args> # unresolved operator template-id -// ::= dn <destructor-name> # destructor or pseudo-destructor; -// # e.g. ~X or ~X<N-1> -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseBaseUnresolvedName() { - if (std::isdigit(look())) - return getDerived().parseSimpleId(); - - if (consumeIf("dn")) - return getDerived().parseDestructorName(); - - consumeIf("on"); - - Node *Oper = getDerived().parseOperatorName(/*NameState=*/nullptr); - if (Oper == nullptr) - return nullptr; - if (look() == 'I') { - Node *TA = getDerived().parseTemplateArgs(); - if (TA == nullptr) - return nullptr; - return make<NameWithTemplateArgs>(Oper, TA); - } - return Oper; -} - -// <unresolved-name> -// extension ::= srN <unresolved-type> [<template-args>] <unresolved-qualifier-level>* E <base-unresolved-name> -// ::= [gs] <base-unresolved-name> # x or (with "gs") ::x -// ::= [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name> -// # A::x, N::y, A<T>::z; "gs" means leading "::" -// [gs] has been parsed by caller. -// ::= sr <unresolved-type> <base-unresolved-name> # T::x / decltype(p)::x -// extension ::= sr <unresolved-type> <template-args> <base-unresolved-name> -// # T::N::x /decltype(p)::N::x -// (ignored) ::= srN <unresolved-type> <unresolved-qualifier-level>+ E <base-unresolved-name> -// -// <unresolved-qualifier-level> ::= <simple-id> -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseUnresolvedName(bool Global) { - Node *SoFar = nullptr; - - // srN <unresolved-type> [<template-args>] <unresolved-qualifier-level>* E <base-unresolved-name> - // srN <unresolved-type> <unresolved-qualifier-level>+ E <base-unresolved-name> - if (consumeIf("srN")) { - SoFar = getDerived().parseUnresolvedType(); - if (SoFar == nullptr) - return nullptr; - - if (look() == 'I') { - Node *TA = getDerived().parseTemplateArgs(); - if (TA == nullptr) - return nullptr; - SoFar = make<NameWithTemplateArgs>(SoFar, TA); - if (!SoFar) - return nullptr; - } - - while (!consumeIf('E')) { - Node *Qual = getDerived().parseSimpleId(); - if (Qual == nullptr) - return nullptr; - SoFar = make<QualifiedName>(SoFar, Qual); - if (!SoFar) - return nullptr; - } - - Node *Base = getDerived().parseBaseUnresolvedName(); - if (Base == nullptr) - return nullptr; - return make<QualifiedName>(SoFar, Base); - } - - // [gs] <base-unresolved-name> # x or (with "gs") ::x - if (!consumeIf("sr")) { - SoFar = getDerived().parseBaseUnresolvedName(); - if (SoFar == nullptr) - return nullptr; - if (Global) - SoFar = make<GlobalQualifiedName>(SoFar); - return SoFar; - } - - // [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name> - if (std::isdigit(look())) { - do { - Node *Qual = getDerived().parseSimpleId(); - if (Qual == nullptr) - return nullptr; - if (SoFar) - SoFar = make<QualifiedName>(SoFar, Qual); - else if (Global) - SoFar = make<GlobalQualifiedName>(Qual); - else - SoFar = Qual; - if (!SoFar) - return nullptr; - } while (!consumeIf('E')); - } - // sr <unresolved-type> <base-unresolved-name> - // sr <unresolved-type> <template-args> <base-unresolved-name> - else { - SoFar = getDerived().parseUnresolvedType(); - if (SoFar == nullptr) - return nullptr; - - if (look() == 'I') { - Node *TA = getDerived().parseTemplateArgs(); - if (TA == nullptr) - return nullptr; - SoFar = make<NameWithTemplateArgs>(SoFar, TA); - if (!SoFar) - return nullptr; - } - } - - assert(SoFar != nullptr); - - Node *Base = getDerived().parseBaseUnresolvedName(); - if (Base == nullptr) - return nullptr; - return make<QualifiedName>(SoFar, Base); -} - -// <abi-tags> ::= <abi-tag> [<abi-tags>] -// <abi-tag> ::= B <source-name> -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseAbiTags(Node *N) { - while (consumeIf('B')) { - StringView SN = parseBareSourceName(); - if (SN.empty()) - return nullptr; - N = make<AbiTagAttr>(N, SN); - if (!N) - return nullptr; - } - return N; -} - -// <number> ::= [n] <non-negative decimal integer> -template <typename Alloc, typename Derived> -StringView -AbstractManglingParser<Alloc, Derived>::parseNumber(bool AllowNegative) { - const char *Tmp = First; - if (AllowNegative) - consumeIf('n'); - if (numLeft() == 0 || !std::isdigit(*First)) - return StringView(); - while (numLeft() != 0 && std::isdigit(*First)) - ++First; - return StringView(Tmp, First); -} - -// <positive length number> ::= [0-9]* -template <typename Alloc, typename Derived> -bool AbstractManglingParser<Alloc, Derived>::parsePositiveInteger(size_t *Out) { - *Out = 0; - if (look() < '0' || look() > '9') - return true; - while (look() >= '0' && look() <= '9') { - *Out *= 10; - *Out += static_cast<size_t>(consume() - '0'); - } - return false; -} - -template <typename Alloc, typename Derived> -StringView AbstractManglingParser<Alloc, Derived>::parseBareSourceName() { - size_t Int = 0; - if (parsePositiveInteger(&Int) || numLeft() < Int) - return StringView(); - StringView R(First, First + Int); - First += Int; - return R; -} - -// <function-type> ::= [<CV-qualifiers>] [<exception-spec>] [Dx] F [Y] <bare-function-type> [<ref-qualifier>] E -// -// <exception-spec> ::= Do # non-throwing exception-specification (e.g., noexcept, throw()) -// ::= DO <expression> E # computed (instantiation-dependent) noexcept -// ::= Dw <type>+ E # dynamic exception specification with instantiation-dependent types -// -// <ref-qualifier> ::= R # & ref-qualifier -// <ref-qualifier> ::= O # && ref-qualifier -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseFunctionType() { - Qualifiers CVQuals = parseCVQualifiers(); - - Node *ExceptionSpec = nullptr; - if (consumeIf("Do")) { - ExceptionSpec = make<NameType>("noexcept"); - if (!ExceptionSpec) - return nullptr; - } else if (consumeIf("DO")) { - Node *E = getDerived().parseExpr(); - if (E == nullptr || !consumeIf('E')) - return nullptr; - ExceptionSpec = make<NoexceptSpec>(E); - if (!ExceptionSpec) - return nullptr; - } else if (consumeIf("Dw")) { - size_t SpecsBegin = Names.size(); - while (!consumeIf('E')) { - Node *T = getDerived().parseType(); - if (T == nullptr) - return nullptr; - Names.push_back(T); - } - ExceptionSpec = - make<DynamicExceptionSpec>(popTrailingNodeArray(SpecsBegin)); - if (!ExceptionSpec) - return nullptr; - } - - consumeIf("Dx"); // transaction safe - - if (!consumeIf('F')) - return nullptr; - consumeIf('Y'); // extern "C" - Node *ReturnType = getDerived().parseType(); - if (ReturnType == nullptr) - return nullptr; - - FunctionRefQual ReferenceQualifier = FrefQualNone; - size_t ParamsBegin = Names.size(); - while (true) { - if (consumeIf('E')) - break; - if (consumeIf('v')) - continue; - if (consumeIf("RE")) { - ReferenceQualifier = FrefQualLValue; - break; - } - if (consumeIf("OE")) { - ReferenceQualifier = FrefQualRValue; - break; - } - Node *T = getDerived().parseType(); - if (T == nullptr) - return nullptr; - Names.push_back(T); - } - - NodeArray Params = popTrailingNodeArray(ParamsBegin); - return make<FunctionType>(ReturnType, Params, CVQuals, - ReferenceQualifier, ExceptionSpec); -} - -// extension: -// <vector-type> ::= Dv <positive dimension number> _ <extended element type> -// ::= Dv [<dimension expression>] _ <element type> -// <extended element type> ::= <element type> -// ::= p # AltiVec vector pixel -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseVectorType() { - if (!consumeIf("Dv")) - return nullptr; - if (look() >= '1' && look() <= '9') { - Node *DimensionNumber = make<NameType>(parseNumber()); - if (!DimensionNumber) - return nullptr; - if (!consumeIf('_')) - return nullptr; - if (consumeIf('p')) - return make<PixelVectorType>(DimensionNumber); - Node *ElemType = getDerived().parseType(); - if (ElemType == nullptr) - return nullptr; - return make<VectorType>(ElemType, DimensionNumber); - } - - if (!consumeIf('_')) { - Node *DimExpr = getDerived().parseExpr(); - if (!DimExpr) - return nullptr; - if (!consumeIf('_')) - return nullptr; - Node *ElemType = getDerived().parseType(); - if (!ElemType) - return nullptr; - return make<VectorType>(ElemType, DimExpr); - } - Node *ElemType = getDerived().parseType(); - if (!ElemType) - return nullptr; - return make<VectorType>(ElemType, /*Dimension=*/nullptr); -} - -// <decltype> ::= Dt <expression> E # decltype of an id-expression or class member access (C++0x) -// ::= DT <expression> E # decltype of an expression (C++0x) -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseDecltype() { - if (!consumeIf('D')) - return nullptr; - if (!consumeIf('t') && !consumeIf('T')) - return nullptr; - Node *E = getDerived().parseExpr(); - if (E == nullptr) - return nullptr; - if (!consumeIf('E')) - return nullptr; - return make<EnclosingExpr>("decltype", E); -} - -// <array-type> ::= A <positive dimension number> _ <element type> -// ::= A [<dimension expression>] _ <element type> -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseArrayType() { - if (!consumeIf('A')) - return nullptr; - - Node *Dimension = nullptr; - - if (std::isdigit(look())) { - Dimension = make<NameType>(parseNumber()); - if (!Dimension) - return nullptr; - if (!consumeIf('_')) - return nullptr; - } else if (!consumeIf('_')) { - Node *DimExpr = getDerived().parseExpr(); - if (DimExpr == nullptr) - return nullptr; - if (!consumeIf('_')) - return nullptr; - Dimension = DimExpr; - } - - Node *Ty = getDerived().parseType(); - if (Ty == nullptr) - return nullptr; - return make<ArrayType>(Ty, Dimension); -} - -// <pointer-to-member-type> ::= M <class type> <member type> -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parsePointerToMemberType() { - if (!consumeIf('M')) - return nullptr; - Node *ClassType = getDerived().parseType(); - if (ClassType == nullptr) - return nullptr; - Node *MemberType = getDerived().parseType(); - if (MemberType == nullptr) - return nullptr; - return make<PointerToMemberType>(ClassType, MemberType); -} - -// <class-enum-type> ::= <name> # non-dependent type name, dependent type name, or dependent typename-specifier -// ::= Ts <name> # dependent elaborated type specifier using 'struct' or 'class' -// ::= Tu <name> # dependent elaborated type specifier using 'union' -// ::= Te <name> # dependent elaborated type specifier using 'enum' -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseClassEnumType() { - StringView ElabSpef; - if (consumeIf("Ts")) - ElabSpef = "struct"; - else if (consumeIf("Tu")) - ElabSpef = "union"; - else if (consumeIf("Te")) - ElabSpef = "enum"; - - Node *Name = getDerived().parseName(); - if (Name == nullptr) - return nullptr; - - if (!ElabSpef.empty()) - return make<ElaboratedTypeSpefType>(ElabSpef, Name); - - return Name; -} - -// <qualified-type> ::= <qualifiers> <type> -// <qualifiers> ::= <extended-qualifier>* <CV-qualifiers> -// <extended-qualifier> ::= U <source-name> [<template-args>] # vendor extended type qualifier -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseQualifiedType() { - if (consumeIf('U')) { - StringView Qual = parseBareSourceName(); - if (Qual.empty()) - return nullptr; - - // extension ::= U <objc-name> <objc-type> # objc-type<identifier> - if (Qual.startsWith("objcproto")) { - StringView ProtoSourceName = Qual.dropFront(std::strlen("objcproto")); - StringView Proto; - { - ScopedOverride<const char *> SaveFirst(First, ProtoSourceName.begin()), - SaveLast(Last, ProtoSourceName.end()); - Proto = parseBareSourceName(); - } - if (Proto.empty()) - return nullptr; - Node *Child = getDerived().parseQualifiedType(); - if (Child == nullptr) - return nullptr; - return make<ObjCProtoName>(Child, Proto); - } - - Node *TA = nullptr; - if (look() == 'I') { - TA = getDerived().parseTemplateArgs(); - if (TA == nullptr) - return nullptr; - } - - Node *Child = getDerived().parseQualifiedType(); - if (Child == nullptr) - return nullptr; - return make<VendorExtQualType>(Child, Qual, TA); - } - - Qualifiers Quals = parseCVQualifiers(); - Node *Ty = getDerived().parseType(); - if (Ty == nullptr) - return nullptr; - if (Quals != QualNone) - Ty = make<QualType>(Ty, Quals); - return Ty; -} - -// <type> ::= <builtin-type> -// ::= <qualified-type> -// ::= <function-type> -// ::= <class-enum-type> -// ::= <array-type> -// ::= <pointer-to-member-type> -// ::= <template-param> -// ::= <template-template-param> <template-args> -// ::= <decltype> -// ::= P <type> # pointer -// ::= R <type> # l-value reference -// ::= O <type> # r-value reference (C++11) -// ::= C <type> # complex pair (C99) -// ::= G <type> # imaginary (C99) -// ::= <substitution> # See Compression below -// extension ::= U <objc-name> <objc-type> # objc-type<identifier> -// extension ::= <vector-type> # <vector-type> starts with Dv -// -// <objc-name> ::= <k0 number> objcproto <k1 number> <identifier> # k0 = 9 + <number of digits in k1> + k1 -// <objc-type> ::= <source-name> # PU<11+>objcproto 11objc_object<source-name> 11objc_object -> id<source-name> -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseType() { - Node *Result = nullptr; - - switch (look()) { - // ::= <qualified-type> - case 'r': - case 'V': - case 'K': { - unsigned AfterQuals = 0; - if (look(AfterQuals) == 'r') ++AfterQuals; - if (look(AfterQuals) == 'V') ++AfterQuals; - if (look(AfterQuals) == 'K') ++AfterQuals; - - if (look(AfterQuals) == 'F' || - (look(AfterQuals) == 'D' && - (look(AfterQuals + 1) == 'o' || look(AfterQuals + 1) == 'O' || - look(AfterQuals + 1) == 'w' || look(AfterQuals + 1) == 'x'))) { - Result = getDerived().parseFunctionType(); - break; - } - DEMANGLE_FALLTHROUGH; - } - case 'U': { - Result = getDerived().parseQualifiedType(); - break; - } - // <builtin-type> ::= v # void - case 'v': - ++First; - return make<NameType>("void"); - // ::= w # wchar_t - case 'w': - ++First; - return make<NameType>("wchar_t"); - // ::= b # bool - case 'b': - ++First; - return make<NameType>("bool"); - // ::= c # char - case 'c': - ++First; - return make<NameType>("char"); - // ::= a # signed char - case 'a': - ++First; - return make<NameType>("signed char"); - // ::= h # unsigned char - case 'h': - ++First; - return make<NameType>("unsigned char"); - // ::= s # short - case 's': - ++First; - return make<NameType>("short"); - // ::= t # unsigned short - case 't': - ++First; - return make<NameType>("unsigned short"); - // ::= i # int - case 'i': - ++First; - return make<NameType>("int"); - // ::= j # unsigned int - case 'j': - ++First; - return make<NameType>("unsigned int"); - // ::= l # long - case 'l': - ++First; - return make<NameType>("long"); - // ::= m # unsigned long - case 'm': - ++First; - return make<NameType>("unsigned long"); - // ::= x # long long, __int64 - case 'x': - ++First; - return make<NameType>("long long"); - // ::= y # unsigned long long, __int64 - case 'y': - ++First; - return make<NameType>("unsigned long long"); - // ::= n # __int128 - case 'n': - ++First; - return make<NameType>("__int128"); - // ::= o # unsigned __int128 - case 'o': - ++First; - return make<NameType>("unsigned __int128"); - // ::= f # float - case 'f': - ++First; - return make<NameType>("float"); - // ::= d # double - case 'd': - ++First; - return make<NameType>("double"); - // ::= e # long double, __float80 - case 'e': - ++First; - return make<NameType>("long double"); - // ::= g # __float128 - case 'g': - ++First; - return make<NameType>("__float128"); - // ::= z # ellipsis - case 'z': - ++First; - return make<NameType>("..."); - - // <builtin-type> ::= u <source-name> # vendor extended type - case 'u': { - ++First; - StringView Res = parseBareSourceName(); - if (Res.empty()) - return nullptr; - // Typically, <builtin-type>s are not considered substitution candidates, - // but the exception to that exception is vendor extended types (Itanium C++ - // ABI 5.9.1). - Result = make<NameType>(Res); - break; - } - case 'D': - switch (look(1)) { - // ::= Dd # IEEE 754r decimal floating point (64 bits) - case 'd': - First += 2; - return make<NameType>("decimal64"); - // ::= De # IEEE 754r decimal floating point (128 bits) - case 'e': - First += 2; - return make<NameType>("decimal128"); - // ::= Df # IEEE 754r decimal floating point (32 bits) - case 'f': - First += 2; - return make<NameType>("decimal32"); - // ::= Dh # IEEE 754r half-precision floating point (16 bits) - case 'h': - First += 2; - return make<NameType>("half"); - // ::= DF <number> _ # ISO/IEC TS 18661 binary floating point (N bits) - case 'F': { - First += 2; - Node *DimensionNumber = make<NameType>(parseNumber()); - if (!DimensionNumber) - return nullptr; - if (!consumeIf('_')) - return nullptr; - return make<BinaryFPType>(DimensionNumber); - } - // ::= DB <number> _ # C23 signed _BitInt(N) - // ::= DB <instantiation-dependent expression> _ # C23 signed _BitInt(N) - // ::= DU <number> _ # C23 unsigned _BitInt(N) - // ::= DU <instantiation-dependent expression> _ # C23 unsigned _BitInt(N) - case 'B': - case 'U': { - bool Signed = look(1) == 'B'; - First += 2; - Node *Size = std::isdigit(look()) ? make<NameType>(parseNumber()) - : getDerived().parseExpr(); - if (!Size) - return nullptr; - if (!consumeIf('_')) - return nullptr; - return make<BitIntType>(Size, Signed); - } - // ::= Di # char32_t - case 'i': - First += 2; - return make<NameType>("char32_t"); - // ::= Ds # char16_t - case 's': - First += 2; - return make<NameType>("char16_t"); - // ::= Du # char8_t (C++2a, not yet in the Itanium spec) - case 'u': - First += 2; - return make<NameType>("char8_t"); - // ::= Da # auto (in dependent new-expressions) - case 'a': - First += 2; - return make<NameType>("auto"); - // ::= Dc # decltype(auto) - case 'c': - First += 2; - return make<NameType>("decltype(auto)"); - // ::= Dn # std::nullptr_t (i.e., decltype(nullptr)) - case 'n': - First += 2; - return make<NameType>("std::nullptr_t"); - - // ::= <decltype> - case 't': - case 'T': { - Result = getDerived().parseDecltype(); - break; - } - // extension ::= <vector-type> # <vector-type> starts with Dv - case 'v': { - Result = getDerived().parseVectorType(); - break; - } - // ::= Dp <type> # pack expansion (C++0x) - case 'p': { - First += 2; - Node *Child = getDerived().parseType(); - if (!Child) - return nullptr; - Result = make<ParameterPackExpansion>(Child); - break; - } - // Exception specifier on a function type. - case 'o': - case 'O': - case 'w': - // Transaction safe function type. - case 'x': - Result = getDerived().parseFunctionType(); - break; - } - break; - // ::= <function-type> - case 'F': { - Result = getDerived().parseFunctionType(); - break; - } - // ::= <array-type> - case 'A': { - Result = getDerived().parseArrayType(); - break; - } - // ::= <pointer-to-member-type> - case 'M': { - Result = getDerived().parsePointerToMemberType(); - break; - } - // ::= <template-param> - case 'T': { - // This could be an elaborate type specifier on a <class-enum-type>. - if (look(1) == 's' || look(1) == 'u' || look(1) == 'e') { - Result = getDerived().parseClassEnumType(); - break; - } - - Result = getDerived().parseTemplateParam(); - if (Result == nullptr) - return nullptr; - - // Result could be either of: - // <type> ::= <template-param> - // <type> ::= <template-template-param> <template-args> - // - // <template-template-param> ::= <template-param> - // ::= <substitution> - // - // If this is followed by some <template-args>, and we're permitted to - // parse them, take the second production. - - if (TryToParseTemplateArgs && look() == 'I') { - Node *TA = getDerived().parseTemplateArgs(); - if (TA == nullptr) - return nullptr; - Result = make<NameWithTemplateArgs>(Result, TA); - } - break; - } - // ::= P <type> # pointer - case 'P': { - ++First; - Node *Ptr = getDerived().parseType(); - if (Ptr == nullptr) - return nullptr; - Result = make<PointerType>(Ptr); - break; - } - // ::= R <type> # l-value reference - case 'R': { - ++First; - Node *Ref = getDerived().parseType(); - if (Ref == nullptr) - return nullptr; - Result = make<ReferenceType>(Ref, ReferenceKind::LValue); - break; - } - // ::= O <type> # r-value reference (C++11) - case 'O': { - ++First; - Node *Ref = getDerived().parseType(); - if (Ref == nullptr) - return nullptr; - Result = make<ReferenceType>(Ref, ReferenceKind::RValue); - break; - } - // ::= C <type> # complex pair (C99) - case 'C': { - ++First; - Node *P = getDerived().parseType(); - if (P == nullptr) - return nullptr; - Result = make<PostfixQualifiedType>(P, " complex"); - break; - } - // ::= G <type> # imaginary (C99) - case 'G': { - ++First; - Node *P = getDerived().parseType(); - if (P == nullptr) - return P; - Result = make<PostfixQualifiedType>(P, " imaginary"); - break; - } - // ::= <substitution> # See Compression below - case 'S': { - if (look(1) != 't') { - bool IsSubst = false; - Result = getDerived().parseUnscopedName(nullptr, &IsSubst); - if (!Result) - return nullptr; - - // Sub could be either of: - // <type> ::= <substitution> - // <type> ::= <template-template-param> <template-args> - // - // <template-template-param> ::= <template-param> - // ::= <substitution> - // - // If this is followed by some <template-args>, and we're permitted to - // parse them, take the second production. - - if (look() == 'I' && (!IsSubst || TryToParseTemplateArgs)) { - if (!IsSubst) - Subs.push_back(Result); - Node *TA = getDerived().parseTemplateArgs(); - if (TA == nullptr) - return nullptr; - Result = make<NameWithTemplateArgs>(Result, TA); - } else if (IsSubst) { - // If all we parsed was a substitution, don't re-insert into the - // substitution table. - return Result; - } - break; - } - DEMANGLE_FALLTHROUGH; - } - // ::= <class-enum-type> - default: { - Result = getDerived().parseClassEnumType(); - break; - } - } - - // If we parsed a type, insert it into the substitution table. Note that all - // <builtin-type>s and <substitution>s have already bailed out, because they - // don't get substitutions. - if (Result != nullptr) - Subs.push_back(Result); - return Result; -} - -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parsePrefixExpr(StringView Kind, - Node::Prec Prec) { - Node *E = getDerived().parseExpr(); - if (E == nullptr) - return nullptr; - return make<PrefixExpr>(Kind, E, Prec); -} - -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseBinaryExpr(StringView Kind, - Node::Prec Prec) { - Node *LHS = getDerived().parseExpr(); - if (LHS == nullptr) - return nullptr; - Node *RHS = getDerived().parseExpr(); - if (RHS == nullptr) - return nullptr; - return make<BinaryExpr>(LHS, Kind, RHS, Prec); -} - -template <typename Derived, typename Alloc> -Node * -AbstractManglingParser<Derived, Alloc>::parseIntegerLiteral(StringView Lit) { - StringView Tmp = parseNumber(true); - if (!Tmp.empty() && consumeIf('E')) - return make<IntegerLiteral>(Lit, Tmp); - return nullptr; -} - -// <CV-Qualifiers> ::= [r] [V] [K] -template <typename Alloc, typename Derived> -Qualifiers AbstractManglingParser<Alloc, Derived>::parseCVQualifiers() { - Qualifiers CVR = QualNone; - if (consumeIf('r')) - CVR |= QualRestrict; - if (consumeIf('V')) - CVR |= QualVolatile; - if (consumeIf('K')) - CVR |= QualConst; - return CVR; -} - -// <function-param> ::= fp <top-level CV-Qualifiers> _ # L == 0, first parameter -// ::= fp <top-level CV-Qualifiers> <parameter-2 non-negative number> _ # L == 0, second and later parameters -// ::= fL <L-1 non-negative number> p <top-level CV-Qualifiers> _ # L > 0, first parameter -// ::= fL <L-1 non-negative number> p <top-level CV-Qualifiers> <parameter-2 non-negative number> _ # L > 0, second and later parameters -// ::= fpT # 'this' expression (not part of standard?) -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseFunctionParam() { - if (consumeIf("fpT")) - return make<NameType>("this"); - if (consumeIf("fp")) { - parseCVQualifiers(); - StringView Num = parseNumber(); - if (!consumeIf('_')) - return nullptr; - return make<FunctionParam>(Num); - } - if (consumeIf("fL")) { - if (parseNumber().empty()) - return nullptr; - if (!consumeIf('p')) - return nullptr; - parseCVQualifiers(); - StringView Num = parseNumber(); - if (!consumeIf('_')) - return nullptr; - return make<FunctionParam>(Num); - } - return nullptr; -} - -// cv <type> <expression> # conversion with one argument -// cv <type> _ <expression>* E # conversion with a different number of arguments -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseConversionExpr() { - if (!consumeIf("cv")) - return nullptr; - Node *Ty; - { - ScopedOverride<bool> SaveTemp(TryToParseTemplateArgs, false); - Ty = getDerived().parseType(); - } - - if (Ty == nullptr) - return nullptr; - - if (consumeIf('_')) { - size_t ExprsBegin = Names.size(); - while (!consumeIf('E')) { - Node *E = getDerived().parseExpr(); - if (E == nullptr) - return E; - Names.push_back(E); - } - NodeArray Exprs = popTrailingNodeArray(ExprsBegin); - return make<ConversionExpr>(Ty, Exprs); - } - - Node *E[1] = {getDerived().parseExpr()}; - if (E[0] == nullptr) - return nullptr; - return make<ConversionExpr>(Ty, makeNodeArray(E, E + 1)); -} - -// <expr-primary> ::= L <type> <value number> E # integer literal -// ::= L <type> <value float> E # floating literal -// ::= L <string type> E # string literal -// ::= L <nullptr type> E # nullptr literal (i.e., "LDnE") -// ::= L <lambda type> E # lambda expression -// FIXME: ::= L <type> <real-part float> _ <imag-part float> E # complex floating point literal (C 2000) -// ::= L <mangled-name> E # external name -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseExprPrimary() { - if (!consumeIf('L')) - return nullptr; - switch (look()) { - case 'w': - ++First; - return getDerived().parseIntegerLiteral("wchar_t"); - case 'b': - if (consumeIf("b0E")) - return make<BoolExpr>(0); - if (consumeIf("b1E")) - return make<BoolExpr>(1); - return nullptr; - case 'c': - ++First; - return getDerived().parseIntegerLiteral("char"); - case 'a': - ++First; - return getDerived().parseIntegerLiteral("signed char"); - case 'h': - ++First; - return getDerived().parseIntegerLiteral("unsigned char"); - case 's': - ++First; - return getDerived().parseIntegerLiteral("short"); - case 't': - ++First; - return getDerived().parseIntegerLiteral("unsigned short"); - case 'i': - ++First; - return getDerived().parseIntegerLiteral(""); - case 'j': - ++First; - return getDerived().parseIntegerLiteral("u"); - case 'l': - ++First; - return getDerived().parseIntegerLiteral("l"); - case 'm': - ++First; - return getDerived().parseIntegerLiteral("ul"); - case 'x': - ++First; - return getDerived().parseIntegerLiteral("ll"); - case 'y': - ++First; - return getDerived().parseIntegerLiteral("ull"); - case 'n': - ++First; - return getDerived().parseIntegerLiteral("__int128"); - case 'o': - ++First; - return getDerived().parseIntegerLiteral("unsigned __int128"); - case 'f': - ++First; - return getDerived().template parseFloatingLiteral<float>(); - case 'd': - ++First; - return getDerived().template parseFloatingLiteral<double>(); - case 'e': - ++First; -#if defined(__powerpc__) || defined(__s390__) - // Handle cases where long doubles encoded with e have the same size - // and representation as doubles. - return getDerived().template parseFloatingLiteral<double>(); -#else - return getDerived().template parseFloatingLiteral<long double>(); -#endif - case '_': - if (consumeIf("_Z")) { - Node *R = getDerived().parseEncoding(); - if (R != nullptr && consumeIf('E')) - return R; - } - return nullptr; - case 'A': { - Node *T = getDerived().parseType(); - if (T == nullptr) - return nullptr; - // FIXME: We need to include the string contents in the mangling. - if (consumeIf('E')) - return make<StringLiteral>(T); - return nullptr; - } - case 'D': - if (consumeIf("Dn") && (consumeIf('0'), consumeIf('E'))) - return make<NameType>("nullptr"); - return nullptr; - case 'T': - // Invalid mangled name per - // http://sourcerytools.com/pipermail/cxx-abi-dev/2011-August/002422.html - return nullptr; - case 'U': { - // FIXME: Should we support LUb... for block literals? - if (look(1) != 'l') - return nullptr; - Node *T = parseUnnamedTypeName(nullptr); - if (!T || !consumeIf('E')) - return nullptr; - return make<LambdaExpr>(T); - } - default: { - // might be named type - Node *T = getDerived().parseType(); - if (T == nullptr) - return nullptr; - StringView N = parseNumber(/*AllowNegative=*/true); - if (N.empty()) - return nullptr; - if (!consumeIf('E')) - return nullptr; - return make<EnumLiteral>(T, N); - } - } -} - -// <braced-expression> ::= <expression> -// ::= di <field source-name> <braced-expression> # .name = expr -// ::= dx <index expression> <braced-expression> # [expr] = expr -// ::= dX <range begin expression> <range end expression> <braced-expression> -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseBracedExpr() { - if (look() == 'd') { - switch (look(1)) { - case 'i': { - First += 2; - Node *Field = getDerived().parseSourceName(/*NameState=*/nullptr); - if (Field == nullptr) - return nullptr; - Node *Init = getDerived().parseBracedExpr(); - if (Init == nullptr) - return nullptr; - return make<BracedExpr>(Field, Init, /*isArray=*/false); - } - case 'x': { - First += 2; - Node *Index = getDerived().parseExpr(); - if (Index == nullptr) - return nullptr; - Node *Init = getDerived().parseBracedExpr(); - if (Init == nullptr) - return nullptr; - return make<BracedExpr>(Index, Init, /*isArray=*/true); - } - case 'X': { - First += 2; - Node *RangeBegin = getDerived().parseExpr(); - if (RangeBegin == nullptr) - return nullptr; - Node *RangeEnd = getDerived().parseExpr(); - if (RangeEnd == nullptr) - return nullptr; - Node *Init = getDerived().parseBracedExpr(); - if (Init == nullptr) - return nullptr; - return make<BracedRangeExpr>(RangeBegin, RangeEnd, Init); - } - } - } - return getDerived().parseExpr(); -} - -// (not yet in the spec) -// <fold-expr> ::= fL <binary-operator-name> <expression> <expression> -// ::= fR <binary-operator-name> <expression> <expression> -// ::= fl <binary-operator-name> <expression> -// ::= fr <binary-operator-name> <expression> -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseFoldExpr() { - if (!consumeIf('f')) - return nullptr; - - bool IsLeftFold = false, HasInitializer = false; - switch (look()) { - default: - return nullptr; - case 'L': - IsLeftFold = true; - HasInitializer = true; - break; - case 'R': - HasInitializer = true; - break; - case 'l': - IsLeftFold = true; - break; - case 'r': - break; - } - ++First; - - const auto *Op = parseOperatorEncoding(); - if (!Op) - return nullptr; - if (!(Op->getKind() == OperatorInfo::Binary - || (Op->getKind() == OperatorInfo::Member - && Op->getName().back() == '*'))) - return nullptr; - - Node *Pack = getDerived().parseExpr(); - if (Pack == nullptr) - return nullptr; - - Node *Init = nullptr; - if (HasInitializer) { - Init = getDerived().parseExpr(); - if (Init == nullptr) - return nullptr; - } - - if (IsLeftFold && Init) - std::swap(Pack, Init); - - return make<FoldExpr>(IsLeftFold, Op->getSymbol(), Pack, Init); -} - -// <expression> ::= mc <parameter type> <expr> [<offset number>] E -// -// Not yet in the spec: https://github.com/itanium-cxx-abi/cxx-abi/issues/47 -template <typename Derived, typename Alloc> -Node * -AbstractManglingParser<Derived, Alloc>::parsePointerToMemberConversionExpr( - Node::Prec Prec) { - Node *Ty = getDerived().parseType(); - if (!Ty) - return nullptr; - Node *Expr = getDerived().parseExpr(); - if (!Expr) - return nullptr; - StringView Offset = getDerived().parseNumber(true); - if (!consumeIf('E')) - return nullptr; - return make<PointerToMemberConversionExpr>(Ty, Expr, Offset, Prec); -} - -// <expression> ::= so <referent type> <expr> [<offset number>] <union-selector>* [p] E -// <union-selector> ::= _ [<number>] -// -// Not yet in the spec: https://github.com/itanium-cxx-abi/cxx-abi/issues/47 -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseSubobjectExpr() { - Node *Ty = getDerived().parseType(); - if (!Ty) - return nullptr; - Node *Expr = getDerived().parseExpr(); - if (!Expr) - return nullptr; - StringView Offset = getDerived().parseNumber(true); - size_t SelectorsBegin = Names.size(); - while (consumeIf('_')) { - Node *Selector = make<NameType>(parseNumber()); - if (!Selector) - return nullptr; - Names.push_back(Selector); - } - bool OnePastTheEnd = consumeIf('p'); - if (!consumeIf('E')) - return nullptr; - return make<SubobjectExpr>( - Ty, Expr, Offset, popTrailingNodeArray(SelectorsBegin), OnePastTheEnd); -} - -// <expression> ::= <unary operator-name> <expression> -// ::= <binary operator-name> <expression> <expression> -// ::= <ternary operator-name> <expression> <expression> <expression> -// ::= cl <expression>+ E # call -// ::= cv <type> <expression> # conversion with one argument -// ::= cv <type> _ <expression>* E # conversion with a different number of arguments -// ::= [gs] nw <expression>* _ <type> E # new (expr-list) type -// ::= [gs] nw <expression>* _ <type> <initializer> # new (expr-list) type (init) -// ::= [gs] na <expression>* _ <type> E # new[] (expr-list) type -// ::= [gs] na <expression>* _ <type> <initializer> # new[] (expr-list) type (init) -// ::= [gs] dl <expression> # delete expression -// ::= [gs] da <expression> # delete[] expression -// ::= pp_ <expression> # prefix ++ -// ::= mm_ <expression> # prefix -- -// ::= ti <type> # typeid (type) -// ::= te <expression> # typeid (expression) -// ::= dc <type> <expression> # dynamic_cast<type> (expression) -// ::= sc <type> <expression> # static_cast<type> (expression) -// ::= cc <type> <expression> # const_cast<type> (expression) -// ::= rc <type> <expression> # reinterpret_cast<type> (expression) -// ::= st <type> # sizeof (a type) -// ::= sz <expression> # sizeof (an expression) -// ::= at <type> # alignof (a type) -// ::= az <expression> # alignof (an expression) -// ::= nx <expression> # noexcept (expression) -// ::= <template-param> -// ::= <function-param> -// ::= dt <expression> <unresolved-name> # expr.name -// ::= pt <expression> <unresolved-name> # expr->name -// ::= ds <expression> <expression> # expr.*expr -// ::= sZ <template-param> # size of a parameter pack -// ::= sZ <function-param> # size of a function parameter pack -// ::= sP <template-arg>* E # sizeof...(T), size of a captured template parameter pack from an alias template -// ::= sp <expression> # pack expansion -// ::= tw <expression> # throw expression -// ::= tr # throw with no operand (rethrow) -// ::= <unresolved-name> # f(p), N::f(p), ::f(p), -// # freestanding dependent name (e.g., T::x), -// # objectless nonstatic member reference -// ::= fL <binary-operator-name> <expression> <expression> -// ::= fR <binary-operator-name> <expression> <expression> -// ::= fl <binary-operator-name> <expression> -// ::= fr <binary-operator-name> <expression> -// ::= <expr-primary> -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseExpr() { - bool Global = consumeIf("gs"); - - const auto *Op = parseOperatorEncoding(); - if (Op) { - auto Sym = Op->getSymbol(); - switch (Op->getKind()) { - case OperatorInfo::Binary: - // Binary operator: lhs @ rhs - return getDerived().parseBinaryExpr(Sym, Op->getPrecedence()); - case OperatorInfo::Prefix: - // Prefix unary operator: @ expr - return getDerived().parsePrefixExpr(Sym, Op->getPrecedence()); - case OperatorInfo::Postfix: { - // Postfix unary operator: expr @ - if (consumeIf('_')) - return getDerived().parsePrefixExpr(Sym, Op->getPrecedence()); - Node *Ex = getDerived().parseExpr(); - if (Ex == nullptr) - return nullptr; - return make<PostfixExpr>(Ex, Sym, Op->getPrecedence()); - } - case OperatorInfo::Array: { - // Array Index: lhs [ rhs ] - Node *Base = getDerived().parseExpr(); - if (Base == nullptr) - return nullptr; - Node *Index = getDerived().parseExpr(); - if (Index == nullptr) - return nullptr; - return make<ArraySubscriptExpr>(Base, Index, Op->getPrecedence()); - } - case OperatorInfo::Member: { - // Member access lhs @ rhs - Node *LHS = getDerived().parseExpr(); - if (LHS == nullptr) - return nullptr; - Node *RHS = getDerived().parseExpr(); - if (RHS == nullptr) - return nullptr; - return make<MemberExpr>(LHS, Sym, RHS, Op->getPrecedence()); - } - case OperatorInfo::New: { - // New - // # new (expr-list) type [(init)] - // [gs] nw <expression>* _ <type> [pi <expression>*] E - // # new[] (expr-list) type [(init)] - // [gs] na <expression>* _ <type> [pi <expression>*] E - size_t Exprs = Names.size(); - while (!consumeIf('_')) { - Node *Ex = getDerived().parseExpr(); - if (Ex == nullptr) - return nullptr; - Names.push_back(Ex); - } - NodeArray ExprList = popTrailingNodeArray(Exprs); - Node *Ty = getDerived().parseType(); - if (Ty == nullptr) - return nullptr; - bool HaveInits = consumeIf("pi"); - size_t InitsBegin = Names.size(); - while (!consumeIf('E')) { - if (!HaveInits) - return nullptr; - Node *Init = getDerived().parseExpr(); - if (Init == nullptr) - return Init; - Names.push_back(Init); - } - NodeArray Inits = popTrailingNodeArray(InitsBegin); - return make<NewExpr>(ExprList, Ty, Inits, Global, - /*IsArray=*/Op->getFlag(), Op->getPrecedence()); - } - case OperatorInfo::Del: { - // Delete - Node *Ex = getDerived().parseExpr(); - if (Ex == nullptr) - return nullptr; - return make<DeleteExpr>(Ex, Global, /*IsArray=*/Op->getFlag(), - Op->getPrecedence()); - } - case OperatorInfo::Call: { - // Function Call - Node *Callee = getDerived().parseExpr(); - if (Callee == nullptr) - return nullptr; - size_t ExprsBegin = Names.size(); - while (!consumeIf('E')) { - Node *E = getDerived().parseExpr(); - if (E == nullptr) - return nullptr; - Names.push_back(E); - } - return make<CallExpr>(Callee, popTrailingNodeArray(ExprsBegin), - Op->getPrecedence()); - } - case OperatorInfo::CCast: { - // C Cast: (type)expr - Node *Ty; - { - ScopedOverride<bool> SaveTemp(TryToParseTemplateArgs, false); - Ty = getDerived().parseType(); - } - if (Ty == nullptr) - return nullptr; - - size_t ExprsBegin = Names.size(); - bool IsMany = consumeIf('_'); - while (!consumeIf('E')) { - Node *E = getDerived().parseExpr(); - if (E == nullptr) - return E; - Names.push_back(E); - if (!IsMany) - break; - } - NodeArray Exprs = popTrailingNodeArray(ExprsBegin); - if (!IsMany && Exprs.size() != 1) - return nullptr; - return make<ConversionExpr>(Ty, Exprs, Op->getPrecedence()); - } - case OperatorInfo::Conditional: { - // Conditional operator: expr ? expr : expr - Node *Cond = getDerived().parseExpr(); - if (Cond == nullptr) - return nullptr; - Node *LHS = getDerived().parseExpr(); - if (LHS == nullptr) - return nullptr; - Node *RHS = getDerived().parseExpr(); - if (RHS == nullptr) - return nullptr; - return make<ConditionalExpr>(Cond, LHS, RHS, Op->getPrecedence()); - } - case OperatorInfo::NamedCast: { - // Named cast operation, @<type>(expr) - Node *Ty = getDerived().parseType(); - if (Ty == nullptr) - return nullptr; - Node *Ex = getDerived().parseExpr(); - if (Ex == nullptr) - return nullptr; - return make<CastExpr>(Sym, Ty, Ex, Op->getPrecedence()); - } - case OperatorInfo::OfIdOp: { - // [sizeof/alignof/typeid] ( <type>|<expr> ) - Node *Arg = - Op->getFlag() ? getDerived().parseType() : getDerived().parseExpr(); - if (!Arg) - return nullptr; - return make<EnclosingExpr>(Sym, Arg, Op->getPrecedence()); - } - case OperatorInfo::NameOnly: { - // Not valid as an expression operand. - return nullptr; - } - } - DEMANGLE_UNREACHABLE; - } - - if (numLeft() < 2) - return nullptr; - - if (look() == 'L') - return getDerived().parseExprPrimary(); - if (look() == 'T') - return getDerived().parseTemplateParam(); - if (look() == 'f') { - // Disambiguate a fold expression from a <function-param>. - if (look(1) == 'p' || (look(1) == 'L' && std::isdigit(look(2)))) - return getDerived().parseFunctionParam(); - return getDerived().parseFoldExpr(); - } - if (consumeIf("il")) { - size_t InitsBegin = Names.size(); - while (!consumeIf('E')) { - Node *E = getDerived().parseBracedExpr(); - if (E == nullptr) - return nullptr; - Names.push_back(E); - } - return make<InitListExpr>(nullptr, popTrailingNodeArray(InitsBegin)); - } - if (consumeIf("mc")) - return parsePointerToMemberConversionExpr(Node::Prec::Unary); - if (consumeIf("nx")) { - Node *Ex = getDerived().parseExpr(); - if (Ex == nullptr) - return Ex; - return make<EnclosingExpr>("noexcept ", Ex, Node::Prec::Unary); - } - if (consumeIf("so")) - return parseSubobjectExpr(); - if (consumeIf("sp")) { - Node *Child = getDerived().parseExpr(); - if (Child == nullptr) - return nullptr; - return make<ParameterPackExpansion>(Child); - } - if (consumeIf("sZ")) { - if (look() == 'T') { - Node *R = getDerived().parseTemplateParam(); - if (R == nullptr) - return nullptr; - return make<SizeofParamPackExpr>(R); - } - Node *FP = getDerived().parseFunctionParam(); - if (FP == nullptr) - return nullptr; - return make<EnclosingExpr>("sizeof... ", FP); - } - if (consumeIf("sP")) { - size_t ArgsBegin = Names.size(); - while (!consumeIf('E')) { - Node *Arg = getDerived().parseTemplateArg(); - if (Arg == nullptr) - return nullptr; - Names.push_back(Arg); - } - auto *Pack = make<NodeArrayNode>(popTrailingNodeArray(ArgsBegin)); - if (!Pack) - return nullptr; - return make<EnclosingExpr>("sizeof... ", Pack); - } - if (consumeIf("tl")) { - Node *Ty = getDerived().parseType(); - if (Ty == nullptr) - return nullptr; - size_t InitsBegin = Names.size(); - while (!consumeIf('E')) { - Node *E = getDerived().parseBracedExpr(); - if (E == nullptr) - return nullptr; - Names.push_back(E); - } - return make<InitListExpr>(Ty, popTrailingNodeArray(InitsBegin)); - } - if (consumeIf("tr")) - return make<NameType>("throw"); - if (consumeIf("tw")) { - Node *Ex = getDerived().parseExpr(); - if (Ex == nullptr) - return nullptr; - return make<ThrowExpr>(Ex); - } - if (consumeIf('u')) { - Node *Name = getDerived().parseSourceName(/*NameState=*/nullptr); - if (!Name) - return nullptr; - // Special case legacy __uuidof mangling. The 't' and 'z' appear where the - // standard encoding expects a <template-arg>, and would be otherwise be - // interpreted as <type> node 'short' or 'ellipsis'. However, neither - // __uuidof(short) nor __uuidof(...) can actually appear, so there is no - // actual conflict here. - bool IsUUID = false; - Node *UUID = nullptr; - if (Name->getBaseName() == "__uuidof") { - if (consumeIf('t')) { - UUID = getDerived().parseType(); - IsUUID = true; - } else if (consumeIf('z')) { - UUID = getDerived().parseExpr(); - IsUUID = true; - } - } - size_t ExprsBegin = Names.size(); - if (IsUUID) { - if (UUID == nullptr) - return nullptr; - Names.push_back(UUID); - } else { - while (!consumeIf('E')) { - Node *E = getDerived().parseTemplateArg(); - if (E == nullptr) - return E; - Names.push_back(E); - } - } - return make<CallExpr>(Name, popTrailingNodeArray(ExprsBegin), - Node::Prec::Postfix); - } - - // Only unresolved names remain. - return getDerived().parseUnresolvedName(Global); -} - -// <call-offset> ::= h <nv-offset> _ -// ::= v <v-offset> _ -// -// <nv-offset> ::= <offset number> -// # non-virtual base override -// -// <v-offset> ::= <offset number> _ <virtual offset number> -// # virtual base override, with vcall offset -template <typename Alloc, typename Derived> -bool AbstractManglingParser<Alloc, Derived>::parseCallOffset() { - // Just scan through the call offset, we never add this information into the - // output. - if (consumeIf('h')) - return parseNumber(true).empty() || !consumeIf('_'); - if (consumeIf('v')) - return parseNumber(true).empty() || !consumeIf('_') || - parseNumber(true).empty() || !consumeIf('_'); - return true; -} - -// <special-name> ::= TV <type> # virtual table -// ::= TT <type> # VTT structure (construction vtable index) -// ::= TI <type> # typeinfo structure -// ::= TS <type> # typeinfo name (null-terminated byte string) -// ::= Tc <call-offset> <call-offset> <base encoding> -// # base is the nominal target function of thunk -// # first call-offset is 'this' adjustment -// # second call-offset is result adjustment -// ::= T <call-offset> <base encoding> -// # base is the nominal target function of thunk -// # Guard variable for one-time initialization -// ::= GV <object name> -// # No <type> -// ::= TW <object name> # Thread-local wrapper -// ::= TH <object name> # Thread-local initialization -// ::= GR <object name> _ # First temporary -// ::= GR <object name> <seq-id> _ # Subsequent temporaries -// # construction vtable for second-in-first -// extension ::= TC <first type> <number> _ <second type> -// extension ::= GR <object name> # reference temporary for object -// extension ::= GI <module name> # module global initializer -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseSpecialName() { - switch (look()) { - case 'T': - switch (look(1)) { - // TA <template-arg> # template parameter object - // - // Not yet in the spec: https://github.com/itanium-cxx-abi/cxx-abi/issues/63 - case 'A': { - First += 2; - Node *Arg = getDerived().parseTemplateArg(); - if (Arg == nullptr) - return nullptr; - return make<SpecialName>("template parameter object for ", Arg); - } - // TV <type> # virtual table - case 'V': { - First += 2; - Node *Ty = getDerived().parseType(); - if (Ty == nullptr) - return nullptr; - return make<SpecialName>("vtable for ", Ty); - } - // TT <type> # VTT structure (construction vtable index) - case 'T': { - First += 2; - Node *Ty = getDerived().parseType(); - if (Ty == nullptr) - return nullptr; - return make<SpecialName>("VTT for ", Ty); - } - // TI <type> # typeinfo structure - case 'I': { - First += 2; - Node *Ty = getDerived().parseType(); - if (Ty == nullptr) - return nullptr; - return make<SpecialName>("typeinfo for ", Ty); - } - // TS <type> # typeinfo name (null-terminated byte string) - case 'S': { - First += 2; - Node *Ty = getDerived().parseType(); - if (Ty == nullptr) - return nullptr; - return make<SpecialName>("typeinfo name for ", Ty); - } - // Tc <call-offset> <call-offset> <base encoding> - case 'c': { - First += 2; - if (parseCallOffset() || parseCallOffset()) - return nullptr; - Node *Encoding = getDerived().parseEncoding(); - if (Encoding == nullptr) - return nullptr; - return make<SpecialName>("covariant return thunk to ", Encoding); - } - // extension ::= TC <first type> <number> _ <second type> - // # construction vtable for second-in-first - case 'C': { - First += 2; - Node *FirstType = getDerived().parseType(); - if (FirstType == nullptr) - return nullptr; - if (parseNumber(true).empty() || !consumeIf('_')) - return nullptr; - Node *SecondType = getDerived().parseType(); - if (SecondType == nullptr) - return nullptr; - return make<CtorVtableSpecialName>(SecondType, FirstType); - } - // TW <object name> # Thread-local wrapper - case 'W': { - First += 2; - Node *Name = getDerived().parseName(); - if (Name == nullptr) - return nullptr; - return make<SpecialName>("thread-local wrapper routine for ", Name); - } - // TH <object name> # Thread-local initialization - case 'H': { - First += 2; - Node *Name = getDerived().parseName(); - if (Name == nullptr) - return nullptr; - return make<SpecialName>("thread-local initialization routine for ", Name); - } - // T <call-offset> <base encoding> - default: { - ++First; - bool IsVirt = look() == 'v'; - if (parseCallOffset()) - return nullptr; - Node *BaseEncoding = getDerived().parseEncoding(); - if (BaseEncoding == nullptr) - return nullptr; - if (IsVirt) - return make<SpecialName>("virtual thunk to ", BaseEncoding); - else - return make<SpecialName>("non-virtual thunk to ", BaseEncoding); - } - } - case 'G': - switch (look(1)) { - // GV <object name> # Guard variable for one-time initialization - case 'V': { - First += 2; - Node *Name = getDerived().parseName(); - if (Name == nullptr) - return nullptr; - return make<SpecialName>("guard variable for ", Name); - } - // GR <object name> # reference temporary for object - // GR <object name> _ # First temporary - // GR <object name> <seq-id> _ # Subsequent temporaries - case 'R': { - First += 2; - Node *Name = getDerived().parseName(); - if (Name == nullptr) - return nullptr; - size_t Count; - bool ParsedSeqId = !parseSeqId(&Count); - if (!consumeIf('_') && ParsedSeqId) - return nullptr; - return make<SpecialName>("reference temporary for ", Name); - } - // GI <module-name> v - case 'I': { - First += 2; - ModuleName *Module = nullptr; - if (getDerived().parseModuleNameOpt(Module)) - return nullptr; - if (Module == nullptr) - return nullptr; - return make<SpecialName>("initializer for module ", Module); - } - } - } - return nullptr; -} - -// <encoding> ::= <function name> <bare-function-type> -// ::= <data name> -// ::= <special-name> -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseEncoding() { - // The template parameters of an encoding are unrelated to those of the - // enclosing context. - class SaveTemplateParams { - AbstractManglingParser *Parser; - decltype(TemplateParams) OldParams; - decltype(OuterTemplateParams) OldOuterParams; - - public: - SaveTemplateParams(AbstractManglingParser *TheParser) : Parser(TheParser) { - OldParams = std::move(Parser->TemplateParams); - OldOuterParams = std::move(Parser->OuterTemplateParams); - Parser->TemplateParams.clear(); - Parser->OuterTemplateParams.clear(); - } - ~SaveTemplateParams() { - Parser->TemplateParams = std::move(OldParams); - Parser->OuterTemplateParams = std::move(OldOuterParams); - } - } SaveTemplateParams(this); - - if (look() == 'G' || look() == 'T') - return getDerived().parseSpecialName(); - - auto IsEndOfEncoding = [&] { - // The set of chars that can potentially follow an <encoding> (none of which - // can start a <type>). Enumerating these allows us to avoid speculative - // parsing. - return numLeft() == 0 || look() == 'E' || look() == '.' || look() == '_'; - }; - - NameState NameInfo(this); - Node *Name = getDerived().parseName(&NameInfo); - if (Name == nullptr) - return nullptr; - - if (resolveForwardTemplateRefs(NameInfo)) - return nullptr; - - if (IsEndOfEncoding()) - return Name; - - Node *Attrs = nullptr; - if (consumeIf("Ua9enable_ifI")) { - size_t BeforeArgs = Names.size(); - while (!consumeIf('E')) { - Node *Arg = getDerived().parseTemplateArg(); - if (Arg == nullptr) - return nullptr; - Names.push_back(Arg); - } - Attrs = make<EnableIfAttr>(popTrailingNodeArray(BeforeArgs)); - if (!Attrs) - return nullptr; - } - - Node *ReturnType = nullptr; - if (!NameInfo.CtorDtorConversion && NameInfo.EndsWithTemplateArgs) { - ReturnType = getDerived().parseType(); - if (ReturnType == nullptr) - return nullptr; - } - - if (consumeIf('v')) - return make<FunctionEncoding>(ReturnType, Name, NodeArray(), - Attrs, NameInfo.CVQualifiers, - NameInfo.ReferenceQualifier); - - size_t ParamsBegin = Names.size(); - do { - Node *Ty = getDerived().parseType(); - if (Ty == nullptr) - return nullptr; - Names.push_back(Ty); - } while (!IsEndOfEncoding()); - - return make<FunctionEncoding>(ReturnType, Name, - popTrailingNodeArray(ParamsBegin), - Attrs, NameInfo.CVQualifiers, - NameInfo.ReferenceQualifier); -} - -template <class Float> -struct FloatData; - -template <> -struct FloatData<float> -{ - static const size_t mangled_size = 8; - static const size_t max_demangled_size = 24; - static constexpr const char* spec = "%af"; -}; - -template <> -struct FloatData<double> -{ - static const size_t mangled_size = 16; - static const size_t max_demangled_size = 32; - static constexpr const char* spec = "%a"; -}; - -template <> -struct FloatData<long double> -{ -#if defined(__mips__) && defined(__mips_n64) || defined(__aarch64__) || \ - defined(__wasm__) || defined(__riscv) - static const size_t mangled_size = 32; -#elif defined(__arm__) || defined(__mips__) || defined(__hexagon__) - static const size_t mangled_size = 16; -#else - static const size_t mangled_size = 20; // May need to be adjusted to 16 or 24 on other platforms -#endif - // `-0x1.ffffffffffffffffffffffffffffp+16383` + 'L' + '\0' == 42 bytes. - // 28 'f's * 4 bits == 112 bits, which is the number of mantissa bits. - // Negatives are one character longer than positives. - // `0x1.` and `p` are constant, and exponents `+16383` and `-16382` are the - // same length. 1 sign bit, 112 mantissa bits, and 15 exponent bits == 128. - static const size_t max_demangled_size = 42; - static constexpr const char *spec = "%LaL"; -}; - -template <typename Alloc, typename Derived> -template <class Float> -Node *AbstractManglingParser<Alloc, Derived>::parseFloatingLiteral() { - const size_t N = FloatData<Float>::mangled_size; - if (numLeft() <= N) - return nullptr; - StringView Data(First, First + N); - for (char C : Data) - if (!std::isxdigit(C)) - return nullptr; - First += N; - if (!consumeIf('E')) - return nullptr; - return make<FloatLiteralImpl<Float>>(Data); -} - -// <seq-id> ::= <0-9A-Z>+ -template <typename Alloc, typename Derived> -bool AbstractManglingParser<Alloc, Derived>::parseSeqId(size_t *Out) { - if (!(look() >= '0' && look() <= '9') && - !(look() >= 'A' && look() <= 'Z')) - return true; - - size_t Id = 0; - while (true) { - if (look() >= '0' && look() <= '9') { - Id *= 36; - Id += static_cast<size_t>(look() - '0'); - } else if (look() >= 'A' && look() <= 'Z') { - Id *= 36; - Id += static_cast<size_t>(look() - 'A') + 10; - } else { - *Out = Id; - return false; - } - ++First; - } -} - -// <substitution> ::= S <seq-id> _ -// ::= S_ -// <substitution> ::= Sa # ::std::allocator -// <substitution> ::= Sb # ::std::basic_string -// <substitution> ::= Ss # ::std::basic_string < char, -// ::std::char_traits<char>, -// ::std::allocator<char> > -// <substitution> ::= Si # ::std::basic_istream<char, std::char_traits<char> > -// <substitution> ::= So # ::std::basic_ostream<char, std::char_traits<char> > -// <substitution> ::= Sd # ::std::basic_iostream<char, std::char_traits<char> > -// The St case is handled specially in parseNestedName. -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseSubstitution() { - if (!consumeIf('S')) - return nullptr; - - if (look() >= 'a' && look() <= 'z') { - SpecialSubKind Kind; - switch (look()) { - case 'a': - Kind = SpecialSubKind::allocator; - break; - case 'b': - Kind = SpecialSubKind::basic_string; - break; - case 'd': - Kind = SpecialSubKind::iostream; - break; - case 'i': - Kind = SpecialSubKind::istream; - break; - case 'o': - Kind = SpecialSubKind::ostream; - break; - case 's': - Kind = SpecialSubKind::string; - break; - default: - return nullptr; - } - ++First; - auto *SpecialSub = make<SpecialSubstitution>(Kind); - if (!SpecialSub) - return nullptr; - - // Itanium C++ ABI 5.1.2: If a name that would use a built-in <substitution> - // has ABI tags, the tags are appended to the substitution; the result is a - // substitutable component. - Node *WithTags = getDerived().parseAbiTags(SpecialSub); - if (WithTags != SpecialSub) { - Subs.push_back(WithTags); - SpecialSub = WithTags; - } - return SpecialSub; - } - - // ::= S_ - if (consumeIf('_')) { - if (Subs.empty()) - return nullptr; - return Subs[0]; - } - - // ::= S <seq-id> _ - size_t Index = 0; - if (parseSeqId(&Index)) - return nullptr; - ++Index; - if (!consumeIf('_') || Index >= Subs.size()) - return nullptr; - return Subs[Index]; -} - -// <template-param> ::= T_ # first template parameter -// ::= T <parameter-2 non-negative number> _ -// ::= TL <level-1> __ -// ::= TL <level-1> _ <parameter-2 non-negative number> _ -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseTemplateParam() { - if (!consumeIf('T')) - return nullptr; - - size_t Level = 0; - if (consumeIf('L')) { - if (parsePositiveInteger(&Level)) - return nullptr; - ++Level; - if (!consumeIf('_')) - return nullptr; - } - - size_t Index = 0; - if (!consumeIf('_')) { - if (parsePositiveInteger(&Index)) - return nullptr; - ++Index; - if (!consumeIf('_')) - return nullptr; - } - - // If we're in a context where this <template-param> refers to a - // <template-arg> further ahead in the mangled name (currently just conversion - // operator types), then we should only look it up in the right context. - // This can only happen at the outermost level. - if (PermitForwardTemplateReferences && Level == 0) { - Node *ForwardRef = make<ForwardTemplateReference>(Index); - if (!ForwardRef) - return nullptr; - assert(ForwardRef->getKind() == Node::KForwardTemplateReference); - ForwardTemplateRefs.push_back( - static_cast<ForwardTemplateReference *>(ForwardRef)); - return ForwardRef; - } - - if (Level >= TemplateParams.size() || !TemplateParams[Level] || - Index >= TemplateParams[Level]->size()) { - // Itanium ABI 5.1.8: In a generic lambda, uses of auto in the parameter - // list are mangled as the corresponding artificial template type parameter. - if (ParsingLambdaParamsAtLevel == Level && Level <= TemplateParams.size()) { - // This will be popped by the ScopedTemplateParamList in - // parseUnnamedTypeName. - if (Level == TemplateParams.size()) - TemplateParams.push_back(nullptr); - return make<NameType>("auto"); - } - - return nullptr; - } - - return (*TemplateParams[Level])[Index]; -} - -// <template-param-decl> ::= Ty # type parameter -// ::= Tn <type> # non-type parameter -// ::= Tt <template-param-decl>* E # template parameter -// ::= Tp <template-param-decl> # parameter pack -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseTemplateParamDecl() { - auto InventTemplateParamName = [&](TemplateParamKind Kind) { - unsigned Index = NumSyntheticTemplateParameters[(int)Kind]++; - Node *N = make<SyntheticTemplateParamName>(Kind, Index); - if (N) TemplateParams.back()->push_back(N); - return N; - }; - - if (consumeIf("Ty")) { - Node *Name = InventTemplateParamName(TemplateParamKind::Type); - if (!Name) - return nullptr; - return make<TypeTemplateParamDecl>(Name); - } - - if (consumeIf("Tn")) { - Node *Name = InventTemplateParamName(TemplateParamKind::NonType); - if (!Name) - return nullptr; - Node *Type = parseType(); - if (!Type) - return nullptr; - return make<NonTypeTemplateParamDecl>(Name, Type); - } - - if (consumeIf("Tt")) { - Node *Name = InventTemplateParamName(TemplateParamKind::Template); - if (!Name) - return nullptr; - size_t ParamsBegin = Names.size(); - ScopedTemplateParamList TemplateTemplateParamParams(this); - while (!consumeIf("E")) { - Node *P = parseTemplateParamDecl(); - if (!P) - return nullptr; - Names.push_back(P); - } - NodeArray Params = popTrailingNodeArray(ParamsBegin); - return make<TemplateTemplateParamDecl>(Name, Params); - } - - if (consumeIf("Tp")) { - Node *P = parseTemplateParamDecl(); - if (!P) - return nullptr; - return make<TemplateParamPackDecl>(P); - } - - return nullptr; -} - -// <template-arg> ::= <type> # type or template -// ::= X <expression> E # expression -// ::= <expr-primary> # simple expressions -// ::= J <template-arg>* E # argument pack -// ::= LZ <encoding> E # extension -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parseTemplateArg() { - switch (look()) { - case 'X': { - ++First; - Node *Arg = getDerived().parseExpr(); - if (Arg == nullptr || !consumeIf('E')) - return nullptr; - return Arg; - } - case 'J': { - ++First; - size_t ArgsBegin = Names.size(); - while (!consumeIf('E')) { - Node *Arg = getDerived().parseTemplateArg(); - if (Arg == nullptr) - return nullptr; - Names.push_back(Arg); - } - NodeArray Args = popTrailingNodeArray(ArgsBegin); - return make<TemplateArgumentPack>(Args); - } - case 'L': { - // ::= LZ <encoding> E # extension - if (look(1) == 'Z') { - First += 2; - Node *Arg = getDerived().parseEncoding(); - if (Arg == nullptr || !consumeIf('E')) - return nullptr; - return Arg; - } - // ::= <expr-primary> # simple expressions - return getDerived().parseExprPrimary(); - } - default: - return getDerived().parseType(); - } -} - -// <template-args> ::= I <template-arg>* E -// extension, the abi says <template-arg>+ -template <typename Derived, typename Alloc> -Node * -AbstractManglingParser<Derived, Alloc>::parseTemplateArgs(bool TagTemplates) { - if (!consumeIf('I')) - return nullptr; - - // <template-params> refer to the innermost <template-args>. Clear out any - // outer args that we may have inserted into TemplateParams. - if (TagTemplates) { - TemplateParams.clear(); - TemplateParams.push_back(&OuterTemplateParams); - OuterTemplateParams.clear(); - } - - size_t ArgsBegin = Names.size(); - while (!consumeIf('E')) { - if (TagTemplates) { - auto OldParams = std::move(TemplateParams); - Node *Arg = getDerived().parseTemplateArg(); - TemplateParams = std::move(OldParams); - if (Arg == nullptr) - return nullptr; - Names.push_back(Arg); - Node *TableEntry = Arg; - if (Arg->getKind() == Node::KTemplateArgumentPack) { - TableEntry = make<ParameterPack>( - static_cast<TemplateArgumentPack*>(TableEntry)->getElements()); - if (!TableEntry) - return nullptr; - } - TemplateParams.back()->push_back(TableEntry); - } else { - Node *Arg = getDerived().parseTemplateArg(); - if (Arg == nullptr) - return nullptr; - Names.push_back(Arg); - } - } - return make<TemplateArgs>(popTrailingNodeArray(ArgsBegin)); -} - -// <mangled-name> ::= _Z <encoding> -// ::= <type> -// extension ::= ___Z <encoding> _block_invoke -// extension ::= ___Z <encoding> _block_invoke<decimal-digit>+ -// extension ::= ___Z <encoding> _block_invoke_<decimal-digit>+ -template <typename Derived, typename Alloc> -Node *AbstractManglingParser<Derived, Alloc>::parse() { - if (consumeIf("_Z") || consumeIf("__Z")) { - Node *Encoding = getDerived().parseEncoding(); - if (Encoding == nullptr) - return nullptr; - if (look() == '.') { - Encoding = make<DotSuffix>(Encoding, StringView(First, Last)); - First = Last; - } - if (numLeft() != 0) - return nullptr; - return Encoding; - } - - if (consumeIf("___Z") || consumeIf("____Z")) { - Node *Encoding = getDerived().parseEncoding(); - if (Encoding == nullptr || !consumeIf("_block_invoke")) - return nullptr; - bool RequireNumber = consumeIf('_'); - if (parseNumber().empty() && RequireNumber) - return nullptr; - if (look() == '.') - First = Last; - if (numLeft() != 0) - return nullptr; - return make<SpecialName>("invocation function for block in ", Encoding); - } - - Node *Ty = getDerived().parseType(); - if (numLeft() != 0) - return nullptr; - return Ty; -} - -template <typename Alloc> -struct ManglingParser : AbstractManglingParser<ManglingParser<Alloc>, Alloc> { - using AbstractManglingParser<ManglingParser<Alloc>, - Alloc>::AbstractManglingParser; -}; - -DEMANGLE_NAMESPACE_END - -#endif // DEMANGLE_ITANIUMDEMANGLE_H diff --git a/demangle/third_party/llvm/include/llvm/Demangle/ItaniumNodes.def b/demangle/third_party/llvm/include/llvm/Demangle/ItaniumNodes.def deleted file mode 100644 index c0e277d5..00000000 --- a/demangle/third_party/llvm/include/llvm/Demangle/ItaniumNodes.def +++ /dev/null @@ -1,95 +0,0 @@ -//===--- ItaniumNodes.def ------------*- mode:c++;eval:(read-only-mode) -*-===// -// Do not edit! See README.txt. -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// Define the demangler's node names - -#ifndef NODE -#error Define NODE to handle nodes -#endif - -NODE(NodeArrayNode) -NODE(DotSuffix) -NODE(VendorExtQualType) -NODE(QualType) -NODE(ConversionOperatorType) -NODE(PostfixQualifiedType) -NODE(ElaboratedTypeSpefType) -NODE(NameType) -NODE(AbiTagAttr) -NODE(EnableIfAttr) -NODE(ObjCProtoName) -NODE(PointerType) -NODE(ReferenceType) -NODE(PointerToMemberType) -NODE(ArrayType) -NODE(FunctionType) -NODE(NoexceptSpec) -NODE(DynamicExceptionSpec) -NODE(FunctionEncoding) -NODE(LiteralOperator) -NODE(SpecialName) -NODE(CtorVtableSpecialName) -NODE(QualifiedName) -NODE(NestedName) -NODE(LocalName) -NODE(ModuleName) -NODE(ModuleEntity) -NODE(VectorType) -NODE(PixelVectorType) -NODE(BinaryFPType) -NODE(BitIntType) -NODE(SyntheticTemplateParamName) -NODE(TypeTemplateParamDecl) -NODE(NonTypeTemplateParamDecl) -NODE(TemplateTemplateParamDecl) -NODE(TemplateParamPackDecl) -NODE(ParameterPack) -NODE(TemplateArgumentPack) -NODE(ParameterPackExpansion) -NODE(TemplateArgs) -NODE(ForwardTemplateReference) -NODE(NameWithTemplateArgs) -NODE(GlobalQualifiedName) -NODE(ExpandedSpecialSubstitution) -NODE(SpecialSubstitution) -NODE(CtorDtorName) -NODE(DtorName) -NODE(UnnamedTypeName) -NODE(ClosureTypeName) -NODE(StructuredBindingName) -NODE(BinaryExpr) -NODE(ArraySubscriptExpr) -NODE(PostfixExpr) -NODE(ConditionalExpr) -NODE(MemberExpr) -NODE(SubobjectExpr) -NODE(EnclosingExpr) -NODE(CastExpr) -NODE(SizeofParamPackExpr) -NODE(CallExpr) -NODE(NewExpr) -NODE(DeleteExpr) -NODE(PrefixExpr) -NODE(FunctionParam) -NODE(ConversionExpr) -NODE(PointerToMemberConversionExpr) -NODE(InitListExpr) -NODE(FoldExpr) -NODE(ThrowExpr) -NODE(BoolExpr) -NODE(StringLiteral) -NODE(LambdaExpr) -NODE(EnumLiteral) -NODE(IntegerLiteral) -NODE(FloatLiteral) -NODE(DoubleLiteral) -NODE(LongDoubleLiteral) -NODE(BracedExpr) -NODE(BracedRangeExpr) - -#undef NODE diff --git a/demangle/third_party/llvm/include/llvm/Demangle/MicrosoftDemangle.h b/demangle/third_party/llvm/include/llvm/Demangle/MicrosoftDemangle.h deleted file mode 100644 index f1a5e1b6..00000000 --- a/demangle/third_party/llvm/include/llvm/Demangle/MicrosoftDemangle.h +++ /dev/null @@ -1,276 +0,0 @@ -//===------------------------- MicrosoftDemangle.h --------------*- C++ -*-===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_DEMANGLE_MICROSOFTDEMANGLE_H -#define LLVM_DEMANGLE_MICROSOFTDEMANGLE_H - -#include "llvm/Demangle/MicrosoftDemangleNodes.h" -#include "llvm/Demangle/StringView.h" - -#include <utility> - -namespace llvm { -namespace ms_demangle { -// This memory allocator is extremely fast, but it doesn't call dtors -// for allocated objects. That means you can't use STL containers -// (such as std::vector) with this allocator. But it pays off -- -// the demangler is 3x faster with this allocator compared to one with -// STL containers. -constexpr size_t AllocUnit = 4096; - -class ArenaAllocator { - struct AllocatorNode { - uint8_t *Buf = nullptr; - size_t Used = 0; - size_t Capacity = 0; - AllocatorNode *Next = nullptr; - }; - - void addNode(size_t Capacity) { - AllocatorNode *NewHead = new AllocatorNode; - NewHead->Buf = new uint8_t[Capacity]; - NewHead->Next = Head; - NewHead->Capacity = Capacity; - Head = NewHead; - NewHead->Used = 0; - } - -public: - ArenaAllocator() { addNode(AllocUnit); } - - ~ArenaAllocator() { - while (Head) { - assert(Head->Buf); - delete[] Head->Buf; - AllocatorNode *Next = Head->Next; - delete Head; - Head = Next; - } - } - - char *allocUnalignedBuffer(size_t Size) { - assert(Head && Head->Buf); - - uint8_t *P = Head->Buf + Head->Used; - - Head->Used += Size; - if (Head->Used <= Head->Capacity) - return reinterpret_cast<char *>(P); - - addNode(std::max(AllocUnit, Size)); - Head->Used = Size; - return reinterpret_cast<char *>(Head->Buf); - } - - template <typename T, typename... Args> T *allocArray(size_t Count) { - size_t Size = Count * sizeof(T); - assert(Head && Head->Buf); - - size_t P = (size_t)Head->Buf + Head->Used; - uintptr_t AlignedP = - (((size_t)P + alignof(T) - 1) & ~(size_t)(alignof(T) - 1)); - uint8_t *PP = (uint8_t *)AlignedP; - size_t Adjustment = AlignedP - P; - - Head->Used += Size + Adjustment; - if (Head->Used <= Head->Capacity) - return new (PP) T[Count](); - - addNode(std::max(AllocUnit, Size)); - Head->Used = Size; - return new (Head->Buf) T[Count](); - } - - template <typename T, typename... Args> T *alloc(Args &&... ConstructorArgs) { - constexpr size_t Size = sizeof(T); - assert(Head && Head->Buf); - - size_t P = (size_t)Head->Buf + Head->Used; - uintptr_t AlignedP = - (((size_t)P + alignof(T) - 1) & ~(size_t)(alignof(T) - 1)); - uint8_t *PP = (uint8_t *)AlignedP; - size_t Adjustment = AlignedP - P; - - Head->Used += Size + Adjustment; - if (Head->Used <= Head->Capacity) - return new (PP) T(std::forward<Args>(ConstructorArgs)...); - - static_assert(Size < AllocUnit); - addNode(AllocUnit); - Head->Used = Size; - return new (Head->Buf) T(std::forward<Args>(ConstructorArgs)...); - } - -private: - AllocatorNode *Head = nullptr; -}; - -struct BackrefContext { - static constexpr size_t Max = 10; - - TypeNode *FunctionParams[Max]; - size_t FunctionParamCount = 0; - - // The first 10 BackReferences in a mangled name can be back-referenced by - // special name @[0-9]. This is a storage for the first 10 BackReferences. - NamedIdentifierNode *Names[Max]; - size_t NamesCount = 0; -}; - -enum class QualifierMangleMode { Drop, Mangle, Result }; - -enum NameBackrefBehavior : uint8_t { - NBB_None = 0, // don't save any names as backrefs. - NBB_Template = 1 << 0, // save template instanations. - NBB_Simple = 1 << 1, // save simple names. -}; - -enum class FunctionIdentifierCodeGroup { Basic, Under, DoubleUnder }; - -// Demangler class takes the main role in demangling symbols. -// It has a set of functions to parse mangled symbols into Type instances. -// It also has a set of functions to convert Type instances to strings. -class Demangler { -public: - Demangler() = default; - virtual ~Demangler() = default; - - // You are supposed to call parse() first and then check if error is true. If - // it is false, call output() to write the formatted name to the given stream. - SymbolNode *parse(StringView &MangledName); - - TagTypeNode *parseTagUniqueName(StringView &MangledName); - - // True if an error occurred. - bool Error = false; - - void dumpBackReferences(); - -private: - SymbolNode *demangleEncodedSymbol(StringView &MangledName, - QualifiedNameNode *QN); - SymbolNode *demangleDeclarator(StringView &MangledName); - SymbolNode *demangleMD5Name(StringView &MangledName); - SymbolNode *demangleTypeinfoName(StringView &MangledName); - - VariableSymbolNode *demangleVariableEncoding(StringView &MangledName, - StorageClass SC); - FunctionSymbolNode *demangleFunctionEncoding(StringView &MangledName); - - Qualifiers demanglePointerExtQualifiers(StringView &MangledName); - - // Parser functions. This is a recursive-descent parser. - TypeNode *demangleType(StringView &MangledName, QualifierMangleMode QMM); - PrimitiveTypeNode *demanglePrimitiveType(StringView &MangledName); - CustomTypeNode *demangleCustomType(StringView &MangledName); - TagTypeNode *demangleClassType(StringView &MangledName); - PointerTypeNode *demanglePointerType(StringView &MangledName); - PointerTypeNode *demangleMemberPointerType(StringView &MangledName); - FunctionSignatureNode *demangleFunctionType(StringView &MangledName, - bool HasThisQuals); - - ArrayTypeNode *demangleArrayType(StringView &MangledName); - - NodeArrayNode *demangleFunctionParameterList(StringView &MangledName, - bool &IsVariadic); - NodeArrayNode *demangleTemplateParameterList(StringView &MangledName); - - std::pair<uint64_t, bool> demangleNumber(StringView &MangledName); - uint64_t demangleUnsigned(StringView &MangledName); - int64_t demangleSigned(StringView &MangledName); - - void memorizeString(StringView s); - void memorizeIdentifier(IdentifierNode *Identifier); - - /// Allocate a copy of \p Borrowed into memory that we own. - StringView copyString(StringView Borrowed); - - QualifiedNameNode *demangleFullyQualifiedTypeName(StringView &MangledName); - QualifiedNameNode *demangleFullyQualifiedSymbolName(StringView &MangledName); - - IdentifierNode *demangleUnqualifiedTypeName(StringView &MangledName, - bool Memorize); - IdentifierNode *demangleUnqualifiedSymbolName(StringView &MangledName, - NameBackrefBehavior NBB); - - QualifiedNameNode *demangleNameScopeChain(StringView &MangledName, - IdentifierNode *UnqualifiedName); - IdentifierNode *demangleNameScopePiece(StringView &MangledName); - - NamedIdentifierNode *demangleBackRefName(StringView &MangledName); - IdentifierNode *demangleTemplateInstantiationName(StringView &MangledName, - NameBackrefBehavior NBB); - IntrinsicFunctionKind - translateIntrinsicFunctionCode(char CH, FunctionIdentifierCodeGroup Group); - IdentifierNode *demangleFunctionIdentifierCode(StringView &MangledName); - IdentifierNode * - demangleFunctionIdentifierCode(StringView &MangledName, - FunctionIdentifierCodeGroup Group); - StructorIdentifierNode *demangleStructorIdentifier(StringView &MangledName, - bool IsDestructor); - ConversionOperatorIdentifierNode * - demangleConversionOperatorIdentifier(StringView &MangledName); - LiteralOperatorIdentifierNode * - demangleLiteralOperatorIdentifier(StringView &MangledName); - - SymbolNode *demangleSpecialIntrinsic(StringView &MangledName); - SpecialTableSymbolNode * - demangleSpecialTableSymbolNode(StringView &MangledName, - SpecialIntrinsicKind SIK); - LocalStaticGuardVariableNode * - demangleLocalStaticGuard(StringView &MangledName, bool IsThread); - VariableSymbolNode *demangleUntypedVariable(ArenaAllocator &Arena, - StringView &MangledName, - StringView VariableName); - VariableSymbolNode * - demangleRttiBaseClassDescriptorNode(ArenaAllocator &Arena, - StringView &MangledName); - FunctionSymbolNode *demangleInitFiniStub(StringView &MangledName, - bool IsDestructor); - - NamedIdentifierNode *demangleSimpleName(StringView &MangledName, - bool Memorize); - NamedIdentifierNode *demangleAnonymousNamespaceName(StringView &MangledName); - NamedIdentifierNode *demangleLocallyScopedNamePiece(StringView &MangledName); - EncodedStringLiteralNode *demangleStringLiteral(StringView &MangledName); - FunctionSymbolNode *demangleVcallThunkNode(StringView &MangledName); - - StringView demangleSimpleString(StringView &MangledName, bool Memorize); - - FuncClass demangleFunctionClass(StringView &MangledName); - CallingConv demangleCallingConvention(StringView &MangledName); - StorageClass demangleVariableStorageClass(StringView &MangledName); - bool demangleThrowSpecification(StringView &MangledName); - wchar_t demangleWcharLiteral(StringView &MangledName); - uint8_t demangleCharLiteral(StringView &MangledName); - - std::pair<Qualifiers, bool> demangleQualifiers(StringView &MangledName); - - // Memory allocator. - ArenaAllocator Arena; - - // A single type uses one global back-ref table for all function params. - // This means back-refs can even go "into" other types. Examples: - // - // // Second int* is a back-ref to first. - // void foo(int *, int*); - // - // // Second int* is not a back-ref to first (first is not a function param). - // int* foo(int*); - // - // // Second int* is a back-ref to first (ALL function types share the same - // // back-ref map. - // using F = void(*)(int*); - // F G(int *); - BackrefContext Backrefs; -}; - -} // namespace ms_demangle -} // namespace llvm - -#endif // LLVM_DEMANGLE_MICROSOFTDEMANGLE_H diff --git a/demangle/third_party/llvm/include/llvm/Demangle/MicrosoftDemangleNodes.h b/demangle/third_party/llvm/include/llvm/Demangle/MicrosoftDemangleNodes.h deleted file mode 100644 index 8ad24723..00000000 --- a/demangle/third_party/llvm/include/llvm/Demangle/MicrosoftDemangleNodes.h +++ /dev/null @@ -1,629 +0,0 @@ -//===- MicrosoftDemangleNodes.h ---------------------------------*- C++ -*-===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file defines the AST nodes used in the MSVC demangler. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_DEMANGLE_MICROSOFTDEMANGLENODES_H -#define LLVM_DEMANGLE_MICROSOFTDEMANGLENODES_H - -#include "llvm/Demangle/StringView.h" -#include <array> -#include <cstdint> -#include <string> - -namespace llvm { -namespace itanium_demangle { -class OutputBuffer; -} -} - -using llvm::itanium_demangle::OutputBuffer; -using llvm::itanium_demangle::StringView; - -namespace llvm { -namespace ms_demangle { - -// Storage classes -enum Qualifiers : uint8_t { - Q_None = 0, - Q_Const = 1 << 0, - Q_Volatile = 1 << 1, - Q_Far = 1 << 2, - Q_Huge = 1 << 3, - Q_Unaligned = 1 << 4, - Q_Restrict = 1 << 5, - Q_Pointer64 = 1 << 6 -}; - -enum class StorageClass : uint8_t { - None, - PrivateStatic, - ProtectedStatic, - PublicStatic, - Global, - FunctionLocalStatic, -}; - -enum class PointerAffinity { None, Pointer, Reference, RValueReference }; -enum class FunctionRefQualifier { None, Reference, RValueReference }; - -// Calling conventions -enum class CallingConv : uint8_t { - None, - Cdecl, - Pascal, - Thiscall, - Stdcall, - Fastcall, - Clrcall, - Eabi, - Vectorcall, - Regcall, - Swift, // Clang-only - SwiftAsync, // Clang-only -}; - -enum class ReferenceKind : uint8_t { None, LValueRef, RValueRef }; - -enum OutputFlags { - OF_Default = 0, - OF_NoCallingConvention = 1, - OF_NoTagSpecifier = 2, - OF_NoAccessSpecifier = 4, - OF_NoMemberType = 8, - OF_NoReturnType = 16, - OF_NoVariableType = 32, -}; - -// Types -enum class PrimitiveKind { - Void, - Bool, - Char, - Schar, - Uchar, - Char8, - Char16, - Char32, - Short, - Ushort, - Int, - Uint, - Long, - Ulong, - Int64, - Uint64, - Wchar, - Float, - Double, - Ldouble, - Nullptr, -}; - -enum class CharKind { - Char, - Char16, - Char32, - Wchar, -}; - -enum class IntrinsicFunctionKind : uint8_t { - None, - New, // ?2 # operator new - Delete, // ?3 # operator delete - Assign, // ?4 # operator= - RightShift, // ?5 # operator>> - LeftShift, // ?6 # operator<< - LogicalNot, // ?7 # operator! - Equals, // ?8 # operator== - NotEquals, // ?9 # operator!= - ArraySubscript, // ?A # operator[] - Pointer, // ?C # operator-> - Dereference, // ?D # operator* - Increment, // ?E # operator++ - Decrement, // ?F # operator-- - Minus, // ?G # operator- - Plus, // ?H # operator+ - BitwiseAnd, // ?I # operator& - MemberPointer, // ?J # operator->* - Divide, // ?K # operator/ - Modulus, // ?L # operator% - LessThan, // ?M operator< - LessThanEqual, // ?N operator<= - GreaterThan, // ?O operator> - GreaterThanEqual, // ?P operator>= - Comma, // ?Q operator, - Parens, // ?R operator() - BitwiseNot, // ?S operator~ - BitwiseXor, // ?T operator^ - BitwiseOr, // ?U operator| - LogicalAnd, // ?V operator&& - LogicalOr, // ?W operator|| - TimesEqual, // ?X operator*= - PlusEqual, // ?Y operator+= - MinusEqual, // ?Z operator-= - DivEqual, // ?_0 operator/= - ModEqual, // ?_1 operator%= - RshEqual, // ?_2 operator>>= - LshEqual, // ?_3 operator<<= - BitwiseAndEqual, // ?_4 operator&= - BitwiseOrEqual, // ?_5 operator|= - BitwiseXorEqual, // ?_6 operator^= - VbaseDtor, // ?_D # vbase destructor - VecDelDtor, // ?_E # vector deleting destructor - DefaultCtorClosure, // ?_F # default constructor closure - ScalarDelDtor, // ?_G # scalar deleting destructor - VecCtorIter, // ?_H # vector constructor iterator - VecDtorIter, // ?_I # vector destructor iterator - VecVbaseCtorIter, // ?_J # vector vbase constructor iterator - VdispMap, // ?_K # virtual displacement map - EHVecCtorIter, // ?_L # eh vector constructor iterator - EHVecDtorIter, // ?_M # eh vector destructor iterator - EHVecVbaseCtorIter, // ?_N # eh vector vbase constructor iterator - CopyCtorClosure, // ?_O # copy constructor closure - LocalVftableCtorClosure, // ?_T # local vftable constructor closure - ArrayNew, // ?_U operator new[] - ArrayDelete, // ?_V operator delete[] - ManVectorCtorIter, // ?__A managed vector ctor iterator - ManVectorDtorIter, // ?__B managed vector dtor iterator - EHVectorCopyCtorIter, // ?__C EH vector copy ctor iterator - EHVectorVbaseCopyCtorIter, // ?__D EH vector vbase copy ctor iterator - VectorCopyCtorIter, // ?__G vector copy constructor iterator - VectorVbaseCopyCtorIter, // ?__H vector vbase copy constructor iterator - ManVectorVbaseCopyCtorIter, // ?__I managed vector vbase copy constructor - CoAwait, // ?__L operator co_await - Spaceship, // ?__M operator<=> - MaxIntrinsic -}; - -enum class SpecialIntrinsicKind { - None, - Vftable, - Vbtable, - Typeof, - VcallThunk, - LocalStaticGuard, - StringLiteralSymbol, - UdtReturning, - Unknown, - DynamicInitializer, - DynamicAtexitDestructor, - RttiTypeDescriptor, - RttiBaseClassDescriptor, - RttiBaseClassArray, - RttiClassHierarchyDescriptor, - RttiCompleteObjLocator, - LocalVftable, - LocalStaticThreadGuard, -}; - -// Function classes -enum FuncClass : uint16_t { - FC_None = 0, - FC_Public = 1 << 0, - FC_Protected = 1 << 1, - FC_Private = 1 << 2, - FC_Global = 1 << 3, - FC_Static = 1 << 4, - FC_Virtual = 1 << 5, - FC_Far = 1 << 6, - FC_ExternC = 1 << 7, - FC_NoParameterList = 1 << 8, - FC_VirtualThisAdjust = 1 << 9, - FC_VirtualThisAdjustEx = 1 << 10, - FC_StaticThisAdjust = 1 << 11, -}; - -enum class TagKind { Class, Struct, Union, Enum }; - -enum class NodeKind { - Unknown, - Md5Symbol, - PrimitiveType, - FunctionSignature, - Identifier, - NamedIdentifier, - VcallThunkIdentifier, - LocalStaticGuardIdentifier, - IntrinsicFunctionIdentifier, - ConversionOperatorIdentifier, - DynamicStructorIdentifier, - StructorIdentifier, - LiteralOperatorIdentifier, - ThunkSignature, - PointerType, - TagType, - ArrayType, - Custom, - IntrinsicType, - NodeArray, - QualifiedName, - TemplateParameterReference, - EncodedStringLiteral, - IntegerLiteral, - RttiBaseClassDescriptor, - LocalStaticGuardVariable, - FunctionSymbol, - VariableSymbol, - SpecialTableSymbol -}; - -struct Node { - explicit Node(NodeKind K) : Kind(K) {} - virtual ~Node() = default; - - NodeKind kind() const { return Kind; } - - virtual void output(OutputBuffer &OB, OutputFlags Flags) const = 0; - - std::string toString(OutputFlags Flags = OF_Default) const; - -private: - NodeKind Kind; -}; - -struct TypeNode; -struct PrimitiveTypeNode; -struct FunctionSignatureNode; -struct IdentifierNode; -struct NamedIdentifierNode; -struct VcallThunkIdentifierNode; -struct IntrinsicFunctionIdentifierNode; -struct LiteralOperatorIdentifierNode; -struct ConversionOperatorIdentifierNode; -struct StructorIdentifierNode; -struct ThunkSignatureNode; -struct PointerTypeNode; -struct ArrayTypeNode; -struct TagTypeNode; -struct NodeArrayNode; -struct QualifiedNameNode; -struct TemplateParameterReferenceNode; -struct EncodedStringLiteralNode; -struct IntegerLiteralNode; -struct RttiBaseClassDescriptorNode; -struct LocalStaticGuardVariableNode; -struct SymbolNode; -struct FunctionSymbolNode; -struct VariableSymbolNode; -struct SpecialTableSymbolNode; - -struct TypeNode : public Node { - explicit TypeNode(NodeKind K) : Node(K) {} - - virtual void outputPre(OutputBuffer &OB, OutputFlags Flags) const = 0; - virtual void outputPost(OutputBuffer &OB, OutputFlags Flags) const = 0; - - void output(OutputBuffer &OB, OutputFlags Flags) const override { - outputPre(OB, Flags); - outputPost(OB, Flags); - } - - Qualifiers Quals = Q_None; -}; - -struct PrimitiveTypeNode : public TypeNode { - explicit PrimitiveTypeNode(PrimitiveKind K) - : TypeNode(NodeKind::PrimitiveType), PrimKind(K) {} - - void outputPre(OutputBuffer &OB, OutputFlags Flags) const override; - void outputPost(OutputBuffer &OB, OutputFlags Flags) const override {} - - PrimitiveKind PrimKind; -}; - -struct FunctionSignatureNode : public TypeNode { - explicit FunctionSignatureNode(NodeKind K) : TypeNode(K) {} - FunctionSignatureNode() : TypeNode(NodeKind::FunctionSignature) {} - - void outputPre(OutputBuffer &OB, OutputFlags Flags) const override; - void outputPost(OutputBuffer &OB, OutputFlags Flags) const override; - - // Valid if this FunctionTypeNode is the Pointee of a PointerType or - // MemberPointerType. - PointerAffinity Affinity = PointerAffinity::None; - - // The function's calling convention. - CallingConv CallConvention = CallingConv::None; - - // Function flags (gloabl, public, etc) - FuncClass FunctionClass = FC_Global; - - FunctionRefQualifier RefQualifier = FunctionRefQualifier::None; - - // The return type of the function. - TypeNode *ReturnType = nullptr; - - // True if this is a C-style ... varargs function. - bool IsVariadic = false; - - // Function parameters - NodeArrayNode *Params = nullptr; - - // True if the function type is noexcept. - bool IsNoexcept = false; -}; - -struct IdentifierNode : public Node { - explicit IdentifierNode(NodeKind K) : Node(K) {} - - NodeArrayNode *TemplateParams = nullptr; - -protected: - void outputTemplateParameters(OutputBuffer &OB, OutputFlags Flags) const; -}; - -struct VcallThunkIdentifierNode : public IdentifierNode { - VcallThunkIdentifierNode() : IdentifierNode(NodeKind::VcallThunkIdentifier) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - - uint64_t OffsetInVTable = 0; -}; - -struct DynamicStructorIdentifierNode : public IdentifierNode { - DynamicStructorIdentifierNode() - : IdentifierNode(NodeKind::DynamicStructorIdentifier) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - - VariableSymbolNode *Variable = nullptr; - QualifiedNameNode *Name = nullptr; - bool IsDestructor = false; -}; - -struct NamedIdentifierNode : public IdentifierNode { - NamedIdentifierNode() : IdentifierNode(NodeKind::NamedIdentifier) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - - StringView Name; -}; - -struct IntrinsicFunctionIdentifierNode : public IdentifierNode { - explicit IntrinsicFunctionIdentifierNode(IntrinsicFunctionKind Operator) - : IdentifierNode(NodeKind::IntrinsicFunctionIdentifier), - Operator(Operator) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - - IntrinsicFunctionKind Operator; -}; - -struct LiteralOperatorIdentifierNode : public IdentifierNode { - LiteralOperatorIdentifierNode() - : IdentifierNode(NodeKind::LiteralOperatorIdentifier) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - - StringView Name; -}; - -struct LocalStaticGuardIdentifierNode : public IdentifierNode { - LocalStaticGuardIdentifierNode() - : IdentifierNode(NodeKind::LocalStaticGuardIdentifier) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - - bool IsThread = false; - uint32_t ScopeIndex = 0; -}; - -struct ConversionOperatorIdentifierNode : public IdentifierNode { - ConversionOperatorIdentifierNode() - : IdentifierNode(NodeKind::ConversionOperatorIdentifier) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - - // The type that this operator converts too. - TypeNode *TargetType = nullptr; -}; - -struct StructorIdentifierNode : public IdentifierNode { - StructorIdentifierNode() : IdentifierNode(NodeKind::StructorIdentifier) {} - explicit StructorIdentifierNode(bool IsDestructor) - : IdentifierNode(NodeKind::StructorIdentifier), - IsDestructor(IsDestructor) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - - // The name of the class that this is a structor of. - IdentifierNode *Class = nullptr; - bool IsDestructor = false; -}; - -struct ThunkSignatureNode : public FunctionSignatureNode { - ThunkSignatureNode() : FunctionSignatureNode(NodeKind::ThunkSignature) {} - - void outputPre(OutputBuffer &OB, OutputFlags Flags) const override; - void outputPost(OutputBuffer &OB, OutputFlags Flags) const override; - - struct ThisAdjustor { - uint32_t StaticOffset = 0; - int32_t VBPtrOffset = 0; - int32_t VBOffsetOffset = 0; - int32_t VtordispOffset = 0; - }; - - ThisAdjustor ThisAdjust; -}; - -struct PointerTypeNode : public TypeNode { - PointerTypeNode() : TypeNode(NodeKind::PointerType) {} - void outputPre(OutputBuffer &OB, OutputFlags Flags) const override; - void outputPost(OutputBuffer &OB, OutputFlags Flags) const override; - - // Is this a pointer, reference, or rvalue-reference? - PointerAffinity Affinity = PointerAffinity::None; - - // If this is a member pointer, this is the class that the member is in. - QualifiedNameNode *ClassParent = nullptr; - - // Represents a type X in "a pointer to X", "a reference to X", or - // "rvalue-reference to X" - TypeNode *Pointee = nullptr; -}; - -struct TagTypeNode : public TypeNode { - explicit TagTypeNode(TagKind Tag) : TypeNode(NodeKind::TagType), Tag(Tag) {} - - void outputPre(OutputBuffer &OB, OutputFlags Flags) const override; - void outputPost(OutputBuffer &OB, OutputFlags Flags) const override; - - QualifiedNameNode *QualifiedName = nullptr; - TagKind Tag; -}; - -struct ArrayTypeNode : public TypeNode { - ArrayTypeNode() : TypeNode(NodeKind::ArrayType) {} - - void outputPre(OutputBuffer &OB, OutputFlags Flags) const override; - void outputPost(OutputBuffer &OB, OutputFlags Flags) const override; - - void outputDimensionsImpl(OutputBuffer &OB, OutputFlags Flags) const; - void outputOneDimension(OutputBuffer &OB, OutputFlags Flags, Node *N) const; - - // A list of array dimensions. e.g. [3,4,5] in `int Foo[3][4][5]` - NodeArrayNode *Dimensions = nullptr; - - // The type of array element. - TypeNode *ElementType = nullptr; -}; - -struct IntrinsicNode : public TypeNode { - IntrinsicNode() : TypeNode(NodeKind::IntrinsicType) {} - void output(OutputBuffer &OB, OutputFlags Flags) const override {} -}; - -struct CustomTypeNode : public TypeNode { - CustomTypeNode() : TypeNode(NodeKind::Custom) {} - - void outputPre(OutputBuffer &OB, OutputFlags Flags) const override; - void outputPost(OutputBuffer &OB, OutputFlags Flags) const override; - - IdentifierNode *Identifier = nullptr; -}; - -struct NodeArrayNode : public Node { - NodeArrayNode() : Node(NodeKind::NodeArray) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - - void output(OutputBuffer &OB, OutputFlags Flags, StringView Separator) const; - - Node **Nodes = nullptr; - size_t Count = 0; -}; - -struct QualifiedNameNode : public Node { - QualifiedNameNode() : Node(NodeKind::QualifiedName) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - - NodeArrayNode *Components = nullptr; - - IdentifierNode *getUnqualifiedIdentifier() { - Node *LastComponent = Components->Nodes[Components->Count - 1]; - return static_cast<IdentifierNode *>(LastComponent); - } -}; - -struct TemplateParameterReferenceNode : public Node { - TemplateParameterReferenceNode() - : Node(NodeKind::TemplateParameterReference) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - - SymbolNode *Symbol = nullptr; - - int ThunkOffsetCount = 0; - std::array<int64_t, 3> ThunkOffsets; - PointerAffinity Affinity = PointerAffinity::None; - bool IsMemberPointer = false; -}; - -struct IntegerLiteralNode : public Node { - IntegerLiteralNode() : Node(NodeKind::IntegerLiteral) {} - IntegerLiteralNode(uint64_t Value, bool IsNegative) - : Node(NodeKind::IntegerLiteral), Value(Value), IsNegative(IsNegative) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - - uint64_t Value = 0; - bool IsNegative = false; -}; - -struct RttiBaseClassDescriptorNode : public IdentifierNode { - RttiBaseClassDescriptorNode() - : IdentifierNode(NodeKind::RttiBaseClassDescriptor) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - - uint32_t NVOffset = 0; - int32_t VBPtrOffset = 0; - uint32_t VBTableOffset = 0; - uint32_t Flags = 0; -}; - -struct SymbolNode : public Node { - explicit SymbolNode(NodeKind K) : Node(K) {} - void output(OutputBuffer &OB, OutputFlags Flags) const override; - QualifiedNameNode *Name = nullptr; -}; - -struct SpecialTableSymbolNode : public SymbolNode { - explicit SpecialTableSymbolNode() - : SymbolNode(NodeKind::SpecialTableSymbol) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - QualifiedNameNode *TargetName = nullptr; - Qualifiers Quals = Qualifiers::Q_None; -}; - -struct LocalStaticGuardVariableNode : public SymbolNode { - LocalStaticGuardVariableNode() - : SymbolNode(NodeKind::LocalStaticGuardVariable) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - - bool IsVisible = false; -}; - -struct EncodedStringLiteralNode : public SymbolNode { - EncodedStringLiteralNode() : SymbolNode(NodeKind::EncodedStringLiteral) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - - StringView DecodedString; - bool IsTruncated = false; - CharKind Char = CharKind::Char; -}; - -struct VariableSymbolNode : public SymbolNode { - VariableSymbolNode() : SymbolNode(NodeKind::VariableSymbol) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - - StorageClass SC = StorageClass::None; - TypeNode *Type = nullptr; -}; - -struct FunctionSymbolNode : public SymbolNode { - FunctionSymbolNode() : SymbolNode(NodeKind::FunctionSymbol) {} - - void output(OutputBuffer &OB, OutputFlags Flags) const override; - - FunctionSignatureNode *Signature = nullptr; -}; - -} // namespace ms_demangle -} // namespace llvm - -#endif diff --git a/demangle/third_party/llvm/include/llvm/Demangle/StringView.h b/demangle/third_party/llvm/include/llvm/Demangle/StringView.h deleted file mode 100644 index 6bbb8837..00000000 --- a/demangle/third_party/llvm/include/llvm/Demangle/StringView.h +++ /dev/null @@ -1,122 +0,0 @@ -//===--- StringView.h ----------------*- mode:c++;eval:(read-only-mode) -*-===// -// Do not edit! See README.txt. -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// FIXME: Use std::string_view instead when we support C++17. -// There are two copies of this file in the source tree. The one under -// libcxxabi is the original and the one under llvm is the copy. Use -// cp-to-llvm.sh to update the copy. See README.txt for more details. -// -//===----------------------------------------------------------------------===// - -#ifndef DEMANGLE_STRINGVIEW_H -#define DEMANGLE_STRINGVIEW_H - -#include "DemangleConfig.h" -#include <cassert> -#include <cstring> - -DEMANGLE_NAMESPACE_BEGIN - -class StringView { - const char *First; - const char *Last; - -public: - static const size_t npos = ~size_t(0); - - template <size_t N> - StringView(const char (&Str)[N]) : First(Str), Last(Str + N - 1) {} - StringView(const char *First_, const char *Last_) - : First(First_), Last(Last_) {} - StringView(const char *First_, size_t Len) - : First(First_), Last(First_ + Len) {} - StringView(const char *Str) : First(Str), Last(Str + std::strlen(Str)) {} - StringView() : First(nullptr), Last(nullptr) {} - - StringView substr(size_t Pos, size_t Len = npos) const { - assert(Pos <= size()); - if (Len > size() - Pos) - Len = size() - Pos; - return StringView(begin() + Pos, Len); - } - - size_t find(char C, size_t From = 0) const { - // Avoid calling memchr with nullptr. - if (From < size()) { - // Just forward to memchr, which is faster than a hand-rolled loop. - if (const void *P = ::memchr(First + From, C, size() - From)) - return size_t(static_cast<const char *>(P) - First); - } - return npos; - } - - StringView dropFront(size_t N = 1) const { - if (N >= size()) - N = size(); - return StringView(First + N, Last); - } - - StringView dropBack(size_t N = 1) const { - if (N >= size()) - N = size(); - return StringView(First, Last - N); - } - - char front() const { - assert(!empty()); - return *begin(); - } - - char back() const { - assert(!empty()); - return *(end() - 1); - } - - char popFront() { - assert(!empty()); - return *First++; - } - - bool consumeFront(char C) { - if (!startsWith(C)) - return false; - *this = dropFront(1); - return true; - } - - bool consumeFront(StringView S) { - if (!startsWith(S)) - return false; - *this = dropFront(S.size()); - return true; - } - - bool startsWith(char C) const { return !empty() && *begin() == C; } - - bool startsWith(StringView Str) const { - if (Str.size() > size()) - return false; - return std::strncmp(Str.begin(), begin(), Str.size()) == 0; - } - - const char &operator[](size_t Idx) const { return *(begin() + Idx); } - - const char *begin() const { return First; } - const char *end() const { return Last; } - size_t size() const { return static_cast<size_t>(Last - First); } - bool empty() const { return First == Last; } -}; - -inline bool operator==(const StringView &LHS, const StringView &RHS) { - return LHS.size() == RHS.size() && - std::strncmp(LHS.begin(), RHS.begin(), LHS.size()) == 0; -} - -DEMANGLE_NAMESPACE_END - -#endif diff --git a/demangle/third_party/llvm/include/llvm/Demangle/Utility.h b/demangle/third_party/llvm/include/llvm/Demangle/Utility.h deleted file mode 100644 index 855c56e9..00000000 --- a/demangle/third_party/llvm/include/llvm/Demangle/Utility.h +++ /dev/null @@ -1,199 +0,0 @@ -//===--- Utility.h -------------------*- mode:c++;eval:(read-only-mode) -*-===// -// Do not edit! See README.txt. -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// Provide some utility classes for use in the demangler. -// There are two copies of this file in the source tree. The one in libcxxabi -// is the original and the one in llvm is the copy. Use cp-to-llvm.sh to update -// the copy. See README.txt for more details. -// -//===----------------------------------------------------------------------===// - -#ifndef DEMANGLE_UTILITY_H -#define DEMANGLE_UTILITY_H - -#include "StringView.h" -#include <array> -#include <cstdint> -#include <cstdlib> -#include <cstring> -#include <exception> -#include <limits> - -DEMANGLE_NAMESPACE_BEGIN - -// Stream that AST nodes write their string representation into after the AST -// has been parsed. -class OutputBuffer { - char *Buffer = nullptr; - size_t CurrentPosition = 0; - size_t BufferCapacity = 0; - - // Ensure there are at least N more positions in the buffer. - void grow(size_t N) { - size_t Need = N + CurrentPosition; - if (Need > BufferCapacity) { - // Reduce the number of reallocations, with a bit of hysteresis. The - // number here is chosen so the first allocation will more-than-likely not - // allocate more than 1K. - Need += 1024 - 32; - BufferCapacity *= 2; - if (BufferCapacity < Need) - BufferCapacity = Need; - Buffer = static_cast<char *>(std::realloc(Buffer, BufferCapacity)); - if (Buffer == nullptr) - std::terminate(); - } - } - - OutputBuffer &writeUnsigned(uint64_t N, bool isNeg = false) { - std::array<char, 21> Temp; - char *TempPtr = Temp.data() + Temp.size(); - - // Output at least one character. - do { - *--TempPtr = char('0' + N % 10); - N /= 10; - } while (N); - - // Add negative sign. - if (isNeg) - *--TempPtr = '-'; - - return operator+=(StringView(TempPtr, Temp.data() + Temp.size())); - } - -public: - OutputBuffer(char *StartBuf, size_t Size) - : Buffer(StartBuf), BufferCapacity(Size) {} - OutputBuffer(char *StartBuf, size_t *SizePtr) - : OutputBuffer(StartBuf, StartBuf ? *SizePtr : 0) {} - OutputBuffer() = default; - // Non-copyable - OutputBuffer(const OutputBuffer &) = delete; - OutputBuffer &operator=(const OutputBuffer &) = delete; - - operator StringView() const { return StringView(Buffer, CurrentPosition); } - - /// If a ParameterPackExpansion (or similar type) is encountered, the offset - /// into the pack that we're currently printing. - unsigned CurrentPackIndex = std::numeric_limits<unsigned>::max(); - unsigned CurrentPackMax = std::numeric_limits<unsigned>::max(); - - /// When zero, we're printing template args and '>' needs to be parenthesized. - /// Use a counter so we can simply increment inside parentheses. - unsigned GtIsGt = 1; - - bool isGtInsideTemplateArgs() const { return GtIsGt == 0; } - - void printOpen(char Open = '(') { - GtIsGt++; - *this += Open; - } - void printClose(char Close = ')') { - GtIsGt--; - *this += Close; - } - - OutputBuffer &operator+=(StringView R) { - if (size_t Size = R.size()) { - grow(Size); - std::memcpy(Buffer + CurrentPosition, R.begin(), Size); - CurrentPosition += Size; - } - return *this; - } - - OutputBuffer &operator+=(char C) { - grow(1); - Buffer[CurrentPosition++] = C; - return *this; - } - - OutputBuffer &prepend(StringView R) { - size_t Size = R.size(); - - grow(Size); - std::memmove(Buffer + Size, Buffer, CurrentPosition); - std::memcpy(Buffer, R.begin(), Size); - CurrentPosition += Size; - - return *this; - } - - OutputBuffer &operator<<(StringView R) { return (*this += R); } - - OutputBuffer &operator<<(char C) { return (*this += C); } - - OutputBuffer &operator<<(long long N) { - return writeUnsigned(static_cast<unsigned long long>(std::abs(N)), N < 0); - } - - OutputBuffer &operator<<(unsigned long long N) { - return writeUnsigned(N, false); - } - - OutputBuffer &operator<<(long N) { - return this->operator<<(static_cast<long long>(N)); - } - - OutputBuffer &operator<<(unsigned long N) { - return this->operator<<(static_cast<unsigned long long>(N)); - } - - OutputBuffer &operator<<(int N) { - return this->operator<<(static_cast<long long>(N)); - } - - OutputBuffer &operator<<(unsigned int N) { - return this->operator<<(static_cast<unsigned long long>(N)); - } - - void insert(size_t Pos, const char *S, size_t N) { - assert(Pos <= CurrentPosition); - if (N == 0) - return; - grow(N); - std::memmove(Buffer + Pos + N, Buffer + Pos, CurrentPosition - Pos); - std::memcpy(Buffer + Pos, S, N); - CurrentPosition += N; - } - - size_t getCurrentPosition() const { return CurrentPosition; } - void setCurrentPosition(size_t NewPos) { CurrentPosition = NewPos; } - - char back() const { - assert(CurrentPosition); - return Buffer[CurrentPosition - 1]; - } - - bool empty() const { return CurrentPosition == 0; } - - char *getBuffer() { return Buffer; } - char *getBufferEnd() { return Buffer + CurrentPosition - 1; } - size_t getBufferCapacity() const { return BufferCapacity; } -}; - -template <class T> class ScopedOverride { - T &Loc; - T Original; - -public: - ScopedOverride(T &Loc_) : ScopedOverride(Loc_, Loc_) {} - - ScopedOverride(T &Loc_, T NewVal) : Loc(Loc_), Original(Loc_) { - Loc_ = std::move(NewVal); - } - ~ScopedOverride() { Loc = std::move(Original); } - - ScopedOverride(const ScopedOverride &) = delete; - ScopedOverride &operator=(const ScopedOverride &) = delete; -}; - -DEMANGLE_NAMESPACE_END - -#endif diff --git a/demangle/third_party/llvm/lib/Demangle/Demangle.cpp b/demangle/third_party/llvm/lib/Demangle/Demangle.cpp deleted file mode 100644 index b5f2369d..00000000 --- a/demangle/third_party/llvm/lib/Demangle/Demangle.cpp +++ /dev/null @@ -1,68 +0,0 @@ -//===-- Demangle.cpp - Common demangling functions ------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -/// -/// \file This file contains definitions of common demangling functions. -/// -//===----------------------------------------------------------------------===// - -#include "llvm/Demangle/Demangle.h" -#include <cstdlib> -#include <cstring> - -static bool isItaniumEncoding(const char *S) { - // Itanium encoding requires 1 or 3 leading underscores, followed by 'Z'. - return std::strncmp(S, "_Z", 2) == 0 || std::strncmp(S, "___Z", 4) == 0; -} - -#if 0 -static bool isRustEncoding(const char *S) { return S[0] == '_' && S[1] == 'R'; } - -static bool isDLangEncoding(const std::string &MangledName) { - return MangledName.size() >= 2 && MangledName[0] == '_' && - MangledName[1] == 'D'; -} -#endif - -std::string llvm::demangle(const std::string &MangledName) { - std::string Result; - const char *S = MangledName.c_str(); - - if (nonMicrosoftDemangle(S, Result)) - return Result; - - if (S[0] == '_' && nonMicrosoftDemangle(S + 1, Result)) - return Result; - - if (char *Demangled = - microsoftDemangle(S, nullptr, nullptr, nullptr, nullptr)) { - Result = Demangled; - std::free(Demangled); - return Result; - } - - return MangledName; -} - -bool llvm::nonMicrosoftDemangle(const char *MangledName, std::string &Result) { - char *Demangled = nullptr; - if (isItaniumEncoding(MangledName)) - Demangled = itaniumDemangle(MangledName, nullptr, nullptr, nullptr); -#if 0 - else if (isRustEncoding(MangledName)) - Demangled = rustDemangle(MangledName); - else if (isDLangEncoding(MangledName)) - Demangled = dlangDemangle(MangledName); -#endif - - if (!Demangled) - return false; - - Result = Demangled; - std::free(Demangled); - return true; -} diff --git a/demangle/third_party/llvm/lib/Demangle/ItaniumDemangle.cpp b/demangle/third_party/llvm/lib/Demangle/ItaniumDemangle.cpp deleted file mode 100644 index 9b646ea8..00000000 --- a/demangle/third_party/llvm/lib/Demangle/ItaniumDemangle.cpp +++ /dev/null @@ -1,608 +0,0 @@ -//===------------------------- ItaniumDemangle.cpp ------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -// FIXME: (possibly) incomplete list of features that clang mangles that this -// file does not yet support: -// - C++ modules TS - -#include "llvm/Demangle/Demangle.h" -#include "llvm/Demangle/ItaniumDemangle.h" - -#include <cassert> -#include <cctype> -#include <cstdio> -#include <cstdlib> -#include <cstring> -#include <functional> -#include <utility> - -using namespace llvm; -using namespace llvm::itanium_demangle; - -constexpr const char *itanium_demangle::FloatData<float>::spec; -constexpr const char *itanium_demangle::FloatData<double>::spec; -constexpr const char *itanium_demangle::FloatData<long double>::spec; - -// <discriminator> := _ <non-negative number> # when number < 10 -// := __ <non-negative number> _ # when number >= 10 -// extension := decimal-digit+ # at the end of string -const char *itanium_demangle::parse_discriminator(const char *first, - const char *last) { - // parse but ignore discriminator - if (first != last) { - if (*first == '_') { - const char *t1 = first + 1; - if (t1 != last) { - if (std::isdigit(*t1)) - first = t1 + 1; - else if (*t1 == '_') { - for (++t1; t1 != last && std::isdigit(*t1); ++t1) - ; - if (t1 != last && *t1 == '_') - first = t1 + 1; - } - } - } else if (std::isdigit(*first)) { - const char *t1 = first + 1; - for (; t1 != last && std::isdigit(*t1); ++t1) - ; - if (t1 == last) - first = last; - } - } - return first; -} - -#ifndef NDEBUG -namespace { -struct DumpVisitor { - unsigned Depth = 0; - bool PendingNewline = false; - - template<typename NodeT> static constexpr bool wantsNewline(const NodeT *) { - return true; - } - static bool wantsNewline(NodeArray A) { return !A.empty(); } - static constexpr bool wantsNewline(...) { return false; } - - template<typename ...Ts> static bool anyWantNewline(Ts ...Vs) { - for (bool B : {wantsNewline(Vs)...}) - if (B) - return true; - return false; - } - - void printStr(const char *S) { fprintf(stderr, "%s", S); } - void print(StringView SV) { - fprintf(stderr, "\"%.*s\"", (int)SV.size(), SV.begin()); - } - void print(const Node *N) { - if (N) - N->visit(std::ref(*this)); - else - printStr("<null>"); - } - void print(NodeArray A) { - ++Depth; - printStr("{"); - bool First = true; - for (const Node *N : A) { - if (First) - print(N); - else - printWithComma(N); - First = false; - } - printStr("}"); - --Depth; - } - - // Overload used when T is exactly 'bool', not merely convertible to 'bool'. - void print(bool B) { printStr(B ? "true" : "false"); } - - template <class T> std::enable_if_t<std::is_unsigned<T>::value> print(T N) { - fprintf(stderr, "%llu", (unsigned long long)N); - } - - template <class T> std::enable_if_t<std::is_signed<T>::value> print(T N) { - fprintf(stderr, "%lld", (long long)N); - } - - void print(ReferenceKind RK) { - switch (RK) { - case ReferenceKind::LValue: - return printStr("ReferenceKind::LValue"); - case ReferenceKind::RValue: - return printStr("ReferenceKind::RValue"); - } - } - void print(FunctionRefQual RQ) { - switch (RQ) { - case FunctionRefQual::FrefQualNone: - return printStr("FunctionRefQual::FrefQualNone"); - case FunctionRefQual::FrefQualLValue: - return printStr("FunctionRefQual::FrefQualLValue"); - case FunctionRefQual::FrefQualRValue: - return printStr("FunctionRefQual::FrefQualRValue"); - } - } - void print(Qualifiers Qs) { - if (!Qs) return printStr("QualNone"); - struct QualName { Qualifiers Q; const char *Name; } Names[] = { - {QualConst, "QualConst"}, - {QualVolatile, "QualVolatile"}, - {QualRestrict, "QualRestrict"}, - }; - for (QualName Name : Names) { - if (Qs & Name.Q) { - printStr(Name.Name); - Qs = Qualifiers(Qs & ~Name.Q); - if (Qs) printStr(" | "); - } - } - } - void print(SpecialSubKind SSK) { - switch (SSK) { - case SpecialSubKind::allocator: - return printStr("SpecialSubKind::allocator"); - case SpecialSubKind::basic_string: - return printStr("SpecialSubKind::basic_string"); - case SpecialSubKind::string: - return printStr("SpecialSubKind::string"); - case SpecialSubKind::istream: - return printStr("SpecialSubKind::istream"); - case SpecialSubKind::ostream: - return printStr("SpecialSubKind::ostream"); - case SpecialSubKind::iostream: - return printStr("SpecialSubKind::iostream"); - } - } - void print(TemplateParamKind TPK) { - switch (TPK) { - case TemplateParamKind::Type: - return printStr("TemplateParamKind::Type"); - case TemplateParamKind::NonType: - return printStr("TemplateParamKind::NonType"); - case TemplateParamKind::Template: - return printStr("TemplateParamKind::Template"); - } - } - void print(Node::Prec P) { - switch (P) { - case Node::Prec::Primary: - return printStr("Node::Prec::Primary"); - case Node::Prec::Postfix: - return printStr("Node::Prec::Postfix"); - case Node::Prec::Unary: - return printStr("Node::Prec::Unary"); - case Node::Prec::Cast: - return printStr("Node::Prec::Cast"); - case Node::Prec::PtrMem: - return printStr("Node::Prec::PtrMem"); - case Node::Prec::Multiplicative: - return printStr("Node::Prec::Multiplicative"); - case Node::Prec::Additive: - return printStr("Node::Prec::Additive"); - case Node::Prec::Shift: - return printStr("Node::Prec::Shift"); - case Node::Prec::Spaceship: - return printStr("Node::Prec::Spaceship"); - case Node::Prec::Relational: - return printStr("Node::Prec::Relational"); - case Node::Prec::Equality: - return printStr("Node::Prec::Equality"); - case Node::Prec::And: - return printStr("Node::Prec::And"); - case Node::Prec::Xor: - return printStr("Node::Prec::Xor"); - case Node::Prec::Ior: - return printStr("Node::Prec::Ior"); - case Node::Prec::AndIf: - return printStr("Node::Prec::AndIf"); - case Node::Prec::OrIf: - return printStr("Node::Prec::OrIf"); - case Node::Prec::Conditional: - return printStr("Node::Prec::Conditional"); - case Node::Prec::Assign: - return printStr("Node::Prec::Assign"); - case Node::Prec::Comma: - return printStr("Node::Prec::Comma"); - case Node::Prec::Default: - return printStr("Node::Prec::Default"); - } - } - - void newLine() { - printStr("\n"); - for (unsigned I = 0; I != Depth; ++I) - printStr(" "); - PendingNewline = false; - } - - template<typename T> void printWithPendingNewline(T V) { - print(V); - if (wantsNewline(V)) - PendingNewline = true; - } - - template<typename T> void printWithComma(T V) { - if (PendingNewline || wantsNewline(V)) { - printStr(","); - newLine(); - } else { - printStr(", "); - } - - printWithPendingNewline(V); - } - - struct CtorArgPrinter { - DumpVisitor &Visitor; - - template<typename T, typename ...Rest> void operator()(T V, Rest ...Vs) { - if (Visitor.anyWantNewline(V, Vs...)) - Visitor.newLine(); - Visitor.printWithPendingNewline(V); - int PrintInOrder[] = { (Visitor.printWithComma(Vs), 0)..., 0 }; - (void)PrintInOrder; - } - }; - - template<typename NodeT> void operator()(const NodeT *Node) { - Depth += 2; - fprintf(stderr, "%s(", itanium_demangle::NodeKind<NodeT>::name()); - Node->match(CtorArgPrinter{*this}); - fprintf(stderr, ")"); - Depth -= 2; - } - - void operator()(const ForwardTemplateReference *Node) { - Depth += 2; - fprintf(stderr, "ForwardTemplateReference("); - if (Node->Ref && !Node->Printing) { - Node->Printing = true; - CtorArgPrinter{*this}(Node->Ref); - Node->Printing = false; - } else { - CtorArgPrinter{*this}(Node->Index); - } - fprintf(stderr, ")"); - Depth -= 2; - } -}; -} - -void itanium_demangle::Node::dump() const { - DumpVisitor V; - visit(std::ref(V)); - V.newLine(); -} -#endif - -namespace { -class BumpPointerAllocator { - struct BlockMeta { - BlockMeta* Next; - size_t Current; - }; - - static constexpr size_t AllocSize = 4096; - static constexpr size_t UsableAllocSize = AllocSize - sizeof(BlockMeta); - - alignas(long double) char InitialBuffer[AllocSize]; - BlockMeta* BlockList = nullptr; - - void grow() { - char* NewMeta = static_cast<char *>(std::malloc(AllocSize)); - if (NewMeta == nullptr) - std::terminate(); - BlockList = new (NewMeta) BlockMeta{BlockList, 0}; - } - - void* allocateMassive(size_t NBytes) { - NBytes += sizeof(BlockMeta); - BlockMeta* NewMeta = reinterpret_cast<BlockMeta*>(std::malloc(NBytes)); - if (NewMeta == nullptr) - std::terminate(); - BlockList->Next = new (NewMeta) BlockMeta{BlockList->Next, 0}; - return static_cast<void*>(NewMeta + 1); - } - -public: - BumpPointerAllocator() - : BlockList(new (InitialBuffer) BlockMeta{nullptr, 0}) {} - - void* allocate(size_t N) { - N = (N + 15u) & ~15u; - if (N + BlockList->Current >= UsableAllocSize) { - if (N > UsableAllocSize) - return allocateMassive(N); - grow(); - } - BlockList->Current += N; - return static_cast<void*>(reinterpret_cast<char*>(BlockList + 1) + - BlockList->Current - N); - } - - void reset() { - while (BlockList) { - BlockMeta* Tmp = BlockList; - BlockList = BlockList->Next; - if (reinterpret_cast<char*>(Tmp) != InitialBuffer) - std::free(Tmp); - } - BlockList = new (InitialBuffer) BlockMeta{nullptr, 0}; - } - - ~BumpPointerAllocator() { reset(); } -}; - -class DefaultAllocator { - BumpPointerAllocator Alloc; - -public: - void reset() { Alloc.reset(); } - - template<typename T, typename ...Args> T *makeNode(Args &&...args) { - return new (Alloc.allocate(sizeof(T))) - T(std::forward<Args>(args)...); - } - - void *allocateNodeArray(size_t sz) { - return Alloc.allocate(sizeof(Node *) * sz); - } -}; -} // unnamed namespace - -//===----------------------------------------------------------------------===// -// Code beyond this point should not be synchronized with libc++abi. -//===----------------------------------------------------------------------===// - -using Demangler = itanium_demangle::ManglingParser<DefaultAllocator>; - -char *llvm::itaniumDemangle(const char *MangledName, char *Buf, - size_t *N, int *Status) { - if (MangledName == nullptr || (Buf != nullptr && N == nullptr)) { - if (Status) - *Status = demangle_invalid_args; - return nullptr; - } - - int InternalStatus = demangle_success; - Demangler Parser(MangledName, MangledName + std::strlen(MangledName)); - Node *AST = Parser.parse(); - - if (AST == nullptr) - InternalStatus = demangle_invalid_mangled_name; - else { - OutputBuffer OB(Buf, N); - assert(Parser.ForwardTemplateRefs.empty()); - AST->print(OB); - OB += '\0'; - if (N != nullptr) - *N = OB.getCurrentPosition(); - Buf = OB.getBuffer(); - } - - if (Status) - *Status = InternalStatus; - return InternalStatus == demangle_success ? Buf : nullptr; -} - -ItaniumPartialDemangler::ItaniumPartialDemangler() - : RootNode(nullptr), Context(new Demangler{nullptr, nullptr}) {} - -ItaniumPartialDemangler::~ItaniumPartialDemangler() { - delete static_cast<Demangler *>(Context); -} - -ItaniumPartialDemangler::ItaniumPartialDemangler( - ItaniumPartialDemangler &&Other) - : RootNode(Other.RootNode), Context(Other.Context) { - Other.Context = Other.RootNode = nullptr; -} - -ItaniumPartialDemangler &ItaniumPartialDemangler:: -operator=(ItaniumPartialDemangler &&Other) { - std::swap(RootNode, Other.RootNode); - std::swap(Context, Other.Context); - return *this; -} - -// Demangle MangledName into an AST, storing it into this->RootNode. -bool ItaniumPartialDemangler::partialDemangle(const char *MangledName) { - Demangler *Parser = static_cast<Demangler *>(Context); - size_t Len = std::strlen(MangledName); - Parser->reset(MangledName, MangledName + Len); - RootNode = Parser->parse(); - return RootNode == nullptr; -} - -static char *printNode(const Node *RootNode, char *Buf, size_t *N) { - OutputBuffer OB(Buf, N); - RootNode->print(OB); - OB += '\0'; - if (N != nullptr) - *N = OB.getCurrentPosition(); - return OB.getBuffer(); -} - -char *ItaniumPartialDemangler::getFunctionBaseName(char *Buf, size_t *N) const { - if (!isFunction()) - return nullptr; - - const Node *Name = static_cast<const FunctionEncoding *>(RootNode)->getName(); - - while (true) { - switch (Name->getKind()) { - case Node::KAbiTagAttr: - Name = static_cast<const AbiTagAttr *>(Name)->Base; - continue; - case Node::KModuleEntity: - Name = static_cast<const ModuleEntity *>(Name)->Name; - continue; - case Node::KNestedName: - Name = static_cast<const NestedName *>(Name)->Name; - continue; - case Node::KLocalName: - Name = static_cast<const LocalName *>(Name)->Entity; - continue; - case Node::KNameWithTemplateArgs: - Name = static_cast<const NameWithTemplateArgs *>(Name)->Name; - continue; - default: - return printNode(Name, Buf, N); - } - } -} - -char *ItaniumPartialDemangler::getFunctionDeclContextName(char *Buf, - size_t *N) const { - if (!isFunction()) - return nullptr; - const Node *Name = static_cast<const FunctionEncoding *>(RootNode)->getName(); - - OutputBuffer OB(Buf, N); - - KeepGoingLocalFunction: - while (true) { - if (Name->getKind() == Node::KAbiTagAttr) { - Name = static_cast<const AbiTagAttr *>(Name)->Base; - continue; - } - if (Name->getKind() == Node::KNameWithTemplateArgs) { - Name = static_cast<const NameWithTemplateArgs *>(Name)->Name; - continue; - } - break; - } - - if (Name->getKind() == Node::KModuleEntity) - Name = static_cast<const ModuleEntity *>(Name)->Name; - - switch (Name->getKind()) { - case Node::KNestedName: - static_cast<const NestedName *>(Name)->Qual->print(OB); - break; - case Node::KLocalName: { - auto *LN = static_cast<const LocalName *>(Name); - LN->Encoding->print(OB); - OB += "::"; - Name = LN->Entity; - goto KeepGoingLocalFunction; - } - default: - break; - } - OB += '\0'; - if (N != nullptr) - *N = OB.getCurrentPosition(); - return OB.getBuffer(); -} - -char *ItaniumPartialDemangler::getFunctionName(char *Buf, size_t *N) const { - if (!isFunction()) - return nullptr; - auto *Name = static_cast<FunctionEncoding *>(RootNode)->getName(); - return printNode(Name, Buf, N); -} - -char *ItaniumPartialDemangler::getFunctionParameters(char *Buf, - size_t *N) const { - if (!isFunction()) - return nullptr; - NodeArray Params = static_cast<FunctionEncoding *>(RootNode)->getParams(); - - OutputBuffer OB(Buf, N); - - OB += '('; - Params.printWithComma(OB); - OB += ')'; - OB += '\0'; - if (N != nullptr) - *N = OB.getCurrentPosition(); - return OB.getBuffer(); -} - -char *ItaniumPartialDemangler::getFunctionReturnType( - char *Buf, size_t *N) const { - if (!isFunction()) - return nullptr; - - OutputBuffer OB(Buf, N); - - if (const Node *Ret = - static_cast<const FunctionEncoding *>(RootNode)->getReturnType()) - Ret->print(OB); - - OB += '\0'; - if (N != nullptr) - *N = OB.getCurrentPosition(); - return OB.getBuffer(); -} - -char *ItaniumPartialDemangler::finishDemangle(char *Buf, size_t *N) const { - assert(RootNode != nullptr && "must call partialDemangle()"); - return printNode(static_cast<Node *>(RootNode), Buf, N); -} - -bool ItaniumPartialDemangler::hasFunctionQualifiers() const { - assert(RootNode != nullptr && "must call partialDemangle()"); - if (!isFunction()) - return false; - auto *E = static_cast<const FunctionEncoding *>(RootNode); - return E->getCVQuals() != QualNone || E->getRefQual() != FrefQualNone; -} - -bool ItaniumPartialDemangler::isCtorOrDtor() const { - const Node *N = static_cast<const Node *>(RootNode); - while (N) { - switch (N->getKind()) { - default: - return false; - case Node::KCtorDtorName: - return true; - - case Node::KAbiTagAttr: - N = static_cast<const AbiTagAttr *>(N)->Base; - break; - case Node::KFunctionEncoding: - N = static_cast<const FunctionEncoding *>(N)->getName(); - break; - case Node::KLocalName: - N = static_cast<const LocalName *>(N)->Entity; - break; - case Node::KNameWithTemplateArgs: - N = static_cast<const NameWithTemplateArgs *>(N)->Name; - break; - case Node::KNestedName: - N = static_cast<const NestedName *>(N)->Name; - break; - case Node::KModuleEntity: - N = static_cast<const ModuleEntity *>(N)->Name; - break; - } - } - return false; -} - -bool ItaniumPartialDemangler::isFunction() const { - assert(RootNode != nullptr && "must call partialDemangle()"); - return static_cast<const Node *>(RootNode)->getKind() == - Node::KFunctionEncoding; -} - -bool ItaniumPartialDemangler::isSpecialName() const { - assert(RootNode != nullptr && "must call partialDemangle()"); - auto K = static_cast<const Node *>(RootNode)->getKind(); - return K == Node::KSpecialName || K == Node::KCtorVtableSpecialName; -} - -bool ItaniumPartialDemangler::isData() const { - return !isFunction() && !isSpecialName(); -} diff --git a/demangle/third_party/llvm/lib/Demangle/MicrosoftDemangle.cpp b/demangle/third_party/llvm/lib/Demangle/MicrosoftDemangle.cpp deleted file mode 100644 index c21b0a30..00000000 --- a/demangle/third_party/llvm/lib/Demangle/MicrosoftDemangle.cpp +++ /dev/null @@ -1,2368 +0,0 @@ -//===- MicrosoftDemangle.cpp ----------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file defines a demangler for MSVC-style mangled symbols. -// -// This file has no dependencies on the rest of LLVM so that it can be -// easily reused in other programs such as libcxxabi. -// -//===----------------------------------------------------------------------===// - -#include "llvm/Demangle/MicrosoftDemangle.h" -#include "llvm/Demangle/Demangle.h" -#include "llvm/Demangle/MicrosoftDemangleNodes.h" - -#include "llvm/Demangle/DemangleConfig.h" -#include "llvm/Demangle/StringView.h" -#include "llvm/Demangle/Utility.h" - -#include <array> -#include <cctype> -#include <cstdio> -#include <tuple> - -using namespace llvm; -using namespace ms_demangle; - -static bool startsWithDigit(StringView S) { - return !S.empty() && std::isdigit(S.front()); -} - - -struct NodeList { - Node *N = nullptr; - NodeList *Next = nullptr; -}; - -static bool isMemberPointer(StringView MangledName, bool &Error) { - Error = false; - switch (MangledName.popFront()) { - case '$': - // This is probably an rvalue reference (e.g. $$Q), and you cannot have an - // rvalue reference to a member. - return false; - case 'A': - // 'A' indicates a reference, and you cannot have a reference to a member - // function or member. - return false; - case 'P': - case 'Q': - case 'R': - case 'S': - // These 4 values indicate some kind of pointer, but we still don't know - // what. - break; - default: - // isMemberPointer() is called only if isPointerType() returns true, - // and it rejects other prefixes. - DEMANGLE_UNREACHABLE; - } - - // If it starts with a number, then 6 indicates a non-member function - // pointer, and 8 indicates a member function pointer. - if (startsWithDigit(MangledName)) { - if (MangledName[0] != '6' && MangledName[0] != '8') { - Error = true; - return false; - } - return (MangledName[0] == '8'); - } - - // Remove ext qualifiers since those can appear on either type and are - // therefore not indicative. - MangledName.consumeFront('E'); // 64-bit - MangledName.consumeFront('I'); // restrict - MangledName.consumeFront('F'); // unaligned - - if (MangledName.empty()) { - Error = true; - return false; - } - - // The next value should be either ABCD (non-member) or QRST (member). - switch (MangledName.front()) { - case 'A': - case 'B': - case 'C': - case 'D': - return false; - case 'Q': - case 'R': - case 'S': - case 'T': - return true; - default: - Error = true; - return false; - } -} - -static SpecialIntrinsicKind -consumeSpecialIntrinsicKind(StringView &MangledName) { - if (MangledName.consumeFront("?_7")) - return SpecialIntrinsicKind::Vftable; - if (MangledName.consumeFront("?_8")) - return SpecialIntrinsicKind::Vbtable; - if (MangledName.consumeFront("?_9")) - return SpecialIntrinsicKind::VcallThunk; - if (MangledName.consumeFront("?_A")) - return SpecialIntrinsicKind::Typeof; - if (MangledName.consumeFront("?_B")) - return SpecialIntrinsicKind::LocalStaticGuard; - if (MangledName.consumeFront("?_C")) - return SpecialIntrinsicKind::StringLiteralSymbol; - if (MangledName.consumeFront("?_P")) - return SpecialIntrinsicKind::UdtReturning; - if (MangledName.consumeFront("?_R0")) - return SpecialIntrinsicKind::RttiTypeDescriptor; - if (MangledName.consumeFront("?_R1")) - return SpecialIntrinsicKind::RttiBaseClassDescriptor; - if (MangledName.consumeFront("?_R2")) - return SpecialIntrinsicKind::RttiBaseClassArray; - if (MangledName.consumeFront("?_R3")) - return SpecialIntrinsicKind::RttiClassHierarchyDescriptor; - if (MangledName.consumeFront("?_R4")) - return SpecialIntrinsicKind::RttiCompleteObjLocator; - if (MangledName.consumeFront("?_S")) - return SpecialIntrinsicKind::LocalVftable; - if (MangledName.consumeFront("?__E")) - return SpecialIntrinsicKind::DynamicInitializer; - if (MangledName.consumeFront("?__F")) - return SpecialIntrinsicKind::DynamicAtexitDestructor; - if (MangledName.consumeFront("?__J")) - return SpecialIntrinsicKind::LocalStaticThreadGuard; - return SpecialIntrinsicKind::None; -} - -static bool startsWithLocalScopePattern(StringView S) { - if (!S.consumeFront('?')) - return false; - - size_t End = S.find('?'); - if (End == StringView::npos) - return false; - StringView Candidate = S.substr(0, End); - if (Candidate.empty()) - return false; - - // \?[0-9]\? - // ?@? is the discriminator 0. - if (Candidate.size() == 1) - return Candidate[0] == '@' || (Candidate[0] >= '0' && Candidate[0] <= '9'); - - // If it's not 0-9, then it's an encoded number terminated with an @ - if (Candidate.back() != '@') - return false; - Candidate = Candidate.dropBack(); - - // An encoded number starts with B-P and all subsequent digits are in A-P. - // Note that the reason the first digit cannot be A is two fold. First, it - // would create an ambiguity with ?A which delimits the beginning of an - // anonymous namespace. Second, A represents 0, and you don't start a multi - // digit number with a leading 0. Presumably the anonymous namespace - // ambiguity is also why single digit encoded numbers use 0-9 rather than A-J. - if (Candidate[0] < 'B' || Candidate[0] > 'P') - return false; - Candidate = Candidate.dropFront(); - while (!Candidate.empty()) { - if (Candidate[0] < 'A' || Candidate[0] > 'P') - return false; - Candidate = Candidate.dropFront(); - } - - return true; -} - -static bool isTagType(StringView S) { - switch (S.front()) { - case 'T': // union - case 'U': // struct - case 'V': // class - case 'W': // enum - return true; - } - return false; -} - -static bool isCustomType(StringView S) { return S[0] == '?'; } - -static bool isPointerType(StringView S) { - if (S.startsWith("$$Q")) // foo && - return true; - - switch (S.front()) { - case 'A': // foo & - case 'P': // foo * - case 'Q': // foo *const - case 'R': // foo *volatile - case 'S': // foo *const volatile - return true; - } - return false; -} - -static bool isArrayType(StringView S) { return S[0] == 'Y'; } - -static bool isFunctionType(StringView S) { - return S.startsWith("$$A8@@") || S.startsWith("$$A6"); -} - -static FunctionRefQualifier -demangleFunctionRefQualifier(StringView &MangledName) { - if (MangledName.consumeFront('G')) - return FunctionRefQualifier::Reference; - else if (MangledName.consumeFront('H')) - return FunctionRefQualifier::RValueReference; - return FunctionRefQualifier::None; -} - -static std::pair<Qualifiers, PointerAffinity> -demanglePointerCVQualifiers(StringView &MangledName) { - if (MangledName.consumeFront("$$Q")) - return std::make_pair(Q_None, PointerAffinity::RValueReference); - - switch (MangledName.popFront()) { - case 'A': - return std::make_pair(Q_None, PointerAffinity::Reference); - case 'P': - return std::make_pair(Q_None, PointerAffinity::Pointer); - case 'Q': - return std::make_pair(Q_Const, PointerAffinity::Pointer); - case 'R': - return std::make_pair(Q_Volatile, PointerAffinity::Pointer); - case 'S': - return std::make_pair(Qualifiers(Q_Const | Q_Volatile), - PointerAffinity::Pointer); - } - // This function is only called if isPointerType() returns true, - // and it only returns true for the six cases listed above. - DEMANGLE_UNREACHABLE; -} - -StringView Demangler::copyString(StringView Borrowed) { - char *Stable = Arena.allocUnalignedBuffer(Borrowed.size()); - // This is not a micro-optimization, it avoids UB, should Borrowed be an null - // buffer. - if (Borrowed.size()) - std::memcpy(Stable, Borrowed.begin(), Borrowed.size()); - - return {Stable, Borrowed.size()}; -} - -SpecialTableSymbolNode * -Demangler::demangleSpecialTableSymbolNode(StringView &MangledName, - SpecialIntrinsicKind K) { - NamedIdentifierNode *NI = Arena.alloc<NamedIdentifierNode>(); - switch (K) { - case SpecialIntrinsicKind::Vftable: - NI->Name = "`vftable'"; - break; - case SpecialIntrinsicKind::Vbtable: - NI->Name = "`vbtable'"; - break; - case SpecialIntrinsicKind::LocalVftable: - NI->Name = "`local vftable'"; - break; - case SpecialIntrinsicKind::RttiCompleteObjLocator: - NI->Name = "`RTTI Complete Object Locator'"; - break; - default: - DEMANGLE_UNREACHABLE; - } - QualifiedNameNode *QN = demangleNameScopeChain(MangledName, NI); - SpecialTableSymbolNode *STSN = Arena.alloc<SpecialTableSymbolNode>(); - STSN->Name = QN; - bool IsMember = false; - if (MangledName.empty()) { - Error = true; - return nullptr; - } - char Front = MangledName.popFront(); - if (Front != '6' && Front != '7') { - Error = true; - return nullptr; - } - - std::tie(STSN->Quals, IsMember) = demangleQualifiers(MangledName); - if (!MangledName.consumeFront('@')) - STSN->TargetName = demangleFullyQualifiedTypeName(MangledName); - return STSN; -} - -LocalStaticGuardVariableNode * -Demangler::demangleLocalStaticGuard(StringView &MangledName, bool IsThread) { - LocalStaticGuardIdentifierNode *LSGI = - Arena.alloc<LocalStaticGuardIdentifierNode>(); - LSGI->IsThread = IsThread; - QualifiedNameNode *QN = demangleNameScopeChain(MangledName, LSGI); - LocalStaticGuardVariableNode *LSGVN = - Arena.alloc<LocalStaticGuardVariableNode>(); - LSGVN->Name = QN; - - if (MangledName.consumeFront("4IA")) - LSGVN->IsVisible = false; - else if (MangledName.consumeFront("5")) - LSGVN->IsVisible = true; - else { - Error = true; - return nullptr; - } - - if (!MangledName.empty()) - LSGI->ScopeIndex = demangleUnsigned(MangledName); - return LSGVN; -} - -static NamedIdentifierNode *synthesizeNamedIdentifier(ArenaAllocator &Arena, - StringView Name) { - NamedIdentifierNode *Id = Arena.alloc<NamedIdentifierNode>(); - Id->Name = Name; - return Id; -} - -static QualifiedNameNode *synthesizeQualifiedName(ArenaAllocator &Arena, - IdentifierNode *Identifier) { - QualifiedNameNode *QN = Arena.alloc<QualifiedNameNode>(); - QN->Components = Arena.alloc<NodeArrayNode>(); - QN->Components->Count = 1; - QN->Components->Nodes = Arena.allocArray<Node *>(1); - QN->Components->Nodes[0] = Identifier; - return QN; -} - -static QualifiedNameNode *synthesizeQualifiedName(ArenaAllocator &Arena, - StringView Name) { - NamedIdentifierNode *Id = synthesizeNamedIdentifier(Arena, Name); - return synthesizeQualifiedName(Arena, Id); -} - -static VariableSymbolNode *synthesizeVariable(ArenaAllocator &Arena, - TypeNode *Type, - StringView VariableName) { - VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>(); - VSN->Type = Type; - VSN->Name = synthesizeQualifiedName(Arena, VariableName); - return VSN; -} - -VariableSymbolNode *Demangler::demangleUntypedVariable( - ArenaAllocator &Arena, StringView &MangledName, StringView VariableName) { - NamedIdentifierNode *NI = synthesizeNamedIdentifier(Arena, VariableName); - QualifiedNameNode *QN = demangleNameScopeChain(MangledName, NI); - VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>(); - VSN->Name = QN; - if (MangledName.consumeFront("8")) - return VSN; - - Error = true; - return nullptr; -} - -VariableSymbolNode * -Demangler::demangleRttiBaseClassDescriptorNode(ArenaAllocator &Arena, - StringView &MangledName) { - RttiBaseClassDescriptorNode *RBCDN = - Arena.alloc<RttiBaseClassDescriptorNode>(); - RBCDN->NVOffset = demangleUnsigned(MangledName); - RBCDN->VBPtrOffset = demangleSigned(MangledName); - RBCDN->VBTableOffset = demangleUnsigned(MangledName); - RBCDN->Flags = demangleUnsigned(MangledName); - if (Error) - return nullptr; - - VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>(); - VSN->Name = demangleNameScopeChain(MangledName, RBCDN); - MangledName.consumeFront('8'); - return VSN; -} - -FunctionSymbolNode *Demangler::demangleInitFiniStub(StringView &MangledName, - bool IsDestructor) { - DynamicStructorIdentifierNode *DSIN = - Arena.alloc<DynamicStructorIdentifierNode>(); - DSIN->IsDestructor = IsDestructor; - - bool IsKnownStaticDataMember = false; - if (MangledName.consumeFront('?')) - IsKnownStaticDataMember = true; - - SymbolNode *Symbol = demangleDeclarator(MangledName); - if (Error) - return nullptr; - - FunctionSymbolNode *FSN = nullptr; - - if (Symbol->kind() == NodeKind::VariableSymbol) { - DSIN->Variable = static_cast<VariableSymbolNode *>(Symbol); - - // Older versions of clang mangled this type of symbol incorrectly. They - // would omit the leading ? and they would only emit a single @ at the end. - // The correct mangling is a leading ? and 2 trailing @ signs. Handle - // both cases. - int AtCount = IsKnownStaticDataMember ? 2 : 1; - for (int I = 0; I < AtCount; ++I) { - if (MangledName.consumeFront('@')) - continue; - Error = true; - return nullptr; - } - - FSN = demangleFunctionEncoding(MangledName); - if (FSN) - FSN->Name = synthesizeQualifiedName(Arena, DSIN); - } else { - if (IsKnownStaticDataMember) { - // This was supposed to be a static data member, but we got a function. - Error = true; - return nullptr; - } - - FSN = static_cast<FunctionSymbolNode *>(Symbol); - DSIN->Name = Symbol->Name; - FSN->Name = synthesizeQualifiedName(Arena, DSIN); - } - - return FSN; -} - -SymbolNode *Demangler::demangleSpecialIntrinsic(StringView &MangledName) { - SpecialIntrinsicKind SIK = consumeSpecialIntrinsicKind(MangledName); - - switch (SIK) { - case SpecialIntrinsicKind::None: - return nullptr; - case SpecialIntrinsicKind::StringLiteralSymbol: - return demangleStringLiteral(MangledName); - case SpecialIntrinsicKind::Vftable: - case SpecialIntrinsicKind::Vbtable: - case SpecialIntrinsicKind::LocalVftable: - case SpecialIntrinsicKind::RttiCompleteObjLocator: - return demangleSpecialTableSymbolNode(MangledName, SIK); - case SpecialIntrinsicKind::VcallThunk: - return demangleVcallThunkNode(MangledName); - case SpecialIntrinsicKind::LocalStaticGuard: - return demangleLocalStaticGuard(MangledName, /*IsThread=*/false); - case SpecialIntrinsicKind::LocalStaticThreadGuard: - return demangleLocalStaticGuard(MangledName, /*IsThread=*/true); - case SpecialIntrinsicKind::RttiTypeDescriptor: { - TypeNode *T = demangleType(MangledName, QualifierMangleMode::Result); - if (Error) - break; - if (!MangledName.consumeFront("@8")) - break; - if (!MangledName.empty()) - break; - return synthesizeVariable(Arena, T, "`RTTI Type Descriptor'"); - } - case SpecialIntrinsicKind::RttiBaseClassArray: - return demangleUntypedVariable(Arena, MangledName, - "`RTTI Base Class Array'"); - case SpecialIntrinsicKind::RttiClassHierarchyDescriptor: - return demangleUntypedVariable(Arena, MangledName, - "`RTTI Class Hierarchy Descriptor'"); - case SpecialIntrinsicKind::RttiBaseClassDescriptor: - return demangleRttiBaseClassDescriptorNode(Arena, MangledName); - case SpecialIntrinsicKind::DynamicInitializer: - return demangleInitFiniStub(MangledName, /*IsDestructor=*/false); - case SpecialIntrinsicKind::DynamicAtexitDestructor: - return demangleInitFiniStub(MangledName, /*IsDestructor=*/true); - case SpecialIntrinsicKind::Typeof: - case SpecialIntrinsicKind::UdtReturning: - // It's unclear which tools produces these manglings, so demangling - // support is not (yet?) implemented. - break; - case SpecialIntrinsicKind::Unknown: - DEMANGLE_UNREACHABLE; // Never returned by consumeSpecialIntrinsicKind. - } - Error = true; - return nullptr; -} - -IdentifierNode * -Demangler::demangleFunctionIdentifierCode(StringView &MangledName) { - assert(MangledName.startsWith('?')); - MangledName = MangledName.dropFront(); - if (MangledName.empty()) { - Error = true; - return nullptr; - } - - if (MangledName.consumeFront("__")) - return demangleFunctionIdentifierCode( - MangledName, FunctionIdentifierCodeGroup::DoubleUnder); - if (MangledName.consumeFront("_")) - return demangleFunctionIdentifierCode(MangledName, - FunctionIdentifierCodeGroup::Under); - return demangleFunctionIdentifierCode(MangledName, - FunctionIdentifierCodeGroup::Basic); -} - -StructorIdentifierNode * -Demangler::demangleStructorIdentifier(StringView &MangledName, - bool IsDestructor) { - StructorIdentifierNode *N = Arena.alloc<StructorIdentifierNode>(); - N->IsDestructor = IsDestructor; - return N; -} - -ConversionOperatorIdentifierNode * -Demangler::demangleConversionOperatorIdentifier(StringView &MangledName) { - ConversionOperatorIdentifierNode *N = - Arena.alloc<ConversionOperatorIdentifierNode>(); - return N; -} - -LiteralOperatorIdentifierNode * -Demangler::demangleLiteralOperatorIdentifier(StringView &MangledName) { - LiteralOperatorIdentifierNode *N = - Arena.alloc<LiteralOperatorIdentifierNode>(); - N->Name = demangleSimpleString(MangledName, /*Memorize=*/false); - return N; -} - -IntrinsicFunctionKind -Demangler::translateIntrinsicFunctionCode(char CH, - FunctionIdentifierCodeGroup Group) { - using IFK = IntrinsicFunctionKind; - if (!(CH >= '0' && CH <= '9') && !(CH >= 'A' && CH <= 'Z')) { - Error = true; - return IFK::None; - } - - // Not all ? identifiers are intrinsics *functions*. This function only maps - // operator codes for the special functions, all others are handled elsewhere, - // hence the IFK::None entries in the table. - static IFK Basic[36] = { - IFK::None, // ?0 # Foo::Foo() - IFK::None, // ?1 # Foo::~Foo() - IFK::New, // ?2 # operator new - IFK::Delete, // ?3 # operator delete - IFK::Assign, // ?4 # operator= - IFK::RightShift, // ?5 # operator>> - IFK::LeftShift, // ?6 # operator<< - IFK::LogicalNot, // ?7 # operator! - IFK::Equals, // ?8 # operator== - IFK::NotEquals, // ?9 # operator!= - IFK::ArraySubscript, // ?A # operator[] - IFK::None, // ?B # Foo::operator <type>() - IFK::Pointer, // ?C # operator-> - IFK::Dereference, // ?D # operator* - IFK::Increment, // ?E # operator++ - IFK::Decrement, // ?F # operator-- - IFK::Minus, // ?G # operator- - IFK::Plus, // ?H # operator+ - IFK::BitwiseAnd, // ?I # operator& - IFK::MemberPointer, // ?J # operator->* - IFK::Divide, // ?K # operator/ - IFK::Modulus, // ?L # operator% - IFK::LessThan, // ?M operator< - IFK::LessThanEqual, // ?N operator<= - IFK::GreaterThan, // ?O operator> - IFK::GreaterThanEqual, // ?P operator>= - IFK::Comma, // ?Q operator, - IFK::Parens, // ?R operator() - IFK::BitwiseNot, // ?S operator~ - IFK::BitwiseXor, // ?T operator^ - IFK::BitwiseOr, // ?U operator| - IFK::LogicalAnd, // ?V operator&& - IFK::LogicalOr, // ?W operator|| - IFK::TimesEqual, // ?X operator*= - IFK::PlusEqual, // ?Y operator+= - IFK::MinusEqual, // ?Z operator-= - }; - static IFK Under[36] = { - IFK::DivEqual, // ?_0 operator/= - IFK::ModEqual, // ?_1 operator%= - IFK::RshEqual, // ?_2 operator>>= - IFK::LshEqual, // ?_3 operator<<= - IFK::BitwiseAndEqual, // ?_4 operator&= - IFK::BitwiseOrEqual, // ?_5 operator|= - IFK::BitwiseXorEqual, // ?_6 operator^= - IFK::None, // ?_7 # vftable - IFK::None, // ?_8 # vbtable - IFK::None, // ?_9 # vcall - IFK::None, // ?_A # typeof - IFK::None, // ?_B # local static guard - IFK::None, // ?_C # string literal - IFK::VbaseDtor, // ?_D # vbase destructor - IFK::VecDelDtor, // ?_E # vector deleting destructor - IFK::DefaultCtorClosure, // ?_F # default constructor closure - IFK::ScalarDelDtor, // ?_G # scalar deleting destructor - IFK::VecCtorIter, // ?_H # vector constructor iterator - IFK::VecDtorIter, // ?_I # vector destructor iterator - IFK::VecVbaseCtorIter, // ?_J # vector vbase constructor iterator - IFK::VdispMap, // ?_K # virtual displacement map - IFK::EHVecCtorIter, // ?_L # eh vector constructor iterator - IFK::EHVecDtorIter, // ?_M # eh vector destructor iterator - IFK::EHVecVbaseCtorIter, // ?_N # eh vector vbase constructor iterator - IFK::CopyCtorClosure, // ?_O # copy constructor closure - IFK::None, // ?_P<name> # udt returning <name> - IFK::None, // ?_Q # <unknown> - IFK::None, // ?_R0 - ?_R4 # RTTI Codes - IFK::None, // ?_S # local vftable - IFK::LocalVftableCtorClosure, // ?_T # local vftable constructor closure - IFK::ArrayNew, // ?_U operator new[] - IFK::ArrayDelete, // ?_V operator delete[] - IFK::None, // ?_W <unused> - IFK::None, // ?_X <unused> - IFK::None, // ?_Y <unused> - IFK::None, // ?_Z <unused> - }; - static IFK DoubleUnder[36] = { - IFK::None, // ?__0 <unused> - IFK::None, // ?__1 <unused> - IFK::None, // ?__2 <unused> - IFK::None, // ?__3 <unused> - IFK::None, // ?__4 <unused> - IFK::None, // ?__5 <unused> - IFK::None, // ?__6 <unused> - IFK::None, // ?__7 <unused> - IFK::None, // ?__8 <unused> - IFK::None, // ?__9 <unused> - IFK::ManVectorCtorIter, // ?__A managed vector ctor iterator - IFK::ManVectorDtorIter, // ?__B managed vector dtor iterator - IFK::EHVectorCopyCtorIter, // ?__C EH vector copy ctor iterator - IFK::EHVectorVbaseCopyCtorIter, // ?__D EH vector vbase copy ctor iter - IFK::None, // ?__E dynamic initializer for `T' - IFK::None, // ?__F dynamic atexit destructor for `T' - IFK::VectorCopyCtorIter, // ?__G vector copy constructor iter - IFK::VectorVbaseCopyCtorIter, // ?__H vector vbase copy ctor iter - IFK::ManVectorVbaseCopyCtorIter, // ?__I managed vector vbase copy ctor - // iter - IFK::None, // ?__J local static thread guard - IFK::None, // ?__K operator ""_name - IFK::CoAwait, // ?__L operator co_await - IFK::Spaceship, // ?__M operator<=> - IFK::None, // ?__N <unused> - IFK::None, // ?__O <unused> - IFK::None, // ?__P <unused> - IFK::None, // ?__Q <unused> - IFK::None, // ?__R <unused> - IFK::None, // ?__S <unused> - IFK::None, // ?__T <unused> - IFK::None, // ?__U <unused> - IFK::None, // ?__V <unused> - IFK::None, // ?__W <unused> - IFK::None, // ?__X <unused> - IFK::None, // ?__Y <unused> - IFK::None, // ?__Z <unused> - }; - - int Index = (CH >= '0' && CH <= '9') ? (CH - '0') : (CH - 'A' + 10); - switch (Group) { - case FunctionIdentifierCodeGroup::Basic: - return Basic[Index]; - case FunctionIdentifierCodeGroup::Under: - return Under[Index]; - case FunctionIdentifierCodeGroup::DoubleUnder: - return DoubleUnder[Index]; - } - DEMANGLE_UNREACHABLE; -} - -IdentifierNode * -Demangler::demangleFunctionIdentifierCode(StringView &MangledName, - FunctionIdentifierCodeGroup Group) { - if (MangledName.empty()) { - Error = true; - return nullptr; - } - switch (Group) { - case FunctionIdentifierCodeGroup::Basic: - switch (char CH = MangledName.popFront()) { - case '0': - case '1': - return demangleStructorIdentifier(MangledName, CH == '1'); - case 'B': - return demangleConversionOperatorIdentifier(MangledName); - default: - return Arena.alloc<IntrinsicFunctionIdentifierNode>( - translateIntrinsicFunctionCode(CH, Group)); - } - case FunctionIdentifierCodeGroup::Under: - return Arena.alloc<IntrinsicFunctionIdentifierNode>( - translateIntrinsicFunctionCode(MangledName.popFront(), Group)); - case FunctionIdentifierCodeGroup::DoubleUnder: - switch (char CH = MangledName.popFront()) { - case 'K': - return demangleLiteralOperatorIdentifier(MangledName); - default: - return Arena.alloc<IntrinsicFunctionIdentifierNode>( - translateIntrinsicFunctionCode(CH, Group)); - } - } - - DEMANGLE_UNREACHABLE; -} - -SymbolNode *Demangler::demangleEncodedSymbol(StringView &MangledName, - QualifiedNameNode *Name) { - if (MangledName.empty()) { - Error = true; - return nullptr; - } - - // Read a variable. - switch (MangledName.front()) { - case '0': - case '1': - case '2': - case '3': - case '4': { - StorageClass SC = demangleVariableStorageClass(MangledName); - return demangleVariableEncoding(MangledName, SC); - } - } - FunctionSymbolNode *FSN = demangleFunctionEncoding(MangledName); - - IdentifierNode *UQN = Name->getUnqualifiedIdentifier(); - if (UQN->kind() == NodeKind::ConversionOperatorIdentifier) { - ConversionOperatorIdentifierNode *COIN = - static_cast<ConversionOperatorIdentifierNode *>(UQN); - if (FSN) - COIN->TargetType = FSN->Signature->ReturnType; - } - return FSN; -} - -SymbolNode *Demangler::demangleDeclarator(StringView &MangledName) { - // What follows is a main symbol name. This may include namespaces or class - // back references. - QualifiedNameNode *QN = demangleFullyQualifiedSymbolName(MangledName); - if (Error) - return nullptr; - - SymbolNode *Symbol = demangleEncodedSymbol(MangledName, QN); - if (Error) - return nullptr; - Symbol->Name = QN; - - IdentifierNode *UQN = QN->getUnqualifiedIdentifier(); - if (UQN->kind() == NodeKind::ConversionOperatorIdentifier) { - ConversionOperatorIdentifierNode *COIN = - static_cast<ConversionOperatorIdentifierNode *>(UQN); - if (!COIN->TargetType) { - Error = true; - return nullptr; - } - } - return Symbol; -} - -SymbolNode *Demangler::demangleMD5Name(StringView &MangledName) { - assert(MangledName.startsWith("??@")); - // This is an MD5 mangled name. We can't demangle it, just return the - // mangled name. - // An MD5 mangled name is ??@ followed by 32 characters and a terminating @. - size_t MD5Last = MangledName.find('@', strlen("??@")); - if (MD5Last == StringView::npos) { - Error = true; - return nullptr; - } - const char *Start = MangledName.begin(); - MangledName = MangledName.dropFront(MD5Last + 1); - - // There are two additional special cases for MD5 names: - // 1. For complete object locators where the object name is long enough - // for the object to have an MD5 name, the complete object locator is - // called ??@...@??_R4@ (with a trailing "??_R4@" instead of the usual - // leading "??_R4". This is handled here. - // 2. For catchable types, in versions of MSVC before 2015 (<1900) or after - // 2017.2 (>= 1914), the catchable type mangling is _CT??@...@??@...@8 - // instead of_CT??@...@8 with just one MD5 name. Since we don't yet - // demangle catchable types anywhere, this isn't handled for MD5 names - // either. - MangledName.consumeFront("??_R4@"); - - StringView MD5(Start, MangledName.begin()); - SymbolNode *S = Arena.alloc<SymbolNode>(NodeKind::Md5Symbol); - S->Name = synthesizeQualifiedName(Arena, MD5); - - return S; -} - -SymbolNode *Demangler::demangleTypeinfoName(StringView &MangledName) { - assert(MangledName.startsWith('.')); - MangledName.consumeFront('.'); - - TypeNode *T = demangleType(MangledName, QualifierMangleMode::Result); - if (Error || !MangledName.empty()) { - Error = true; - return nullptr; - } - return synthesizeVariable(Arena, T, "`RTTI Type Descriptor Name'"); -} - -// Parser entry point. -SymbolNode *Demangler::parse(StringView &MangledName) { - // Typeinfo names are strings stored in RTTI data. They're not symbol names. - // It's still useful to demangle them. They're the only demangled entity - // that doesn't start with a "?" but a ".". - if (MangledName.startsWith('.')) - return demangleTypeinfoName(MangledName); - - if (MangledName.startsWith("??@")) - return demangleMD5Name(MangledName); - - // MSVC-style mangled symbols must start with '?'. - if (!MangledName.startsWith('?')) { - Error = true; - return nullptr; - } - - MangledName.consumeFront('?'); - - // ?$ is a template instantiation, but all other names that start with ? are - // operators / special names. - if (SymbolNode *SI = demangleSpecialIntrinsic(MangledName)) - return SI; - - return demangleDeclarator(MangledName); -} - -TagTypeNode *Demangler::parseTagUniqueName(StringView &MangledName) { - if (!MangledName.consumeFront(".?A")) { - Error = true; - return nullptr; - } - MangledName.consumeFront(".?A"); - if (MangledName.empty()) { - Error = true; - return nullptr; - } - - return demangleClassType(MangledName); -} - -// <type-encoding> ::= <storage-class> <variable-type> -// <storage-class> ::= 0 # private static member -// ::= 1 # protected static member -// ::= 2 # public static member -// ::= 3 # global -// ::= 4 # static local - -VariableSymbolNode *Demangler::demangleVariableEncoding(StringView &MangledName, - StorageClass SC) { - VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>(); - - VSN->Type = demangleType(MangledName, QualifierMangleMode::Drop); - VSN->SC = SC; - - if (Error) - return nullptr; - - // <variable-type> ::= <type> <cvr-qualifiers> - // ::= <type> <pointee-cvr-qualifiers> # pointers, references - switch (VSN->Type->kind()) { - case NodeKind::PointerType: { - PointerTypeNode *PTN = static_cast<PointerTypeNode *>(VSN->Type); - - Qualifiers ExtraChildQuals = Q_None; - PTN->Quals = Qualifiers(VSN->Type->Quals | - demanglePointerExtQualifiers(MangledName)); - - bool IsMember = false; - std::tie(ExtraChildQuals, IsMember) = demangleQualifiers(MangledName); - - if (PTN->ClassParent) { - QualifiedNameNode *BackRefName = - demangleFullyQualifiedTypeName(MangledName); - (void)BackRefName; - } - PTN->Pointee->Quals = Qualifiers(PTN->Pointee->Quals | ExtraChildQuals); - - break; - } - default: - VSN->Type->Quals = demangleQualifiers(MangledName).first; - break; - } - - return VSN; -} - -// Sometimes numbers are encoded in mangled symbols. For example, -// "int (*x)[20]" is a valid C type (x is a pointer to an array of -// length 20), so we need some way to embed numbers as part of symbols. -// This function parses it. -// -// <number> ::= [?] <non-negative integer> -// -// <non-negative integer> ::= <decimal digit> # when 1 <= Number <= 10 -// ::= <hex digit>+ @ # when Number == 0 or >= 10 -// -// <hex-digit> ::= [A-P] # A = 0, B = 1, ... -std::pair<uint64_t, bool> Demangler::demangleNumber(StringView &MangledName) { - bool IsNegative = MangledName.consumeFront('?'); - - if (startsWithDigit(MangledName)) { - uint64_t Ret = MangledName[0] - '0' + 1; - MangledName = MangledName.dropFront(1); - return {Ret, IsNegative}; - } - - uint64_t Ret = 0; - for (size_t i = 0; i < MangledName.size(); ++i) { - char C = MangledName[i]; - if (C == '@') { - MangledName = MangledName.dropFront(i + 1); - return {Ret, IsNegative}; - } - if ('A' <= C && C <= 'P') { - Ret = (Ret << 4) + (C - 'A'); - continue; - } - break; - } - - Error = true; - return {0ULL, false}; -} - -uint64_t Demangler::demangleUnsigned(StringView &MangledName) { - bool IsNegative = false; - uint64_t Number = 0; - std::tie(Number, IsNegative) = demangleNumber(MangledName); - if (IsNegative) - Error = true; - return Number; -} - -int64_t Demangler::demangleSigned(StringView &MangledName) { - bool IsNegative = false; - uint64_t Number = 0; - std::tie(Number, IsNegative) = demangleNumber(MangledName); - if (Number > INT64_MAX) - Error = true; - int64_t I = static_cast<int64_t>(Number); - return IsNegative ? -I : I; -} - -// First 10 strings can be referenced by special BackReferences ?0, ?1, ..., ?9. -// Memorize it. -void Demangler::memorizeString(StringView S) { - if (Backrefs.NamesCount >= BackrefContext::Max) - return; - for (size_t i = 0; i < Backrefs.NamesCount; ++i) - if (S == Backrefs.Names[i]->Name) - return; - NamedIdentifierNode *N = Arena.alloc<NamedIdentifierNode>(); - N->Name = S; - Backrefs.Names[Backrefs.NamesCount++] = N; -} - -NamedIdentifierNode *Demangler::demangleBackRefName(StringView &MangledName) { - assert(startsWithDigit(MangledName)); - - size_t I = MangledName[0] - '0'; - if (I >= Backrefs.NamesCount) { - Error = true; - return nullptr; - } - - MangledName = MangledName.dropFront(); - return Backrefs.Names[I]; -} - -void Demangler::memorizeIdentifier(IdentifierNode *Identifier) { - // Render this class template name into a string buffer so that we can - // memorize it for the purpose of back-referencing. - OutputBuffer OB; - Identifier->output(OB, OF_Default); - StringView Owned = copyString(OB); - memorizeString(Owned); - std::free(OB.getBuffer()); -} - -IdentifierNode * -Demangler::demangleTemplateInstantiationName(StringView &MangledName, - NameBackrefBehavior NBB) { - assert(MangledName.startsWith("?$")); - MangledName.consumeFront("?$"); - - BackrefContext OuterContext; - std::swap(OuterContext, Backrefs); - - IdentifierNode *Identifier = - demangleUnqualifiedSymbolName(MangledName, NBB_Simple); - if (!Error) - Identifier->TemplateParams = demangleTemplateParameterList(MangledName); - - std::swap(OuterContext, Backrefs); - if (Error) - return nullptr; - - if (NBB & NBB_Template) { - // NBB_Template is only set for types and non-leaf names ("a::" in "a::b"). - // Structors and conversion operators only makes sense in a leaf name, so - // reject them in NBB_Template contexts. - if (Identifier->kind() == NodeKind::ConversionOperatorIdentifier || - Identifier->kind() == NodeKind::StructorIdentifier) { - Error = true; - return nullptr; - } - - memorizeIdentifier(Identifier); - } - - return Identifier; -} - -NamedIdentifierNode *Demangler::demangleSimpleName(StringView &MangledName, - bool Memorize) { - StringView S = demangleSimpleString(MangledName, Memorize); - if (Error) - return nullptr; - - NamedIdentifierNode *Name = Arena.alloc<NamedIdentifierNode>(); - Name->Name = S; - return Name; -} - -static bool isRebasedHexDigit(char C) { return (C >= 'A' && C <= 'P'); } - -static uint8_t rebasedHexDigitToNumber(char C) { - assert(isRebasedHexDigit(C)); - return (C <= 'J') ? (C - 'A') : (10 + C - 'K'); -} - -uint8_t Demangler::demangleCharLiteral(StringView &MangledName) { - assert(!MangledName.empty()); - if (!MangledName.startsWith('?')) - return MangledName.popFront(); - - MangledName = MangledName.dropFront(); - if (MangledName.empty()) - goto CharLiteralError; - - if (MangledName.consumeFront('$')) { - // Two hex digits - if (MangledName.size() < 2) - goto CharLiteralError; - StringView Nibbles = MangledName.substr(0, 2); - if (!isRebasedHexDigit(Nibbles[0]) || !isRebasedHexDigit(Nibbles[1])) - goto CharLiteralError; - // Don't append the null terminator. - uint8_t C1 = rebasedHexDigitToNumber(Nibbles[0]); - uint8_t C2 = rebasedHexDigitToNumber(Nibbles[1]); - MangledName = MangledName.dropFront(2); - return (C1 << 4) | C2; - } - - if (startsWithDigit(MangledName)) { - const char *Lookup = ",/\\:. \n\t'-"; - char C = Lookup[MangledName[0] - '0']; - MangledName = MangledName.dropFront(); - return C; - } - - if (MangledName[0] >= 'a' && MangledName[0] <= 'z') { - char Lookup[26] = {'\xE1', '\xE2', '\xE3', '\xE4', '\xE5', '\xE6', '\xE7', - '\xE8', '\xE9', '\xEA', '\xEB', '\xEC', '\xED', '\xEE', - '\xEF', '\xF0', '\xF1', '\xF2', '\xF3', '\xF4', '\xF5', - '\xF6', '\xF7', '\xF8', '\xF9', '\xFA'}; - char C = Lookup[MangledName[0] - 'a']; - MangledName = MangledName.dropFront(); - return C; - } - - if (MangledName[0] >= 'A' && MangledName[0] <= 'Z') { - char Lookup[26] = {'\xC1', '\xC2', '\xC3', '\xC4', '\xC5', '\xC6', '\xC7', - '\xC8', '\xC9', '\xCA', '\xCB', '\xCC', '\xCD', '\xCE', - '\xCF', '\xD0', '\xD1', '\xD2', '\xD3', '\xD4', '\xD5', - '\xD6', '\xD7', '\xD8', '\xD9', '\xDA'}; - char C = Lookup[MangledName[0] - 'A']; - MangledName = MangledName.dropFront(); - return C; - } - -CharLiteralError: - Error = true; - return '\0'; -} - -wchar_t Demangler::demangleWcharLiteral(StringView &MangledName) { - uint8_t C1, C2; - - C1 = demangleCharLiteral(MangledName); - if (Error || MangledName.empty()) - goto WCharLiteralError; - C2 = demangleCharLiteral(MangledName); - if (Error) - goto WCharLiteralError; - - return ((wchar_t)C1 << 8) | (wchar_t)C2; - -WCharLiteralError: - Error = true; - return L'\0'; -} - -static void writeHexDigit(char *Buffer, uint8_t Digit) { - assert(Digit <= 15); - *Buffer = (Digit < 10) ? ('0' + Digit) : ('A' + Digit - 10); -} - -static void outputHex(OutputBuffer &OB, unsigned C) { - assert (C != 0); - - // It's easier to do the math if we can work from right to left, but we need - // to print the numbers from left to right. So render this into a temporary - // buffer first, then output the temporary buffer. Each byte is of the form - // \xAB, which means that each byte needs 4 characters. Since there are at - // most 4 bytes, we need a 4*4+1 = 17 character temporary buffer. - char TempBuffer[17]; - - ::memset(TempBuffer, 0, sizeof(TempBuffer)); - constexpr int MaxPos = sizeof(TempBuffer) - 1; - - int Pos = MaxPos - 1; // TempBuffer[MaxPos] is the terminating \0. - while (C != 0) { - for (int I = 0; I < 2; ++I) { - writeHexDigit(&TempBuffer[Pos--], C % 16); - C /= 16; - } - } - TempBuffer[Pos--] = 'x'; - assert(Pos >= 0); - TempBuffer[Pos--] = '\\'; - OB << StringView(&TempBuffer[Pos + 1]); -} - -static void outputEscapedChar(OutputBuffer &OB, unsigned C) { - switch (C) { - case '\0': // nul - OB << "\\0"; - return; - case '\'': // single quote - OB << "\\\'"; - return; - case '\"': // double quote - OB << "\\\""; - return; - case '\\': // backslash - OB << "\\\\"; - return; - case '\a': // bell - OB << "\\a"; - return; - case '\b': // backspace - OB << "\\b"; - return; - case '\f': // form feed - OB << "\\f"; - return; - case '\n': // new line - OB << "\\n"; - return; - case '\r': // carriage return - OB << "\\r"; - return; - case '\t': // tab - OB << "\\t"; - return; - case '\v': // vertical tab - OB << "\\v"; - return; - default: - break; - } - - if (C > 0x1F && C < 0x7F) { - // Standard ascii char. - OB << (char)C; - return; - } - - outputHex(OB, C); -} - -static unsigned countTrailingNullBytes(const uint8_t *StringBytes, int Length) { - const uint8_t *End = StringBytes + Length - 1; - unsigned Count = 0; - while (Length > 0 && *End == 0) { - --Length; - --End; - ++Count; - } - return Count; -} - -static unsigned countEmbeddedNulls(const uint8_t *StringBytes, - unsigned Length) { - unsigned Result = 0; - for (unsigned I = 0; I < Length; ++I) { - if (*StringBytes++ == 0) - ++Result; - } - return Result; -} - -// A mangled (non-wide) string literal stores the total length of the string it -// refers to (passed in NumBytes), and it contains up to 32 bytes of actual text -// (passed in StringBytes, NumChars). -static unsigned guessCharByteSize(const uint8_t *StringBytes, unsigned NumChars, - uint64_t NumBytes) { - assert(NumBytes > 0); - - // If the number of bytes is odd, this is guaranteed to be a char string. - if (NumBytes % 2 == 1) - return 1; - - // All strings can encode at most 32 bytes of data. If it's less than that, - // then we encoded the entire string. In this case we check for a 1-byte, - // 2-byte, or 4-byte null terminator. - if (NumBytes < 32) { - unsigned TrailingNulls = countTrailingNullBytes(StringBytes, NumChars); - if (TrailingNulls >= 4 && NumBytes % 4 == 0) - return 4; - if (TrailingNulls >= 2) - return 2; - return 1; - } - - // The whole string was not able to be encoded. Try to look at embedded null - // terminators to guess. The heuristic is that we count all embedded null - // terminators. If more than 2/3 are null, it's a char32. If more than 1/3 - // are null, it's a char16. Otherwise it's a char8. This obviously isn't - // perfect and is biased towards languages that have ascii alphabets, but this - // was always going to be best effort since the encoding is lossy. - unsigned Nulls = countEmbeddedNulls(StringBytes, NumChars); - if (Nulls >= 2 * NumChars / 3 && NumBytes % 4 == 0) - return 4; - if (Nulls >= NumChars / 3) - return 2; - return 1; -} - -static unsigned decodeMultiByteChar(const uint8_t *StringBytes, - unsigned CharIndex, unsigned CharBytes) { - assert(CharBytes == 1 || CharBytes == 2 || CharBytes == 4); - unsigned Offset = CharIndex * CharBytes; - unsigned Result = 0; - StringBytes = StringBytes + Offset; - for (unsigned I = 0; I < CharBytes; ++I) { - unsigned C = static_cast<unsigned>(StringBytes[I]); - Result |= C << (8 * I); - } - return Result; -} - -FunctionSymbolNode *Demangler::demangleVcallThunkNode(StringView &MangledName) { - FunctionSymbolNode *FSN = Arena.alloc<FunctionSymbolNode>(); - VcallThunkIdentifierNode *VTIN = Arena.alloc<VcallThunkIdentifierNode>(); - FSN->Signature = Arena.alloc<ThunkSignatureNode>(); - FSN->Signature->FunctionClass = FC_NoParameterList; - - FSN->Name = demangleNameScopeChain(MangledName, VTIN); - if (!Error) - Error = !MangledName.consumeFront("$B"); - if (!Error) - VTIN->OffsetInVTable = demangleUnsigned(MangledName); - if (!Error) - Error = !MangledName.consumeFront('A'); - if (!Error) - FSN->Signature->CallConvention = demangleCallingConvention(MangledName); - return (Error) ? nullptr : FSN; -} - -EncodedStringLiteralNode * -Demangler::demangleStringLiteral(StringView &MangledName) { - // This function uses goto, so declare all variables up front. - OutputBuffer OB; - StringView CRC; - uint64_t StringByteSize; - bool IsWcharT = false; - bool IsNegative = false; - size_t CrcEndPos = 0; - - EncodedStringLiteralNode *Result = Arena.alloc<EncodedStringLiteralNode>(); - - // Prefix indicating the beginning of a string literal - if (!MangledName.consumeFront("@_")) - goto StringLiteralError; - if (MangledName.empty()) - goto StringLiteralError; - - // Char Type (regular or wchar_t) - switch (MangledName.popFront()) { - case '1': - IsWcharT = true; - DEMANGLE_FALLTHROUGH; - case '0': - break; - default: - goto StringLiteralError; - } - - // Encoded Length - std::tie(StringByteSize, IsNegative) = demangleNumber(MangledName); - if (Error || IsNegative || StringByteSize < (IsWcharT ? 2 : 1)) - goto StringLiteralError; - - // CRC 32 (always 8 characters plus a terminator) - CrcEndPos = MangledName.find('@'); - if (CrcEndPos == StringView::npos) - goto StringLiteralError; - CRC = MangledName.substr(0, CrcEndPos); - MangledName = MangledName.dropFront(CrcEndPos + 1); - if (MangledName.empty()) - goto StringLiteralError; - - if (IsWcharT) { - Result->Char = CharKind::Wchar; - if (StringByteSize > 64) - Result->IsTruncated = true; - - while (!MangledName.consumeFront('@')) { - if (MangledName.size() < 2) - goto StringLiteralError; - wchar_t W = demangleWcharLiteral(MangledName); - if (StringByteSize != 2 || Result->IsTruncated) - outputEscapedChar(OB, W); - StringByteSize -= 2; - if (Error) - goto StringLiteralError; - } - } else { - // The max byte length is actually 32, but some compilers mangled strings - // incorrectly, so we have to assume it can go higher. - constexpr unsigned MaxStringByteLength = 32 * 4; - uint8_t StringBytes[MaxStringByteLength]; - - unsigned BytesDecoded = 0; - while (!MangledName.consumeFront('@')) { - if (MangledName.size() < 1 || BytesDecoded >= MaxStringByteLength) - goto StringLiteralError; - StringBytes[BytesDecoded++] = demangleCharLiteral(MangledName); - } - - if (StringByteSize > BytesDecoded) - Result->IsTruncated = true; - - unsigned CharBytes = - guessCharByteSize(StringBytes, BytesDecoded, StringByteSize); - assert(StringByteSize % CharBytes == 0); - switch (CharBytes) { - case 1: - Result->Char = CharKind::Char; - break; - case 2: - Result->Char = CharKind::Char16; - break; - case 4: - Result->Char = CharKind::Char32; - break; - default: - DEMANGLE_UNREACHABLE; - } - const unsigned NumChars = BytesDecoded / CharBytes; - for (unsigned CharIndex = 0; CharIndex < NumChars; ++CharIndex) { - unsigned NextChar = - decodeMultiByteChar(StringBytes, CharIndex, CharBytes); - if (CharIndex + 1 < NumChars || Result->IsTruncated) - outputEscapedChar(OB, NextChar); - } - } - - Result->DecodedString = copyString(OB); - std::free(OB.getBuffer()); - return Result; - -StringLiteralError: - Error = true; - std::free(OB.getBuffer()); - return nullptr; -} - -// Returns MangledName's prefix before the first '@', or an error if -// MangledName contains no '@' or the prefix has length 0. -StringView Demangler::demangleSimpleString(StringView &MangledName, - bool Memorize) { - StringView S; - for (size_t i = 0; i < MangledName.size(); ++i) { - if (MangledName[i] != '@') - continue; - if (i == 0) - break; - S = MangledName.substr(0, i); - MangledName = MangledName.dropFront(i + 1); - - if (Memorize) - memorizeString(S); - return S; - } - - Error = true; - return {}; -} - -NamedIdentifierNode * -Demangler::demangleAnonymousNamespaceName(StringView &MangledName) { - assert(MangledName.startsWith("?A")); - MangledName.consumeFront("?A"); - - NamedIdentifierNode *Node = Arena.alloc<NamedIdentifierNode>(); - Node->Name = "`anonymous namespace'"; - size_t EndPos = MangledName.find('@'); - if (EndPos == StringView::npos) { - Error = true; - return nullptr; - } - StringView NamespaceKey = MangledName.substr(0, EndPos); - memorizeString(NamespaceKey); - MangledName = MangledName.substr(EndPos + 1); - return Node; -} - -NamedIdentifierNode * -Demangler::demangleLocallyScopedNamePiece(StringView &MangledName) { - assert(startsWithLocalScopePattern(MangledName)); - - NamedIdentifierNode *Identifier = Arena.alloc<NamedIdentifierNode>(); - MangledName.consumeFront('?'); - uint64_t Number = 0; - bool IsNegative = false; - std::tie(Number, IsNegative) = demangleNumber(MangledName); - assert(!IsNegative); - - // One ? to terminate the number - MangledName.consumeFront('?'); - - assert(!Error); - Node *Scope = parse(MangledName); - if (Error) - return nullptr; - - // Render the parent symbol's name into a buffer. - OutputBuffer OB; - OB << '`'; - Scope->output(OB, OF_Default); - OB << '\''; - OB << "::`" << Number << "'"; - - Identifier->Name = copyString(OB); - std::free(OB.getBuffer()); - return Identifier; -} - -// Parses a type name in the form of A@B@C@@ which represents C::B::A. -QualifiedNameNode * -Demangler::demangleFullyQualifiedTypeName(StringView &MangledName) { - IdentifierNode *Identifier = - demangleUnqualifiedTypeName(MangledName, /*Memorize=*/true); - if (Error) - return nullptr; - assert(Identifier); - - QualifiedNameNode *QN = demangleNameScopeChain(MangledName, Identifier); - if (Error) - return nullptr; - assert(QN); - return QN; -} - -// Parses a symbol name in the form of A@B@C@@ which represents C::B::A. -// Symbol names have slightly different rules regarding what can appear -// so we separate out the implementations for flexibility. -QualifiedNameNode * -Demangler::demangleFullyQualifiedSymbolName(StringView &MangledName) { - // This is the final component of a symbol name (i.e. the leftmost component - // of a mangled name. Since the only possible template instantiation that - // can appear in this context is a function template, and since those are - // not saved for the purposes of name backreferences, only backref simple - // names. - IdentifierNode *Identifier = - demangleUnqualifiedSymbolName(MangledName, NBB_Simple); - if (Error) - return nullptr; - - QualifiedNameNode *QN = demangleNameScopeChain(MangledName, Identifier); - if (Error) - return nullptr; - - if (Identifier->kind() == NodeKind::StructorIdentifier) { - if (QN->Components->Count < 2) { - Error = true; - return nullptr; - } - StructorIdentifierNode *SIN = - static_cast<StructorIdentifierNode *>(Identifier); - Node *ClassNode = QN->Components->Nodes[QN->Components->Count - 2]; - SIN->Class = static_cast<IdentifierNode *>(ClassNode); - } - assert(QN); - return QN; -} - -IdentifierNode *Demangler::demangleUnqualifiedTypeName(StringView &MangledName, - bool Memorize) { - // An inner-most name can be a back-reference, because a fully-qualified name - // (e.g. Scope + Inner) can contain other fully qualified names inside of - // them (for example template parameters), and these nested parameters can - // refer to previously mangled types. - if (startsWithDigit(MangledName)) - return demangleBackRefName(MangledName); - - if (MangledName.startsWith("?$")) - return demangleTemplateInstantiationName(MangledName, NBB_Template); - - return demangleSimpleName(MangledName, Memorize); -} - -IdentifierNode * -Demangler::demangleUnqualifiedSymbolName(StringView &MangledName, - NameBackrefBehavior NBB) { - if (startsWithDigit(MangledName)) - return demangleBackRefName(MangledName); - if (MangledName.startsWith("?$")) - return demangleTemplateInstantiationName(MangledName, NBB); - if (MangledName.startsWith('?')) - return demangleFunctionIdentifierCode(MangledName); - return demangleSimpleName(MangledName, /*Memorize=*/(NBB & NBB_Simple) != 0); -} - -IdentifierNode *Demangler::demangleNameScopePiece(StringView &MangledName) { - if (startsWithDigit(MangledName)) - return demangleBackRefName(MangledName); - - if (MangledName.startsWith("?$")) - return demangleTemplateInstantiationName(MangledName, NBB_Template); - - if (MangledName.startsWith("?A")) - return demangleAnonymousNamespaceName(MangledName); - - if (startsWithLocalScopePattern(MangledName)) - return demangleLocallyScopedNamePiece(MangledName); - - return demangleSimpleName(MangledName, /*Memorize=*/true); -} - -static NodeArrayNode *nodeListToNodeArray(ArenaAllocator &Arena, NodeList *Head, - size_t Count) { - NodeArrayNode *N = Arena.alloc<NodeArrayNode>(); - N->Count = Count; - N->Nodes = Arena.allocArray<Node *>(Count); - for (size_t I = 0; I < Count; ++I) { - N->Nodes[I] = Head->N; - Head = Head->Next; - } - return N; -} - -QualifiedNameNode * -Demangler::demangleNameScopeChain(StringView &MangledName, - IdentifierNode *UnqualifiedName) { - NodeList *Head = Arena.alloc<NodeList>(); - - Head->N = UnqualifiedName; - - size_t Count = 1; - while (!MangledName.consumeFront("@")) { - ++Count; - NodeList *NewHead = Arena.alloc<NodeList>(); - NewHead->Next = Head; - Head = NewHead; - - if (MangledName.empty()) { - Error = true; - return nullptr; - } - - assert(!Error); - IdentifierNode *Elem = demangleNameScopePiece(MangledName); - if (Error) - return nullptr; - - Head->N = Elem; - } - - QualifiedNameNode *QN = Arena.alloc<QualifiedNameNode>(); - QN->Components = nodeListToNodeArray(Arena, Head, Count); - return QN; -} - -FuncClass Demangler::demangleFunctionClass(StringView &MangledName) { - switch (MangledName.popFront()) { - case '9': - return FuncClass(FC_ExternC | FC_NoParameterList); - case 'A': - return FC_Private; - case 'B': - return FuncClass(FC_Private | FC_Far); - case 'C': - return FuncClass(FC_Private | FC_Static); - case 'D': - return FuncClass(FC_Private | FC_Static | FC_Far); - case 'E': - return FuncClass(FC_Private | FC_Virtual); - case 'F': - return FuncClass(FC_Private | FC_Virtual | FC_Far); - case 'G': - return FuncClass(FC_Private | FC_StaticThisAdjust); - case 'H': - return FuncClass(FC_Private | FC_StaticThisAdjust | FC_Far); - case 'I': - return FuncClass(FC_Protected); - case 'J': - return FuncClass(FC_Protected | FC_Far); - case 'K': - return FuncClass(FC_Protected | FC_Static); - case 'L': - return FuncClass(FC_Protected | FC_Static | FC_Far); - case 'M': - return FuncClass(FC_Protected | FC_Virtual); - case 'N': - return FuncClass(FC_Protected | FC_Virtual | FC_Far); - case 'O': - return FuncClass(FC_Protected | FC_Virtual | FC_StaticThisAdjust); - case 'P': - return FuncClass(FC_Protected | FC_Virtual | FC_StaticThisAdjust | FC_Far); - case 'Q': - return FuncClass(FC_Public); - case 'R': - return FuncClass(FC_Public | FC_Far); - case 'S': - return FuncClass(FC_Public | FC_Static); - case 'T': - return FuncClass(FC_Public | FC_Static | FC_Far); - case 'U': - return FuncClass(FC_Public | FC_Virtual); - case 'V': - return FuncClass(FC_Public | FC_Virtual | FC_Far); - case 'W': - return FuncClass(FC_Public | FC_Virtual | FC_StaticThisAdjust); - case 'X': - return FuncClass(FC_Public | FC_Virtual | FC_StaticThisAdjust | FC_Far); - case 'Y': - return FuncClass(FC_Global); - case 'Z': - return FuncClass(FC_Global | FC_Far); - case '$': { - FuncClass VFlag = FC_VirtualThisAdjust; - if (MangledName.consumeFront('R')) - VFlag = FuncClass(VFlag | FC_VirtualThisAdjustEx); - if (MangledName.empty()) - break; - switch (MangledName.popFront()) { - case '0': - return FuncClass(FC_Private | FC_Virtual | VFlag); - case '1': - return FuncClass(FC_Private | FC_Virtual | VFlag | FC_Far); - case '2': - return FuncClass(FC_Protected | FC_Virtual | VFlag); - case '3': - return FuncClass(FC_Protected | FC_Virtual | VFlag | FC_Far); - case '4': - return FuncClass(FC_Public | FC_Virtual | VFlag); - case '5': - return FuncClass(FC_Public | FC_Virtual | VFlag | FC_Far); - } - } - } - - Error = true; - return FC_Public; -} - -CallingConv Demangler::demangleCallingConvention(StringView &MangledName) { - if (MangledName.empty()) { - Error = true; - return CallingConv::None; - } - - switch (MangledName.popFront()) { - case 'A': - case 'B': - return CallingConv::Cdecl; - case 'C': - case 'D': - return CallingConv::Pascal; - case 'E': - case 'F': - return CallingConv::Thiscall; - case 'G': - case 'H': - return CallingConv::Stdcall; - case 'I': - case 'J': - return CallingConv::Fastcall; - case 'M': - case 'N': - return CallingConv::Clrcall; - case 'O': - case 'P': - return CallingConv::Eabi; - case 'Q': - return CallingConv::Vectorcall; - case 'S': - return CallingConv::Swift; - case 'W': - return CallingConv::SwiftAsync; - } - - return CallingConv::None; -} - -StorageClass Demangler::demangleVariableStorageClass(StringView &MangledName) { - assert(MangledName.front() >= '0' && MangledName.front() <= '4'); - - switch (MangledName.popFront()) { - case '0': - return StorageClass::PrivateStatic; - case '1': - return StorageClass::ProtectedStatic; - case '2': - return StorageClass::PublicStatic; - case '3': - return StorageClass::Global; - case '4': - return StorageClass::FunctionLocalStatic; - } - DEMANGLE_UNREACHABLE; -} - -std::pair<Qualifiers, bool> -Demangler::demangleQualifiers(StringView &MangledName) { - if (MangledName.empty()) { - Error = true; - return std::make_pair(Q_None, false); - } - - switch (MangledName.popFront()) { - // Member qualifiers - case 'Q': - return std::make_pair(Q_None, true); - case 'R': - return std::make_pair(Q_Const, true); - case 'S': - return std::make_pair(Q_Volatile, true); - case 'T': - return std::make_pair(Qualifiers(Q_Const | Q_Volatile), true); - // Non-Member qualifiers - case 'A': - return std::make_pair(Q_None, false); - case 'B': - return std::make_pair(Q_Const, false); - case 'C': - return std::make_pair(Q_Volatile, false); - case 'D': - return std::make_pair(Qualifiers(Q_Const | Q_Volatile), false); - } - Error = true; - return std::make_pair(Q_None, false); -} - -// <variable-type> ::= <type> <cvr-qualifiers> -// ::= <type> <pointee-cvr-qualifiers> # pointers, references -TypeNode *Demangler::demangleType(StringView &MangledName, - QualifierMangleMode QMM) { - Qualifiers Quals = Q_None; - bool IsMember = false; - if (QMM == QualifierMangleMode::Mangle) { - std::tie(Quals, IsMember) = demangleQualifiers(MangledName); - } else if (QMM == QualifierMangleMode::Result) { - if (MangledName.consumeFront('?')) - std::tie(Quals, IsMember) = demangleQualifiers(MangledName); - } - - if (MangledName.empty()) { - Error = true; - return nullptr; - } - - TypeNode *Ty = nullptr; - if (isTagType(MangledName)) - Ty = demangleClassType(MangledName); - else if (isPointerType(MangledName)) { - if (isMemberPointer(MangledName, Error)) - Ty = demangleMemberPointerType(MangledName); - else if (!Error) - Ty = demanglePointerType(MangledName); - else - return nullptr; - } else if (isArrayType(MangledName)) - Ty = demangleArrayType(MangledName); - else if (isFunctionType(MangledName)) { - if (MangledName.consumeFront("$$A8@@")) - Ty = demangleFunctionType(MangledName, true); - else { - assert(MangledName.startsWith("$$A6")); - MangledName.consumeFront("$$A6"); - Ty = demangleFunctionType(MangledName, false); - } - } else if (isCustomType(MangledName)) { - Ty = demangleCustomType(MangledName); - } else { - Ty = demanglePrimitiveType(MangledName); - } - - if (!Ty || Error) - return Ty; - Ty->Quals = Qualifiers(Ty->Quals | Quals); - return Ty; -} - -bool Demangler::demangleThrowSpecification(StringView &MangledName) { - if (MangledName.consumeFront("_E")) - return true; - if (MangledName.consumeFront('Z')) - return false; - - Error = true; - return false; -} - -FunctionSignatureNode *Demangler::demangleFunctionType(StringView &MangledName, - bool HasThisQuals) { - FunctionSignatureNode *FTy = Arena.alloc<FunctionSignatureNode>(); - - if (HasThisQuals) { - FTy->Quals = demanglePointerExtQualifiers(MangledName); - FTy->RefQualifier = demangleFunctionRefQualifier(MangledName); - FTy->Quals = Qualifiers(FTy->Quals | demangleQualifiers(MangledName).first); - } - - // Fields that appear on both member and non-member functions. - FTy->CallConvention = demangleCallingConvention(MangledName); - - // <return-type> ::= <type> - // ::= @ # structors (they have no declared return type) - bool IsStructor = MangledName.consumeFront('@'); - if (!IsStructor) - FTy->ReturnType = demangleType(MangledName, QualifierMangleMode::Result); - - FTy->Params = demangleFunctionParameterList(MangledName, FTy->IsVariadic); - - FTy->IsNoexcept = demangleThrowSpecification(MangledName); - - return FTy; -} - -FunctionSymbolNode * -Demangler::demangleFunctionEncoding(StringView &MangledName) { - FuncClass ExtraFlags = FC_None; - if (MangledName.consumeFront("$$J0")) - ExtraFlags = FC_ExternC; - - if (MangledName.empty()) { - Error = true; - return nullptr; - } - - FuncClass FC = demangleFunctionClass(MangledName); - FC = FuncClass(ExtraFlags | FC); - - FunctionSignatureNode *FSN = nullptr; - ThunkSignatureNode *TTN = nullptr; - if (FC & FC_StaticThisAdjust) { - TTN = Arena.alloc<ThunkSignatureNode>(); - TTN->ThisAdjust.StaticOffset = demangleSigned(MangledName); - } else if (FC & FC_VirtualThisAdjust) { - TTN = Arena.alloc<ThunkSignatureNode>(); - if (FC & FC_VirtualThisAdjustEx) { - TTN->ThisAdjust.VBPtrOffset = demangleSigned(MangledName); - TTN->ThisAdjust.VBOffsetOffset = demangleSigned(MangledName); - } - TTN->ThisAdjust.VtordispOffset = demangleSigned(MangledName); - TTN->ThisAdjust.StaticOffset = demangleSigned(MangledName); - } - - if (FC & FC_NoParameterList) { - // This is an extern "C" function whose full signature hasn't been mangled. - // This happens when we need to mangle a local symbol inside of an extern - // "C" function. - FSN = Arena.alloc<FunctionSignatureNode>(); - } else { - bool HasThisQuals = !(FC & (FC_Global | FC_Static)); - FSN = demangleFunctionType(MangledName, HasThisQuals); - } - - if (Error) - return nullptr; - - if (TTN) { - *static_cast<FunctionSignatureNode *>(TTN) = *FSN; - FSN = TTN; - } - FSN->FunctionClass = FC; - - FunctionSymbolNode *Symbol = Arena.alloc<FunctionSymbolNode>(); - Symbol->Signature = FSN; - return Symbol; -} - -CustomTypeNode *Demangler::demangleCustomType(StringView &MangledName) { - assert(MangledName.startsWith('?')); - MangledName.popFront(); - - CustomTypeNode *CTN = Arena.alloc<CustomTypeNode>(); - CTN->Identifier = demangleUnqualifiedTypeName(MangledName, /*Memorize=*/true); - if (!MangledName.consumeFront('@')) - Error = true; - if (Error) - return nullptr; - return CTN; -} - -// Reads a primitive type. -PrimitiveTypeNode *Demangler::demanglePrimitiveType(StringView &MangledName) { - if (MangledName.consumeFront("$$T")) - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Nullptr); - - switch (MangledName.popFront()) { - case 'X': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Void); - case 'D': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Char); - case 'C': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Schar); - case 'E': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Uchar); - case 'F': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Short); - case 'G': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Ushort); - case 'H': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Int); - case 'I': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Uint); - case 'J': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Long); - case 'K': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Ulong); - case 'M': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Float); - case 'N': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Double); - case 'O': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Ldouble); - case '_': { - if (MangledName.empty()) { - Error = true; - return nullptr; - } - switch (MangledName.popFront()) { - case 'N': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Bool); - case 'J': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Int64); - case 'K': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Uint64); - case 'W': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Wchar); - case 'Q': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Char8); - case 'S': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Char16); - case 'U': - return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Char32); - } - break; - } - } - Error = true; - return nullptr; -} - -TagTypeNode *Demangler::demangleClassType(StringView &MangledName) { - TagTypeNode *TT = nullptr; - - switch (MangledName.popFront()) { - case 'T': - TT = Arena.alloc<TagTypeNode>(TagKind::Union); - break; - case 'U': - TT = Arena.alloc<TagTypeNode>(TagKind::Struct); - break; - case 'V': - TT = Arena.alloc<TagTypeNode>(TagKind::Class); - break; - case 'W': - if (!MangledName.consumeFront('4')) { - Error = true; - return nullptr; - } - TT = Arena.alloc<TagTypeNode>(TagKind::Enum); - break; - default: - assert(false); - } - - TT->QualifiedName = demangleFullyQualifiedTypeName(MangledName); - return TT; -} - -// <pointer-type> ::= E? <pointer-cvr-qualifiers> <ext-qualifiers> <type> -// # the E is required for 64-bit non-static pointers -PointerTypeNode *Demangler::demanglePointerType(StringView &MangledName) { - PointerTypeNode *Pointer = Arena.alloc<PointerTypeNode>(); - - std::tie(Pointer->Quals, Pointer->Affinity) = - demanglePointerCVQualifiers(MangledName); - - if (MangledName.consumeFront("6")) { - Pointer->Pointee = demangleFunctionType(MangledName, false); - return Pointer; - } - - Qualifiers ExtQuals = demanglePointerExtQualifiers(MangledName); - Pointer->Quals = Qualifiers(Pointer->Quals | ExtQuals); - - Pointer->Pointee = demangleType(MangledName, QualifierMangleMode::Mangle); - return Pointer; -} - -PointerTypeNode *Demangler::demangleMemberPointerType(StringView &MangledName) { - PointerTypeNode *Pointer = Arena.alloc<PointerTypeNode>(); - - std::tie(Pointer->Quals, Pointer->Affinity) = - demanglePointerCVQualifiers(MangledName); - assert(Pointer->Affinity == PointerAffinity::Pointer); - - Qualifiers ExtQuals = demanglePointerExtQualifiers(MangledName); - Pointer->Quals = Qualifiers(Pointer->Quals | ExtQuals); - - // isMemberPointer() only returns true if there is at least one character - // after the qualifiers. - if (MangledName.consumeFront("8")) { - Pointer->ClassParent = demangleFullyQualifiedTypeName(MangledName); - Pointer->Pointee = demangleFunctionType(MangledName, true); - } else { - Qualifiers PointeeQuals = Q_None; - bool IsMember = false; - std::tie(PointeeQuals, IsMember) = demangleQualifiers(MangledName); - assert(IsMember || Error); - Pointer->ClassParent = demangleFullyQualifiedTypeName(MangledName); - - Pointer->Pointee = demangleType(MangledName, QualifierMangleMode::Drop); - if (Pointer->Pointee) - Pointer->Pointee->Quals = PointeeQuals; - } - - return Pointer; -} - -Qualifiers Demangler::demanglePointerExtQualifiers(StringView &MangledName) { - Qualifiers Quals = Q_None; - if (MangledName.consumeFront('E')) - Quals = Qualifiers(Quals | Q_Pointer64); - if (MangledName.consumeFront('I')) - Quals = Qualifiers(Quals | Q_Restrict); - if (MangledName.consumeFront('F')) - Quals = Qualifiers(Quals | Q_Unaligned); - - return Quals; -} - -ArrayTypeNode *Demangler::demangleArrayType(StringView &MangledName) { - assert(MangledName.front() == 'Y'); - MangledName.popFront(); - - uint64_t Rank = 0; - bool IsNegative = false; - std::tie(Rank, IsNegative) = demangleNumber(MangledName); - if (IsNegative || Rank == 0) { - Error = true; - return nullptr; - } - - ArrayTypeNode *ATy = Arena.alloc<ArrayTypeNode>(); - NodeList *Head = Arena.alloc<NodeList>(); - NodeList *Tail = Head; - - for (uint64_t I = 0; I < Rank; ++I) { - uint64_t D = 0; - std::tie(D, IsNegative) = demangleNumber(MangledName); - if (Error || IsNegative) { - Error = true; - return nullptr; - } - Tail->N = Arena.alloc<IntegerLiteralNode>(D, IsNegative); - if (I + 1 < Rank) { - Tail->Next = Arena.alloc<NodeList>(); - Tail = Tail->Next; - } - } - ATy->Dimensions = nodeListToNodeArray(Arena, Head, Rank); - - if (MangledName.consumeFront("$$C")) { - bool IsMember = false; - std::tie(ATy->Quals, IsMember) = demangleQualifiers(MangledName); - if (IsMember) { - Error = true; - return nullptr; - } - } - - ATy->ElementType = demangleType(MangledName, QualifierMangleMode::Drop); - return ATy; -} - -// Reads a function's parameters. -NodeArrayNode *Demangler::demangleFunctionParameterList(StringView &MangledName, - bool &IsVariadic) { - // Empty parameter list. - if (MangledName.consumeFront('X')) - return nullptr; - - NodeList *Head = Arena.alloc<NodeList>(); - NodeList **Current = &Head; - size_t Count = 0; - while (!Error && !MangledName.startsWith('@') && - !MangledName.startsWith('Z')) { - ++Count; - - if (startsWithDigit(MangledName)) { - size_t N = MangledName[0] - '0'; - if (N >= Backrefs.FunctionParamCount) { - Error = true; - return nullptr; - } - MangledName = MangledName.dropFront(); - - *Current = Arena.alloc<NodeList>(); - (*Current)->N = Backrefs.FunctionParams[N]; - Current = &(*Current)->Next; - continue; - } - - size_t OldSize = MangledName.size(); - - *Current = Arena.alloc<NodeList>(); - TypeNode *TN = demangleType(MangledName, QualifierMangleMode::Drop); - if (!TN || Error) - return nullptr; - - (*Current)->N = TN; - - size_t CharsConsumed = OldSize - MangledName.size(); - assert(CharsConsumed != 0); - - // Single-letter types are ignored for backreferences because memorizing - // them doesn't save anything. - if (Backrefs.FunctionParamCount <= 9 && CharsConsumed > 1) - Backrefs.FunctionParams[Backrefs.FunctionParamCount++] = TN; - - Current = &(*Current)->Next; - } - - if (Error) - return nullptr; - - NodeArrayNode *NA = nodeListToNodeArray(Arena, Head, Count); - // A non-empty parameter list is terminated by either 'Z' (variadic) parameter - // list or '@' (non variadic). Careful not to consume "@Z", as in that case - // the following Z could be a throw specifier. - if (MangledName.consumeFront('@')) - return NA; - - if (MangledName.consumeFront('Z')) { - IsVariadic = true; - return NA; - } - - DEMANGLE_UNREACHABLE; -} - -NodeArrayNode * -Demangler::demangleTemplateParameterList(StringView &MangledName) { - NodeList *Head = nullptr; - NodeList **Current = &Head; - size_t Count = 0; - - while (!MangledName.startsWith('@')) { - if (MangledName.consumeFront("$S") || MangledName.consumeFront("$$V") || - MangledName.consumeFront("$$$V") || MangledName.consumeFront("$$Z")) { - // parameter pack separator - continue; - } - - ++Count; - - // Template parameter lists don't participate in back-referencing. - *Current = Arena.alloc<NodeList>(); - - NodeList &TP = **Current; - - TemplateParameterReferenceNode *TPRN = nullptr; - if (MangledName.consumeFront("$$Y")) { - // Template alias - TP.N = demangleFullyQualifiedTypeName(MangledName); - } else if (MangledName.consumeFront("$$B")) { - // Array - TP.N = demangleType(MangledName, QualifierMangleMode::Drop); - } else if (MangledName.consumeFront("$$C")) { - // Type has qualifiers. - TP.N = demangleType(MangledName, QualifierMangleMode::Mangle); - } else if (MangledName.startsWith("$1") || MangledName.startsWith("$H") || - MangledName.startsWith("$I") || MangledName.startsWith("$J")) { - // Pointer to member - TP.N = TPRN = Arena.alloc<TemplateParameterReferenceNode>(); - TPRN->IsMemberPointer = true; - - MangledName = MangledName.dropFront(); - // 1 - single inheritance <name> - // H - multiple inheritance <name> <number> - // I - virtual inheritance <name> <number> <number> - // J - unspecified inheritance <name> <number> <number> <number> - char InheritanceSpecifier = MangledName.popFront(); - SymbolNode *S = nullptr; - if (MangledName.startsWith('?')) { - S = parse(MangledName); - if (Error || !S->Name) { - Error = true; - return nullptr; - } - memorizeIdentifier(S->Name->getUnqualifiedIdentifier()); - } - - switch (InheritanceSpecifier) { - case 'J': - TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] = - demangleSigned(MangledName); - DEMANGLE_FALLTHROUGH; - case 'I': - TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] = - demangleSigned(MangledName); - DEMANGLE_FALLTHROUGH; - case 'H': - TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] = - demangleSigned(MangledName); - DEMANGLE_FALLTHROUGH; - case '1': - break; - default: - DEMANGLE_UNREACHABLE; - } - TPRN->Affinity = PointerAffinity::Pointer; - TPRN->Symbol = S; - } else if (MangledName.startsWith("$E?")) { - MangledName.consumeFront("$E"); - // Reference to symbol - TP.N = TPRN = Arena.alloc<TemplateParameterReferenceNode>(); - TPRN->Symbol = parse(MangledName); - TPRN->Affinity = PointerAffinity::Reference; - } else if (MangledName.startsWith("$F") || MangledName.startsWith("$G")) { - TP.N = TPRN = Arena.alloc<TemplateParameterReferenceNode>(); - - // Data member pointer. - MangledName = MangledName.dropFront(); - char InheritanceSpecifier = MangledName.popFront(); - - switch (InheritanceSpecifier) { - case 'G': - TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] = - demangleSigned(MangledName); - DEMANGLE_FALLTHROUGH; - case 'F': - TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] = - demangleSigned(MangledName); - TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] = - demangleSigned(MangledName); - break; - default: - DEMANGLE_UNREACHABLE; - } - TPRN->IsMemberPointer = true; - - } else if (MangledName.consumeFront("$0")) { - // Integral non-type template parameter - bool IsNegative = false; - uint64_t Value = 0; - std::tie(Value, IsNegative) = demangleNumber(MangledName); - - TP.N = Arena.alloc<IntegerLiteralNode>(Value, IsNegative); - } else { - TP.N = demangleType(MangledName, QualifierMangleMode::Drop); - } - if (Error) - return nullptr; - - Current = &TP.Next; - } - - // The loop above returns nullptr on Error. - assert(!Error); - - // Template parameter lists cannot be variadic, so it can only be terminated - // by @ (as opposed to 'Z' in the function parameter case). - assert(MangledName.startsWith('@')); // The above loop exits only on '@'. - MangledName.consumeFront('@'); - return nodeListToNodeArray(Arena, Head, Count); -} - -void Demangler::dumpBackReferences() { - std::printf("%d function parameter backreferences\n", - (int)Backrefs.FunctionParamCount); - - // Create an output stream so we can render each type. - OutputBuffer OB; - for (size_t I = 0; I < Backrefs.FunctionParamCount; ++I) { - OB.setCurrentPosition(0); - - TypeNode *T = Backrefs.FunctionParams[I]; - T->output(OB, OF_Default); - - StringView B = OB; - std::printf(" [%d] - %.*s\n", (int)I, (int)B.size(), B.begin()); - } - std::free(OB.getBuffer()); - - if (Backrefs.FunctionParamCount > 0) - std::printf("\n"); - std::printf("%d name backreferences\n", (int)Backrefs.NamesCount); - for (size_t I = 0; I < Backrefs.NamesCount; ++I) { - std::printf(" [%d] - %.*s\n", (int)I, (int)Backrefs.Names[I]->Name.size(), - Backrefs.Names[I]->Name.begin()); - } - if (Backrefs.NamesCount > 0) - std::printf("\n"); -} - -char *llvm::microsoftDemangle(const char *MangledName, size_t *NMangled, - char *Buf, size_t *N, - int *Status, MSDemangleFlags Flags) { - Demangler D; - - StringView Name{MangledName}; - SymbolNode *AST = D.parse(Name); - if (!D.Error && NMangled) - *NMangled = Name.begin() - MangledName; - - if (Flags & MSDF_DumpBackrefs) - D.dumpBackReferences(); - - OutputFlags OF = OF_Default; - if (Flags & MSDF_NoCallingConvention) - OF = OutputFlags(OF | OF_NoCallingConvention); - if (Flags & MSDF_NoAccessSpecifier) - OF = OutputFlags(OF | OF_NoAccessSpecifier); - if (Flags & MSDF_NoReturnType) - OF = OutputFlags(OF | OF_NoReturnType); - if (Flags & MSDF_NoMemberType) - OF = OutputFlags(OF | OF_NoMemberType); - if (Flags & MSDF_NoVariableType) - OF = OutputFlags(OF | OF_NoVariableType); - - int InternalStatus = demangle_success; - if (D.Error) - InternalStatus = demangle_invalid_mangled_name; - else { - OutputBuffer OB(Buf, N); - AST->output(OB, OF); - OB += '\0'; - if (N != nullptr) - *N = OB.getCurrentPosition(); - Buf = OB.getBuffer(); - } - - if (Status) - *Status = InternalStatus; - return InternalStatus == demangle_success ? Buf : nullptr; -} diff --git a/demangle/third_party/llvm/lib/Demangle/MicrosoftDemangleNodes.cpp b/demangle/third_party/llvm/lib/Demangle/MicrosoftDemangleNodes.cpp deleted file mode 100644 index 975649f2..00000000 --- a/demangle/third_party/llvm/lib/Demangle/MicrosoftDemangleNodes.cpp +++ /dev/null @@ -1,658 +0,0 @@ -//===- MicrosoftDemangle.cpp ----------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file defines a demangler for MSVC-style mangled symbols. -// -//===----------------------------------------------------------------------===// - -#include "llvm/Demangle/MicrosoftDemangleNodes.h" -#include "llvm/Demangle/Utility.h" -#include <cctype> -#include <string> - -using namespace llvm; -using namespace ms_demangle; - -#define OUTPUT_ENUM_CLASS_VALUE(Enum, Value, Desc) \ - case Enum::Value: \ - OB << Desc; \ - break; - -// Writes a space if the last token does not end with a punctuation. -static void outputSpaceIfNecessary(OutputBuffer &OB) { - if (OB.empty()) - return; - - char C = OB.back(); - if (std::isalnum(C) || C == '>') - OB << " "; -} - -static void outputSingleQualifier(OutputBuffer &OB, Qualifiers Q) { - switch (Q) { - case Q_Const: - OB << "const"; - break; - case Q_Volatile: - OB << "volatile"; - break; - case Q_Restrict: - OB << "__restrict"; - break; - default: - break; - } -} - -static bool outputQualifierIfPresent(OutputBuffer &OB, Qualifiers Q, - Qualifiers Mask, bool NeedSpace) { - if (!(Q & Mask)) - return NeedSpace; - - if (NeedSpace) - OB << " "; - - outputSingleQualifier(OB, Mask); - return true; -} - -static void outputQualifiers(OutputBuffer &OB, Qualifiers Q, bool SpaceBefore, - bool SpaceAfter) { - if (Q == Q_None) - return; - - size_t Pos1 = OB.getCurrentPosition(); - SpaceBefore = outputQualifierIfPresent(OB, Q, Q_Const, SpaceBefore); - SpaceBefore = outputQualifierIfPresent(OB, Q, Q_Volatile, SpaceBefore); - SpaceBefore = outputQualifierIfPresent(OB, Q, Q_Restrict, SpaceBefore); - size_t Pos2 = OB.getCurrentPosition(); - if (SpaceAfter && Pos2 > Pos1) - OB << " "; -} - -static void outputCallingConvention(OutputBuffer &OB, CallingConv CC) { - outputSpaceIfNecessary(OB); - - switch (CC) { - case CallingConv::Cdecl: - OB << "__cdecl"; - break; - case CallingConv::Fastcall: - OB << "__fastcall"; - break; - case CallingConv::Pascal: - OB << "__pascal"; - break; - case CallingConv::Regcall: - OB << "__regcall"; - break; - case CallingConv::Stdcall: - OB << "__stdcall"; - break; - case CallingConv::Thiscall: - OB << "__thiscall"; - break; - case CallingConv::Eabi: - OB << "__eabi"; - break; - case CallingConv::Vectorcall: - OB << "__vectorcall"; - break; - case CallingConv::Clrcall: - OB << "__clrcall"; - break; - case CallingConv::Swift: - OB << "__attribute__((__swiftcall__)) "; - break; - case CallingConv::SwiftAsync: - OB << "__attribute__((__swiftasynccall__)) "; - break; - default: - break; - } -} - -std::string Node::toString(OutputFlags Flags) const { - OutputBuffer OB; - this->output(OB, Flags); - StringView SV = OB; - std::string Owned(SV.begin(), SV.end()); - std::free(OB.getBuffer()); - return Owned; -} - -void PrimitiveTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const { - switch (PrimKind) { - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Void, "void"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Bool, "bool"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char, "char"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Schar, "signed char"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Uchar, "unsigned char"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char8, "char8_t"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char16, "char16_t"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char32, "char32_t"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Short, "short"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Ushort, "unsigned short"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Int, "int"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Uint, "unsigned int"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Long, "long"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Ulong, "unsigned long"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Int64, "__int64"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Uint64, "unsigned __int64"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Wchar, "wchar_t"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Float, "float"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Double, "double"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Ldouble, "long double"); - OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Nullptr, "std::nullptr_t"); - } - outputQualifiers(OB, Quals, true, false); -} - -void NodeArrayNode::output(OutputBuffer &OB, OutputFlags Flags) const { - output(OB, Flags, ", "); -} - -void NodeArrayNode::output(OutputBuffer &OB, OutputFlags Flags, - StringView Separator) const { - if (Count == 0) - return; - if (Nodes[0]) - Nodes[0]->output(OB, Flags); - for (size_t I = 1; I < Count; ++I) { - OB << Separator; - Nodes[I]->output(OB, Flags); - } -} - -void EncodedStringLiteralNode::output(OutputBuffer &OB, - OutputFlags Flags) const { - switch (Char) { - case CharKind::Wchar: - OB << "L\""; - break; - case CharKind::Char: - OB << "\""; - break; - case CharKind::Char16: - OB << "u\""; - break; - case CharKind::Char32: - OB << "U\""; - break; - } - OB << DecodedString << "\""; - if (IsTruncated) - OB << "..."; -} - -void IntegerLiteralNode::output(OutputBuffer &OB, OutputFlags Flags) const { - if (IsNegative) - OB << '-'; - OB << Value; -} - -void TemplateParameterReferenceNode::output(OutputBuffer &OB, - OutputFlags Flags) const { - if (ThunkOffsetCount > 0) - OB << "{"; - else if (Affinity == PointerAffinity::Pointer) - OB << "&"; - - if (Symbol) { - Symbol->output(OB, Flags); - if (ThunkOffsetCount > 0) - OB << ", "; - } - - if (ThunkOffsetCount > 0) - OB << ThunkOffsets[0]; - for (int I = 1; I < ThunkOffsetCount; ++I) { - OB << ", " << ThunkOffsets[I]; - } - if (ThunkOffsetCount > 0) - OB << "}"; -} - -void IdentifierNode::outputTemplateParameters(OutputBuffer &OB, - OutputFlags Flags) const { - if (!TemplateParams) - return; - OB << "<"; - TemplateParams->output(OB, Flags); - OB << ">"; -} - -void DynamicStructorIdentifierNode::output(OutputBuffer &OB, - OutputFlags Flags) const { - if (IsDestructor) - OB << "`dynamic atexit destructor for "; - else - OB << "`dynamic initializer for "; - - if (Variable) { - OB << "`"; - Variable->output(OB, Flags); - OB << "''"; - } else { - OB << "'"; - Name->output(OB, Flags); - OB << "''"; - } -} - -void NamedIdentifierNode::output(OutputBuffer &OB, OutputFlags Flags) const { - OB << Name; - outputTemplateParameters(OB, Flags); -} - -void IntrinsicFunctionIdentifierNode::output(OutputBuffer &OB, - OutputFlags Flags) const { - switch (Operator) { - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, New, "operator new"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Delete, "operator delete"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Assign, "operator="); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, RightShift, "operator>>"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LeftShift, "operator<<"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LogicalNot, "operator!"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Equals, "operator=="); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, NotEquals, "operator!="); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ArraySubscript, - "operator[]"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Pointer, "operator->"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Increment, "operator++"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Decrement, "operator--"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Minus, "operator-"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Plus, "operator+"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Dereference, "operator*"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseAnd, "operator&"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, MemberPointer, - "operator->*"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Divide, "operator/"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Modulus, "operator%"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LessThan, "operator<"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LessThanEqual, "operator<="); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, GreaterThan, "operator>"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, GreaterThanEqual, - "operator>="); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Comma, "operator,"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Parens, "operator()"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseNot, "operator~"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseXor, "operator^"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseOr, "operator|"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LogicalAnd, "operator&&"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LogicalOr, "operator||"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, TimesEqual, "operator*="); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, PlusEqual, "operator+="); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, MinusEqual, "operator-="); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, DivEqual, "operator/="); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ModEqual, "operator%="); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, RshEqual, "operator>>="); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LshEqual, "operator<<="); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseAndEqual, - "operator&="); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseOrEqual, - "operator|="); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseXorEqual, - "operator^="); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VbaseDtor, "`vbase dtor'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecDelDtor, - "`vector deleting dtor'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, DefaultCtorClosure, - "`default ctor closure'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ScalarDelDtor, - "`scalar deleting dtor'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecCtorIter, - "`vector ctor iterator'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecDtorIter, - "`vector dtor iterator'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecVbaseCtorIter, - "`vector vbase ctor iterator'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VdispMap, - "`virtual displacement map'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVecCtorIter, - "`eh vector ctor iterator'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVecDtorIter, - "`eh vector dtor iterator'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVecVbaseCtorIter, - "`eh vector vbase ctor iterator'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, CopyCtorClosure, - "`copy ctor closure'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LocalVftableCtorClosure, - "`local vftable ctor closure'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ArrayNew, "operator new[]"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ArrayDelete, - "operator delete[]"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ManVectorCtorIter, - "`managed vector ctor iterator'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ManVectorDtorIter, - "`managed vector dtor iterator'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVectorCopyCtorIter, - "`EH vector copy ctor iterator'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVectorVbaseCopyCtorIter, - "`EH vector vbase copy ctor iterator'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VectorCopyCtorIter, - "`vector copy ctor iterator'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VectorVbaseCopyCtorIter, - "`vector vbase copy constructor iterator'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ManVectorVbaseCopyCtorIter, - "`managed vector vbase copy constructor iterator'"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, CoAwait, - "operator co_await"); - OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Spaceship, "operator<=>"); - case IntrinsicFunctionKind::MaxIntrinsic: - case IntrinsicFunctionKind::None: - break; - } - outputTemplateParameters(OB, Flags); -} - -void LocalStaticGuardIdentifierNode::output(OutputBuffer &OB, - OutputFlags Flags) const { - if (IsThread) - OB << "`local static thread guard'"; - else - OB << "`local static guard'"; - if (ScopeIndex > 0) - OB << "{" << ScopeIndex << "}"; -} - -void ConversionOperatorIdentifierNode::output(OutputBuffer &OB, - OutputFlags Flags) const { - OB << "operator"; - outputTemplateParameters(OB, Flags); - OB << " "; - TargetType->output(OB, Flags); -} - -void StructorIdentifierNode::output(OutputBuffer &OB, OutputFlags Flags) const { - if (IsDestructor) - OB << "~"; - Class->output(OB, Flags); - outputTemplateParameters(OB, Flags); -} - -void LiteralOperatorIdentifierNode::output(OutputBuffer &OB, - OutputFlags Flags) const { - OB << "operator \"\"" << Name; - outputTemplateParameters(OB, Flags); -} - -void FunctionSignatureNode::outputPre(OutputBuffer &OB, - OutputFlags Flags) const { - if (!(Flags & OF_NoAccessSpecifier)) { - if (FunctionClass & FC_Public) - OB << "public: "; - if (FunctionClass & FC_Protected) - OB << "protected: "; - if (FunctionClass & FC_Private) - OB << "private: "; - } - - if (!(Flags & OF_NoMemberType)) { - if (!(FunctionClass & FC_Global)) { - if (FunctionClass & FC_Static) - OB << "static "; - } - if (FunctionClass & FC_Virtual) - OB << "virtual "; - - if (FunctionClass & FC_ExternC) - OB << "extern \"C\" "; - } - - if (!(Flags & OF_NoReturnType) && ReturnType) { - ReturnType->outputPre(OB, Flags); - OB << " "; - } - - if (!(Flags & OF_NoCallingConvention)) - outputCallingConvention(OB, CallConvention); -} - -void FunctionSignatureNode::outputPost(OutputBuffer &OB, - OutputFlags Flags) const { - if (!(FunctionClass & FC_NoParameterList)) { - OB << "("; - if (Params) - Params->output(OB, Flags); - else - OB << "void"; - - if (IsVariadic) { - if (OB.back() != '(') - OB << ", "; - OB << "..."; - } - OB << ")"; - } - - if (Quals & Q_Const) - OB << " const"; - if (Quals & Q_Volatile) - OB << " volatile"; - if (Quals & Q_Restrict) - OB << " __restrict"; - if (Quals & Q_Unaligned) - OB << " __unaligned"; - - if (IsNoexcept) - OB << " noexcept"; - - if (RefQualifier == FunctionRefQualifier::Reference) - OB << " &"; - else if (RefQualifier == FunctionRefQualifier::RValueReference) - OB << " &&"; - - if (!(Flags & OF_NoReturnType) && ReturnType) - ReturnType->outputPost(OB, Flags); -} - -void ThunkSignatureNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const { - OB << "[thunk]: "; - - FunctionSignatureNode::outputPre(OB, Flags); -} - -void ThunkSignatureNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const { - if (FunctionClass & FC_StaticThisAdjust) { - OB << "`adjustor{" << ThisAdjust.StaticOffset << "}'"; - } else if (FunctionClass & FC_VirtualThisAdjust) { - if (FunctionClass & FC_VirtualThisAdjustEx) { - OB << "`vtordispex{" << ThisAdjust.VBPtrOffset << ", " - << ThisAdjust.VBOffsetOffset << ", " << ThisAdjust.VtordispOffset - << ", " << ThisAdjust.StaticOffset << "}'"; - } else { - OB << "`vtordisp{" << ThisAdjust.VtordispOffset << ", " - << ThisAdjust.StaticOffset << "}'"; - } - } - - FunctionSignatureNode::outputPost(OB, Flags); -} - -void PointerTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const { - if (Pointee->kind() == NodeKind::FunctionSignature) { - // If this is a pointer to a function, don't output the calling convention. - // It needs to go inside the parentheses. - const FunctionSignatureNode *Sig = - static_cast<const FunctionSignatureNode *>(Pointee); - Sig->outputPre(OB, OF_NoCallingConvention); - } else - Pointee->outputPre(OB, Flags); - - outputSpaceIfNecessary(OB); - - if (Quals & Q_Unaligned) - OB << "__unaligned "; - - if (Pointee->kind() == NodeKind::ArrayType) { - OB << "("; - } else if (Pointee->kind() == NodeKind::FunctionSignature) { - OB << "("; - const FunctionSignatureNode *Sig = - static_cast<const FunctionSignatureNode *>(Pointee); - outputCallingConvention(OB, Sig->CallConvention); - OB << " "; - } - - if (ClassParent) { - ClassParent->output(OB, Flags); - OB << "::"; - } - - switch (Affinity) { - case PointerAffinity::Pointer: - OB << "*"; - break; - case PointerAffinity::Reference: - OB << "&"; - break; - case PointerAffinity::RValueReference: - OB << "&&"; - break; - default: - assert(false); - } - outputQualifiers(OB, Quals, false, false); -} - -void PointerTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const { - if (Pointee->kind() == NodeKind::ArrayType || - Pointee->kind() == NodeKind::FunctionSignature) - OB << ")"; - - Pointee->outputPost(OB, Flags); -} - -void TagTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const { - if (!(Flags & OF_NoTagSpecifier)) { - switch (Tag) { - OUTPUT_ENUM_CLASS_VALUE(TagKind, Class, "class"); - OUTPUT_ENUM_CLASS_VALUE(TagKind, Struct, "struct"); - OUTPUT_ENUM_CLASS_VALUE(TagKind, Union, "union"); - OUTPUT_ENUM_CLASS_VALUE(TagKind, Enum, "enum"); - } - OB << " "; - } - QualifiedName->output(OB, Flags); - outputQualifiers(OB, Quals, true, false); -} - -void TagTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {} - -void ArrayTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const { - ElementType->outputPre(OB, Flags); - outputQualifiers(OB, Quals, true, false); -} - -void ArrayTypeNode::outputOneDimension(OutputBuffer &OB, OutputFlags Flags, - Node *N) const { - assert(N->kind() == NodeKind::IntegerLiteral); - IntegerLiteralNode *ILN = static_cast<IntegerLiteralNode *>(N); - if (ILN->Value != 0) - ILN->output(OB, Flags); -} - -void ArrayTypeNode::outputDimensionsImpl(OutputBuffer &OB, - OutputFlags Flags) const { - if (Dimensions->Count == 0) - return; - - outputOneDimension(OB, Flags, Dimensions->Nodes[0]); - for (size_t I = 1; I < Dimensions->Count; ++I) { - OB << "]["; - outputOneDimension(OB, Flags, Dimensions->Nodes[I]); - } -} - -void ArrayTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const { - OB << "["; - outputDimensionsImpl(OB, Flags); - OB << "]"; - - ElementType->outputPost(OB, Flags); -} - -void SymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const { - Name->output(OB, Flags); -} - -void FunctionSymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const { - Signature->outputPre(OB, Flags); - outputSpaceIfNecessary(OB); - Name->output(OB, Flags); - Signature->outputPost(OB, Flags); -} - -void VariableSymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const { - const char *AccessSpec = nullptr; - bool IsStatic = true; - switch (SC) { - case StorageClass::PrivateStatic: - AccessSpec = "private"; - break; - case StorageClass::PublicStatic: - AccessSpec = "public"; - break; - case StorageClass::ProtectedStatic: - AccessSpec = "protected"; - break; - default: - IsStatic = false; - break; - } - if (!(Flags & OF_NoAccessSpecifier) && AccessSpec) - OB << AccessSpec << ": "; - if (!(Flags & OF_NoMemberType) && IsStatic) - OB << "static "; - - if (!(Flags & OF_NoVariableType) && Type) { - Type->outputPre(OB, Flags); - outputSpaceIfNecessary(OB); - } - Name->output(OB, Flags); - if (!(Flags & OF_NoVariableType) && Type) - Type->outputPost(OB, Flags); -} - -void CustomTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const { - Identifier->output(OB, Flags); -} -void CustomTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {} - -void QualifiedNameNode::output(OutputBuffer &OB, OutputFlags Flags) const { - Components->output(OB, Flags, "::"); -} - -void RttiBaseClassDescriptorNode::output(OutputBuffer &OB, - OutputFlags Flags) const { - OB << "`RTTI Base Class Descriptor at ("; - OB << NVOffset << ", " << VBPtrOffset << ", " << VBTableOffset << ", " - << this->Flags; - OB << ")'"; -} - -void LocalStaticGuardVariableNode::output(OutputBuffer &OB, - OutputFlags Flags) const { - Name->output(OB, Flags); -} - -void VcallThunkIdentifierNode::output(OutputBuffer &OB, - OutputFlags Flags) const { - OB << "`vcall'{" << OffsetInVTable << ", {flat}}"; -} - -void SpecialTableSymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const { - outputQualifiers(OB, Quals, false, true); - Name->output(OB, Flags); - if (TargetName) { - OB << "{for `"; - TargetName->output(OB, Flags); - OB << "'}"; - } -} |