Commit 9ddfacd8e62abd80b25619dd852ee811dad5f7b6 | zig

author	Andrew Kelley <andrew@ziglang.org> 2023-08-11 17:22:29-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-09-19 09:37:31-07:00
log	9ddfacd8e62abd80b25619dd852ee811dad5f7b6
tree	441be2e6381f6e82b8e87d5f1773f7531f8e9912
parent	571a4c86c39d83b28a0c6f413f3fc259b48cf422

libcxxabi: update to LLVM 17

release/17.x branch, commit 8f4dd44097c9ae25dd203d5ac87f3b48f854bba8

13 files changed, 461 insertions(+), 408 deletions(-)

lib
- libcxxabi
  - include
    __cxxabi_config.h
  - src
    aix_state_tab_eh.inc
    cxa_aux_runtime.cpp
    cxa_demangle.cpp
    cxa_guard_impl.h
    demangle
    DemangleConfig.h
    ItaniumDemangle.h
    StringView.h
    StringViewExtras.h
    Utility.h
    fallback_malloc.cpp
    private_typeinfo.cpp
    stdlib_new_delete.cpp

lib/libcxxabi/include/__cxxabi_config.h+1-1

...	@@ -32,7 +32,7 @@	...	@@ -32,7 +32,7 @@
32	#endif	32	#endif
33		33
34	#if defined(_WIN32)	34	#if defined(_WIN32)
35	#if defined(_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS)	35	#if defined(_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS) \|\| (defined(__MINGW32__) && !defined(_LIBCXXABI_BUILDING_LIBRARY))
36	#define _LIBCXXABI_HIDDEN	36	#define _LIBCXXABI_HIDDEN
37	#define _LIBCXXABI_DATA_VIS	37	#define _LIBCXXABI_DATA_VIS
38	#define _LIBCXXABI_FUNC_VIS	38	#define _LIBCXXABI_FUNC_VIS

lib/libcxxabi/src/aix_state_tab_eh.inc+56-29

...	@@ -14,10 +14,6 @@	...	@@ -14,10 +14,6 @@
14	#include <stdio.h>	14	#include <stdio.h>
15	#include <sys/debug.h>	15	#include <sys/debug.h>
16		16
17	#if !__has_cpp_attribute(clang::optnone)
18	#error This file requires clang::optnone attribute support
19	#endif
20
21	/*	17	/*
22	The legacy IBM xlC and xlclang++ compilers use the state table for EH	18	The legacy IBM xlC and xlclang++ compilers use the state table for EH
23	instead of the range table. Destructors, or addresses of the possible catch	19	instead of the range table. Destructors, or addresses of the possible catch
...	@@ -563,7 +559,8 @@ __xlcxx_personality_v0(int version, _Unwind_Action actions, uint64_t exceptionCl	...	@@ -563,7 +559,8 @@ __xlcxx_personality_v0(int version, _Unwind_Action actions, uint64_t exceptionCl
563	uintptr_t currentSP = reinterpret_cast<uintptr_t>(_Unwind_GetGR(context, 1));	559	uintptr_t currentSP = reinterpret_cast<uintptr_t>(_Unwind_GetGR(context, 1));
564	uintptr_t callersSP = reinterpret_cast<uintptr_t>(currentSP[0]);	560	uintptr_t callersSP = reinterpret_cast<uintptr_t>(currentSP[0]);
565	callersSP[3] = reinterpret_cast<uintptr_t>(unwind_exception);	561	callersSP[3] = reinterpret_cast<uintptr_t>(unwind_exception);
566	_LIBCXXABI_TRACE_STATETAB("Handshake: set unwind_exception=%p in stack=%p\n", reinterpret_cast<void>(unwind_exception), reinterpret_cast<void>(callersSP));	562	_LIBCXXABI_TRACE_STATETAB("Handshake: save unwind_exception=%p in stack=%p\n",
		563	reinterpret_cast<void>(unwind_exception), reinterpret_cast<void>(callersSP));
567	// Jump to the handler.	564	// Jump to the handler.
568	_Unwind_SetIP(context, results.landingPad);	565	_Unwind_SetIP(context, results.landingPad);
569	return _URC_INSTALL_CONTEXT;	566	return _URC_INSTALL_CONTEXT;
...	@@ -641,38 +638,68 @@ _LIBCXXABI_FUNC_VIS void __xlc_throw_badexception() {	...	@@ -641,38 +638,68 @@ _LIBCXXABI_FUNC_VIS void __xlc_throw_badexception() {
641	__cxa_throw(newexception, const_cast<std::type_info*>(&typeid(std::bad_exception)), 0);	638	__cxa_throw(newexception, const_cast<std::type_info*>(&typeid(std::bad_exception)), 0);
642	}	639	}
643		640
644	// force_a_stackframe	641	// skip_non_cxx_eh_aware_frames
645	// This function is called by __xlc_exception_handle() to ensure a stack frame	642	// This function skips non-C++ EH aware stack frames by unwinding from the
646	// is created for __xlc_exception_handle().	643	// stack frame pointed by 'Sp' and returns the first C++ EH aware stack frame
647	__attribute__((noinline, optnone))	644	// found. 'Pc' is an instruction address inside the function that owns the
648	static void force_a_stackframe() {}	645	// stack frame pointed to by 'Sp'.
		646	static uintptr_t* skip_non_cxx_eh_aware_frames(uint32_t* Pc, uintptr_t* Sp) {
		647	uint32_t* currentPc = Pc;
		648	uintptr_t* currentStack = Sp;
		649
		650	// Loop until a C++ EH aware frame is found or the return address is 0,
		651	// which is the return address of the startup function '__start'.
		652	while (currentPc != 0) {
		653	uint32_t* p = currentPc;
		654
		655	// Keep looking forward until a word of 0 is found. The traceback
		656	// table starts at the following word.
		657	while (*p)
		658	++p;
		659	tbtable* TBTable = reinterpret_cast<tbtable*>(p + 1);
		660
		661	// A stack frame with a C++ state table is C++ EH aware.
		662	if (TBTable->tb.lang == TB_CPLUSPLUS && TBTable->tb.has_ctl)
		663	return currentStack;
		664
		665	// Move up one stack frame.
		666	currentStack = reinterpret_cast<uintptr_t*>(currentStack[0]);
		667	// Get the value of the LR (saved, prior to incrementing the SP, by the
		668	// prolog of the function just inspected) from the frame.
		669	currentPc = reinterpret_cast<uint32_t*>(currentStack[2]);
		670	}
		671	// This should not happen.
		672	_LIBCXXABI_TRACE_STATETAB0("skip_non_cxx_eh_aware_frames() reached the end of stack frames, aborting\n");
		673	abort();
		674	}
649		675
650	// __xlc_exception_handle	676	// __xlc_exception_handle
651	// This function is for xlclang++. It returns the address of the exception	677	// This function is for xlclang++. It returns the address of the exception
652	// object stored in the reserved field in the stack of the caller of the	678	// object stored in the reserved field in the stack of the caller of the
653	// function that calls __xlc_exception_handle() (within the link area for the	679	// function that calls __xlc_exception_handle() (within the link area for the
654	// call to the latter). The address is stored by the personality routine for	680	// call to the latter). The address is stored by the personality routine for
655	// xlclang++ compiled code. The implementation of __xlc_exception_handle()	681	// xlclang++ compiled code. If __xlc_exception_handle() is called by
656	// assumes a stack frame is created for it. The following ensures this	682	// non-C++ EH aware functions, their frames are skipped until a C++ EH aware
657	// assumption holds true: 1) a call to force_a_stackframe() is made inside	683	// frame is found.
658	// __xlc_exception_handle() to make it non-leaf; and 2) optimizations are	684	// Note: make sure __xlc_excpetion_handle() is a non-leaf function. Currently
659	// disabled for this function with attribute 'optnone'. Note: this function	685	// it calls skip_non_cxx_eh_aware_frames(), which in turn calls abort().
660	// may not work as expected if these are changed.
661	__attribute__((optnone))
662	_LIBCXXABI_FUNC_VIS uintptr_t __xlc_exception_handle() {	686	_LIBCXXABI_FUNC_VIS uintptr_t __xlc_exception_handle() {
663	// Make a call to force_a_stackframe() so that the compiler creates a stack
664	// frame for this function.
665	force_a_stackframe();
666
667	// Get the SP of this function, i.e., __xlc_exception_handle().	687	// Get the SP of this function, i.e., __xlc_exception_handle().
668	uintptr_t *lastStack;	688	uintptr_t* lastStack = reinterpret_cast<uintptr_t*>(__builtin_frame_address(0));
669	asm("mr %0, 1" : "=r"(lastStack));	689	// Move one frame up to the frame of the caller of __xlc_exception_handle().
670	// Get the SP of the caller of __xlc_exception_handle().	690	lastStack = reinterpret_cast<uintptr_t*>(lastStack[0]);
671	uintptr_t callerStack = reinterpret_cast<uintptr_t>(lastStack[0]);	691	// Get the return address of this function, i.e., __xlc_exception_handle().
672	// Get the SP of the caller of the caller.	692	uint32_t* returnAddress = reinterpret_cast<uint32_t*>(__builtin_return_address(0));
673	uintptr_t callerStack2 = reinterpret_cast<uintptr_t>(callerStack[0]);	693
674	uintptr_t exceptionObject = callerStack2[3];	694	// Skip non-C++ EH aware frames and get the first C++ EH aware frame.
675	_LIBCXXABI_TRACE_STATETAB("Handshake: exceptionObject=%p from stack=%p\n", reinterpret_cast<void>(exceptionObject), reinterpret_cast<void>(callerStack2));	695	uintptr_t* callerStack = skip_non_cxx_eh_aware_frames(returnAddress, lastStack);
		696
		697	// Get the SP of the caller of the C++ EH aware caller.
		698	callerStack = reinterpret_cast<uintptr_t*>(callerStack[0]);
		699	// Retrieve the exception object in the stack slot saved by the personality.
		700	uintptr_t exceptionObject = callerStack[3];
		701	_LIBCXXABI_TRACE_STATETAB("Handshake: retrieve exceptionObject=%p from stack=%p\n",
		702	reinterpret_cast<void>(exceptionObject), reinterpret_cast<void>(callerStack));
676	return exceptionObject;	703	return exceptionObject;
677	}	704	}
678		705

lib/libcxxabi/src/cxa_aux_runtime.cpp+1

...	@@ -10,6 +10,7 @@	...	@@ -10,6 +10,7 @@
10	//===----------------------------------------------------------------------===//	10	//===----------------------------------------------------------------------===//
11		11
12	#include "cxxabi.h"	12	#include "cxxabi.h"
		13	#include <exception>
13	#include <new>	14	#include <new>
14	#include <typeinfo>	15	#include <typeinfo>
15		16

lib/libcxxabi/src/cxa_demangle.cpp+4-2

...	@@ -10,6 +10,7 @@	...	@@ -10,6 +10,7 @@
10	// file does not yet support:	10	// file does not yet support:
11	// - C++ modules TS	11	// - C++ modules TS
12		12
		13	#include "demangle/DemangleConfig.h"
13	#include "demangle/ItaniumDemangle.h"	14	#include "demangle/ItaniumDemangle.h"
14	#include "__cxxabi_config.h"	15	#include "__cxxabi_config.h"
15	#include <cassert>	16	#include <cassert>
...	@@ -19,6 +20,7 @@	...	@@ -19,6 +20,7 @@
19	#include <cstring>	20	#include <cstring>
20	#include <functional>	21	#include <functional>
21	#include <numeric>	22	#include <numeric>
		23	#include <string_view>
22	#include <utility>	24	#include <utility>
23		25
24	using namespace itanium_demangle;	26	using namespace itanium_demangle;
...	@@ -77,8 +79,8 @@ struct DumpVisitor {	...	@@ -77,8 +79,8 @@ struct DumpVisitor {
77	}	79	}
78		80
79	void printStr(const char *S) { fprintf(stderr, "%s", S); }	81	void printStr(const char *S) { fprintf(stderr, "%s", S); }
80	void print(StringView SV) {	82	void print(std::string_view SV) {
81	fprintf(stderr, "\"%.*s\"", (int)SV.size(), SV.begin());	83	fprintf(stderr, "\"%.s\"", (int)SV.size(), &SV.begin());
82	}	84	}
83	void print(const Node *N) {	85	void print(const Node *N) {
84	if (N)	86	if (N)

lib/libcxxabi/src/cxa_guard_impl.h+3-3

lib/libcxxabi/src/demangle/DemangleConfig.h+8

...	@@ -11,6 +11,14 @@	...	@@ -11,6 +11,14 @@
11	#ifndef LIBCXXABI_DEMANGLE_DEMANGLE_CONFIG_H	11	#ifndef LIBCXXABI_DEMANGLE_DEMANGLE_CONFIG_H
12	#define LIBCXXABI_DEMANGLE_DEMANGLE_CONFIG_H	12	#define LIBCXXABI_DEMANGLE_DEMANGLE_CONFIG_H
13		13
		14	// Must be defined before pulling in headers from libc++. Allow downstream
		15	// build systems to override this value.
		16	// https://libcxx.llvm.org/UsingLibcxx.html#enabling-the-safe-libc-mode
		17	#ifndef _LIBCPP_VERBOSE_ABORT
		18	#define _LIBCPP_VERBOSE_ABORT(...) abort_message(__VA_ARGS__)
		19	#include "../abort_message.h"
		20	#endif
		21
14	#include <ciso646>	22	#include <ciso646>
15		23
16	#ifdef _MSC_VER	24	#ifdef _MSC_VER

lib/libcxxabi/src/demangle/ItaniumDemangle.h+154-134

 @@ -17,8 +17,9 @@
 #define DEMANGLE_ITANIUMDEMANGLE_H
 #include "DemangleConfig.h"
-#include "StringView.h"
+#include "StringViewExtras.h"
 #include "Utility.h"
+#include <__cxxabi_config.h>
 #include <algorithm>
 #include <cassert>
 #include <cctype>
 @@ -27,8 +28,15 @@
 #include <cstring>
 #include <limits>
 #include <new>
+#include <string_view>
+#include <type_traits>
 #include <utility>
+#ifdef _LIBCXXABI_COMPILER_CLANG
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-template"
+#endif
 DEMANGLE_NAMESPACE_BEGIN
 template <class T, size_t N> class PODSmallVector {
 @@ -286,7 +294,7 @@ public:
   // implementation.
   virtual void printRight(OutputBuffer &) const {}
-  virtual StringView getBaseName() const { return StringView(); }
+  virtual std::string_view getBaseName() const { return {}; }
   // Silence compiler warnings, this dtor will never be called.
   virtual ~Node() = default;
 @@ -345,10 +353,10 @@ struct NodeArrayNode : Node {
 class DotSuffix final : public Node {
   const Node *Prefix;
-  const StringView Suffix;
+  const std::string_view Suffix;
 public:
-  DotSuffix(const Node *Prefix_, StringView Suffix_)
+  DotSuffix(const Node *Prefix_, std::string_view Suffix_)
       : Node(KDotSuffix), Prefix(Prefix_), Suffix(Suffix_) {}
   template<typename Fn> void match(Fn F) const { F(Prefix, Suffix); }
 @@ -363,15 +371,15 @@ public:
 class VendorExtQualType final : public Node {
   const Node *Ty;
-  StringView Ext;
+  std::string_view Ext;
   const Node *TA;
 public:
-  VendorExtQualType(const Node *Ty_, StringView Ext_, const Node *TA_)
+  VendorExtQualType(const Node *Ty_, std::string_view Ext_, const Node *TA_)
       : Node(KVendorExtQualType), Ty(Ty_), Ext(Ext_), TA(TA_) {}
   const Node *getTy() const { return Ty; }
-  StringView getExt() const { return Ext; }
+  std::string_view getExt() const { return Ext; }
   const Node *getTA() const { return TA; }
   template <typename Fn> void match(Fn F) const { F(Ty, Ext, TA); }
 @@ -462,10 +470,10 @@ public:
 class PostfixQualifiedType final : public Node {
   const Node *Ty;
-  const StringView Postfix;
+  const std::string_view Postfix;
 public:
-  PostfixQualifiedType(const Node *Ty_, StringView Postfix_)
+  PostfixQualifiedType(const Node *Ty_, std::string_view Postfix_)
       : Node(KPostfixQualifiedType), Ty(Ty_), Postfix(Postfix_) {}
   template<typename Fn> void match(Fn F) const { F(Ty, Postfix); }
 @@ -477,15 +485,15 @@ public:
 };
 class NameType final : public Node {
-  const StringView Name;
+  const std::string_view Name;
 public:
-  NameType(StringView Name_) : Node(KNameType), Name(Name_) {}
+  NameType(std::string_view Name_) : Node(KNameType), Name(Name_) {}
   template<typename Fn> void match(Fn F) const { F(Name); }
-  StringView getName() const { return Name; }
+  std::string_view getName() const { return Name; }
-  StringView getBaseName() const override { return Name; }
+  std::string_view getBaseName() const override { return Name; }
   void printLeft(OutputBuffer &OB) const override { OB += Name; }
 };
 @@ -511,10 +519,10 @@ public:
 };
 class ElaboratedTypeSpefType : public Node {
-  StringView Kind;
+  std::string_view Kind;
   Node *Child;
 public:
-  ElaboratedTypeSpefType(StringView Kind_, Node *Child_)
+  ElaboratedTypeSpefType(std::string_view Kind_, Node *Child_)
       : Node(KElaboratedTypeSpefType), Kind(Kind_), Child(Child_) {}
   template<typename Fn> void match(Fn F) const { F(Kind, Child); }
 @@ -528,15 +536,17 @@ public:
 struct AbiTagAttr : Node {
   Node *Base;
-  StringView Tag;
+  std::string_view Tag;
-  AbiTagAttr(Node* Base_, StringView Tag_)
+  AbiTagAttr(Node *Base_, std::string_view Tag_)
-      : Node(KAbiTagAttr, Base_->RHSComponentCache,
+      : Node(KAbiTagAttr, Base_->RHSComponentCache, Base_->ArrayCache,
-             Base_->ArrayCache, Base_->FunctionCache),
+             Base_->FunctionCache),
         Base(Base_), Tag(Tag_) {}
   template<typename Fn> void match(Fn F) const { F(Base, Tag); }
+  std::string_view getBaseName() const override { return Base->getBaseName(); }
   void printLeft(OutputBuffer &OB) const override {
     Base->printLeft(OB);
     OB += "[abi:";
 @@ -562,12 +572,12 @@ public:
 class ObjCProtoName : public Node {
   const Node *Ty;
-  StringView Protocol;
+  std::string_view Protocol;
   friend class PointerType;
 public:
-  ObjCProtoName(const Node *Ty_, StringView Protocol_)
+  ObjCProtoName(const Node *Ty_, std::string_view Protocol_)
       : Node(KObjCProtoName), Ty(Ty_), Protocol(Protocol_) {}
   template<typename Fn> void match(Fn F) const { F(Ty, Protocol); }
 @@ -944,11 +954,11 @@ public:
 };
 class SpecialName final : public Node {
-  const StringView Special;
+  const std::string_view Special;
   const Node *Child;
 public:
-  SpecialName(StringView Special_, const Node *Child_)
+  SpecialName(std::string_view Special_, const Node *Child_)
       : Node(KSpecialName), Special(Special_), Child(Child_) {}
   template<typename Fn> void match(Fn F) const { F(Special, Child); }
 @@ -987,7 +997,7 @@ struct NestedName : Node {
   template<typename Fn> void match(Fn F) const { F(Qual, Name); }
-  StringView getBaseName() const override { return Name->getBaseName(); }
+  std::string_view getBaseName() const override { return Name->getBaseName(); }
   void printLeft(OutputBuffer &OB) const override {
     Qual->print(OB);
 @@ -1027,7 +1037,7 @@ struct ModuleEntity : Node {
   template <typename Fn> void match(Fn F) const { F(Module, Name); }
-  StringView getBaseName() const override { return Name->getBaseName(); }
+  std::string_view getBaseName() const override { return Name->getBaseName(); }
   void printLeft(OutputBuffer &OB) const override {
     Name->print(OB);
 @@ -1063,7 +1073,7 @@ public:
   template<typename Fn> void match(Fn F) const { F(Qualifier, Name); }
-  StringView getBaseName() const override { return Name->getBaseName(); }
+  std::string_view getBaseName() const override { return Name->getBaseName(); }
   void printLeft(OutputBuffer &OB) const override {
     Qualifier->print(OB);
 @@ -1485,7 +1495,7 @@ struct NameWithTemplateArgs : Node {
   template<typename Fn> void match(Fn F) const { F(Name, TemplateArgs); }
-  StringView getBaseName() const override { return Name->getBaseName(); }
+  std::string_view getBaseName() const override { return Name->getBaseName(); }
   void printLeft(OutputBuffer &OB) const override {
     Name->print(OB);
 @@ -1502,7 +1512,7 @@ public:
   template<typename Fn> void match(Fn F) const { F(Child); }
-  StringView getBaseName() const override { return Child->getBaseName(); }
+  std::string_view getBaseName() const override { return Child->getBaseName(); }
   void printLeft(OutputBuffer &OB) const override {
     OB += "::";
 @@ -1538,20 +1548,20 @@ protected:
     return unsigned(SSK) >= unsigned(SpecialSubKind::string);
   }
-  StringView getBaseName() const override {
+  std::string_view getBaseName() const override {
     switch (SSK) {
     case SpecialSubKind::allocator:
-      return StringView("allocator");
+      return {"allocator"};
     case SpecialSubKind::basic_string:
-      return StringView("basic_string");
+      return {"basic_string"};
     case SpecialSubKind::string:
-      return StringView("basic_string");
+      return {"basic_string"};
     case SpecialSubKind::istream:
-      return StringView("basic_istream");
+      return {"basic_istream"};
     case SpecialSubKind::ostream:
-      return StringView("basic_ostream");
+      return {"basic_ostream"};
     case SpecialSubKind::iostream:
-      return StringView("basic_iostream");
+      return {"basic_iostream"};
     }
     DEMANGLE_UNREACHABLE;
   }
 @@ -1575,12 +1585,12 @@ public:
   template<typename Fn> void match(Fn F) const { F(SSK); }
-  StringView getBaseName() const override {
+  std::string_view getBaseName() const override {
-    auto SV = ExpandedSpecialSubstitution::getBaseName ();
+    std::string_view SV = ExpandedSpecialSubstitution::getBaseName();
     if (isInstantiation()) {
       // The instantiations are typedefs that drop the "basic_" prefix.
-      assert(SV.startsWith("basic_"));
+      assert(starts_with(SV, "basic_"));
-      SV = SV.dropFront(sizeof("basic_") - 1);
+      SV.remove_prefix(sizeof("basic_") - 1);
     }
     return SV;
   }
 @@ -1628,10 +1638,11 @@ public:
 };
 class UnnamedTypeName : public Node {
-  const StringView Count;
+  const std::string_view Count;
 public:
-  UnnamedTypeName(StringView Count_) : Node(KUnnamedTypeName), Count(Count_) {}
+  UnnamedTypeName(std::string_view Count_)
+      : Node(KUnnamedTypeName), Count(Count_) {}
   template<typename Fn> void match(Fn F) const { F(Count); }
 @@ -1645,11 +1656,11 @@ public:
 class ClosureTypeName : public Node {
   NodeArray TemplateParams;
   NodeArray Params;
-  StringView Count;
+  std::string_view Count;
 public:
   ClosureTypeName(NodeArray TemplateParams_, NodeArray Params_,
-                  StringView Count_)
+                  std::string_view Count_)
       : Node(KClosureTypeName), TemplateParams(TemplateParams_),
         Params(Params_), Count(Count_) {}
 @@ -1696,12 +1707,12 @@ public:
 class BinaryExpr : public Node {
   const Node *LHS;
-  const StringView InfixOperator;
+  const std::string_view InfixOperator;
   const Node *RHS;
 public:
-  BinaryExpr(const Node *LHS_, StringView InfixOperator_, const Node *RHS_,
+  BinaryExpr(const Node *LHS_, std::string_view InfixOperator_,
-             Prec Prec_)
+             const Node *RHS_, Prec Prec_)
       : Node(KBinaryExpr, Prec_), LHS(LHS_), InfixOperator(InfixOperator_),
         RHS(RHS_) {}
 @@ -1750,10 +1761,10 @@ public:
 class PostfixExpr : public Node {
   const Node *Child;
-  const StringView Operator;
+  const std::string_view Operator;
 public:
-  PostfixExpr(const Node *Child_, StringView Operator_, Prec Prec_)
+  PostfixExpr(const Node *Child_, std::string_view Operator_, Prec Prec_)
       : Node(KPostfixExpr, Prec_), Child(Child_), Operator(Operator_) {}
   template <typename Fn> void match(Fn F) const {
 @@ -1791,11 +1802,12 @@ public:
 class MemberExpr : public Node {
   const Node *LHS;
-  const StringView Kind;
+  const std::string_view Kind;
   const Node *RHS;
 public:
-  MemberExpr(const Node *LHS_, StringView Kind_, const Node *RHS_, Prec Prec_)
+  MemberExpr(const Node *LHS_, std::string_view Kind_, const Node *RHS_,
+             Prec Prec_)
       : Node(KMemberExpr, Prec_), LHS(LHS_), Kind(Kind_), RHS(RHS_) {}
   template <typename Fn> void match(Fn F) const {
 @@ -1812,13 +1824,14 @@ public:
 class SubobjectExpr : public Node {
   const Node *Type;
   const Node *SubExpr;
-  StringView Offset;
+  std::string_view Offset;
   NodeArray UnionSelectors;
   bool OnePastTheEnd;
 public:
-  SubobjectExpr(const Node *Type_, const Node *SubExpr_, StringView Offset_,
+  SubobjectExpr(const Node *Type_, const Node *SubExpr_,
-                NodeArray UnionSelectors_, bool OnePastTheEnd_)
+                std::string_view Offset_, NodeArray UnionSelectors_,
+                bool OnePastTheEnd_)
       : Node(KSubobjectExpr), Type(Type_), SubExpr(SubExpr_), Offset(Offset_),
         UnionSelectors(UnionSelectors_), OnePastTheEnd(OnePastTheEnd_) {}
 @@ -1835,7 +1848,7 @@ public:
       OB += "0";
     } else if (Offset[0] == 'n') {
       OB += "-";
-      OB += Offset.dropFront();
+      OB += std::string_view(Offset.data() + 1, Offset.size() - 1);
     } else {
       OB += Offset;
     }
 @@ -1844,12 +1857,12 @@ public:
 };
 class EnclosingExpr : public Node {
-  const StringView Prefix;
+  const std::string_view Prefix;
   const Node *Infix;
-  const StringView Postfix;
+  const std::string_view Postfix;
 public:
-  EnclosingExpr(StringView Prefix_, const Node *Infix_,
+  EnclosingExpr(std::string_view Prefix_, const Node *Infix_,
                 Prec Prec_ = Prec::Primary)
       : Node(KEnclosingExpr, Prec_), Prefix(Prefix_), Infix(Infix_) {}
 @@ -1868,12 +1881,13 @@ public:
 class CastExpr : public Node {
   // cast_kind<to>(from)
-  const StringView CastKind;
+  const std::string_view CastKind;
   const Node *To;
   const Node *From;
 public:
-  CastExpr(StringView CastKind_, const Node *To_, const Node *From_, Prec Prec_)
+  CastExpr(std::string_view 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 {
 @@ -1996,11 +2010,11 @@ public:
 };
 class PrefixExpr : public Node {
-  StringView Prefix;
+  std::string_view Prefix;
   Node *Child;
 public:
-  PrefixExpr(StringView Prefix_, Node *Child_, Prec Prec_)
+  PrefixExpr(std::string_view Prefix_, Node *Child_, Prec Prec_)
       : Node(KPrefixExpr, Prec_), Prefix(Prefix_), Child(Child_) {}
   template <typename Fn> void match(Fn F) const {
 @@ -2014,10 +2028,11 @@ public:
 };
 class FunctionParam : public Node {
-  StringView Number;
+  std::string_view Number;
 public:
-  FunctionParam(StringView Number_) : Node(KFunctionParam), Number(Number_) {}
+  FunctionParam(std::string_view Number_)
+      : Node(KFunctionParam), Number(Number_) {}
   template<typename Fn> void match(Fn F) const { F(Number); }
 @@ -2052,11 +2067,11 @@ public:
 class PointerToMemberConversionExpr : public Node {
   const Node *Type;
   const Node *SubExpr;
-  StringView Offset;
+  std::string_view Offset;
 public:
   PointerToMemberConversionExpr(const Node *Type_, const Node *SubExpr_,
-                                StringView Offset_, Prec Prec_)
+                                std::string_view Offset_, Prec Prec_)
       : Node(KPointerToMemberConversionExpr, Prec_), Type(Type_),
         SubExpr(SubExpr_), Offset(Offset_) {}
 @@ -2141,11 +2156,11 @@ public:
 class FoldExpr : public Node {
   const Node *Pack, *Init;
-  StringView OperatorName;
+  std::string_view OperatorName;
   bool IsLeftFold;
 public:
-  FoldExpr(bool IsLeftFold_, StringView OperatorName_, const Node *Pack_,
+  FoldExpr(bool IsLeftFold_, std::string_view OperatorName_, const Node *Pack_,
            const Node *Init_)
       : Node(KFoldExpr), Pack(Pack_), Init(Init_), OperatorName(OperatorName_),
         IsLeftFold(IsLeftFold_) {}
 @@ -2209,7 +2224,7 @@ public:
   template<typename Fn> void match(Fn F) const { F(Value); }
   void printLeft(OutputBuffer &OB) const override {
-    OB += Value ? StringView("true") : StringView("false");
+    OB += Value ? std::string_view("true") : std::string_view("false");
   }
 };
 @@ -2247,10 +2262,10 @@ public:
 class EnumLiteral : public Node {
   // ty(integer)
   const Node *Ty;
-  StringView Integer;
+  std::string_view Integer;
 public:
-  EnumLiteral(const Node *Ty_, StringView Integer_)
+  EnumLiteral(const Node *Ty_, std::string_view Integer_)
       : Node(KEnumLiteral), Ty(Ty_), Integer(Integer_) {}
   template<typename Fn> void match(Fn F) const { F(Ty, Integer); }
 @@ -2261,18 +2276,18 @@ public:
     OB.printClose();
     if (Integer[0] == 'n')
-      OB << "-" << Integer.dropFront(1);
+      OB << '-' << std::string_view(Integer.data() + 1, Integer.size() - 1);
     else
       OB << Integer;
   }
 };
 class IntegerLiteral : public Node {
-  StringView Type;
+  std::string_view Type;
-  StringView Value;
+  std::string_view Value;
 public:
-  IntegerLiteral(StringView Type_, StringView Value_)
+  IntegerLiteral(std::string_view Type_, std::string_view Value_)
       : Node(KIntegerLiteral), Type(Type_), Value(Value_) {}
   template<typename Fn> void match(Fn F) const { F(Type, Value); }
 @@ -2284,10 +2299,9 @@ public:
       OB.printClose();
     }
-    if (Value[0] == 'n') {
+    if (Value[0] == 'n')
-      OB += '-';
+      OB << '-' << std::string_view(Value.data() + 1, Value.size() - 1);
-      OB += Value.dropFront(1);
+    else
-    } else
       OB += Value;
     if (Type.size() <= 3)
 @@ -2310,29 +2324,26 @@ constexpr Node::Kind getFloatLiteralKind(long double *) {
 }
 template <class Float> class FloatLiteralImpl : public Node {
-  const StringView Contents;
+  const std::string_view Contents;
   static constexpr Kind KindForClass =
       float_literal_impl::getFloatLiteralKind((Float *)nullptr);
 public:
-  FloatLiteralImpl(StringView Contents_)
+  FloatLiteralImpl(std::string_view 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) {
+    if (Contents.size() >= N) {
-      last = first + N;
       union {
         Float value;
         char buf[sizeof(Float)];
       };
-      const char *t = first;
+      const char *t = Contents.data();
+      const char *last = t + N;
       char *e = buf;
       for (; t != last; ++t, ++e) {
         unsigned d1 = isdigit(*t) ? static_cast<unsigned>(*t - '0')
 @@ -2347,7 +2358,7 @@ public:
 #endif
       char num[FloatData<Float>::max_demangled_size] = {0};
       int n = snprintf(num, sizeof(num), FloatData<Float>::spec, value);
-      OB += StringView(num, num + n);
+      OB += std::string_view(num, n);
     }
   }
 };
 @@ -2474,8 +2485,8 @@ template <typename Derived, typename Alloc> struct AbstractManglingParser {
     return res;
   }
-  bool consumeIf(StringView S) {
+  bool consumeIf(std::string_view S) {
-    if (StringView(First, Last).startsWith(S)) {
+    if (starts_with(std::string_view(First, Last - First), S)) {
       First += S.size();
       return true;
     }
 @@ -2500,10 +2511,10 @@ template <typename Derived, typename Alloc> struct AbstractManglingParser {
   size_t numLeft() const { return static_cast<size_t>(Last - First); }
-  StringView parseNumber(bool AllowNegative = false);
+  std::string_view parseNumber(bool AllowNegative = false);
   Qualifiers parseCVQualifiers();
   bool parsePositiveInteger(size_t *Out);
-  StringView parseBareSourceName();
+  std::string_view parseBareSourceName();
   bool parseSeqId(size_t *Out);
   Node *parseSubstitution();
 @@ -2514,9 +2525,9 @@ template <typename Derived, typename Alloc> struct AbstractManglingParser {
   /// Parse the <expr> production.
   Node *parseExpr();
-  Node *parsePrefixExpr(StringView Kind, Node::Prec Prec);
+  Node *parsePrefixExpr(std::string_view Kind, Node::Prec Prec);
-  Node *parseBinaryExpr(StringView Kind, Node::Prec Prec);
+  Node *parseBinaryExpr(std::string_view Kind, Node::Prec Prec);
-  Node *parseIntegerLiteral(StringView Lit);
+  Node *parseIntegerLiteral(std::string_view Lit);
   Node *parseExprPrimary();
   template <class Float> Node *parseFloatingLiteral();
   Node *parseFunctionParam();
 @@ -2624,17 +2635,18 @@ template <typename Derived, typename Alloc> struct AbstractManglingParser {
     bool operator!=(const char *Peek) const { return !this->operator==(Peek); }
   public:
-    StringView getSymbol() const {
+    std::string_view getSymbol() const {
-      StringView Res = Name;
+      std::string_view Res = Name;
       if (Kind < Unnameable) {
-        assert(Res.startsWith("operator") &&
+        assert(starts_with(Res, "operator") &&
                "operator name does not start with 'operator'");
-        Res = Res.dropFront(sizeof("operator") - 1);
+        Res.remove_prefix(sizeof("operator") - 1);
-        Res.consumeFront(' ');
+        if (starts_with(Res, ' '))
+          Res.remove_prefix(1);
       }
       return Res;
     }
-    StringView getName() const { return Name; }
+    std::string_view getName() const { return Name; }
     OIKind getKind() const { return Kind; }
     bool getFlag() const { return Flag; }
     Node::Prec getPrecedence() const { return Prec; }
 @@ -2854,7 +2866,7 @@ AbstractManglingParser<Derived, Alloc>::parseUnnamedTypeName(NameState *State) {
     TemplateParams.clear();
   if (consumeIf("Ut")) {
-    StringView Count = parseNumber();
+    std::string_view Count = parseNumber();
     if (!consumeIf('_'))
       return nullptr;
     return make<UnnamedTypeName>(Count);
 @@ -2866,7 +2878,7 @@ AbstractManglingParser<Derived, Alloc>::parseUnnamedTypeName(NameState *State) {
     size_t ParamsBegin = Names.size();
     while (look() == 'T' &&
-           StringView("yptn").find(look(1)) != StringView::npos) {
+           std::string_view("yptn").find(look(1)) != std::string_view::npos) {
       Node *T = parseTemplateParamDecl();
       if (!T)
         return nullptr;
 @@ -2909,7 +2921,7 @@ AbstractManglingParser<Derived, Alloc>::parseUnnamedTypeName(NameState *State) {
     }
     NodeArray Params = popTrailingNodeArray(ParamsBegin);
-    StringView Count = parseNumber();
+    std::string_view Count = parseNumber();
     if (!consumeIf('_'))
       return nullptr;
     return make<ClosureTypeName>(TempParams, Params, Count);
 @@ -2931,9 +2943,9 @@ Node *AbstractManglingParser<Derived, Alloc>::parseSourceName(NameState *) {
     return nullptr;
   if (numLeft() < Length || Length == 0)
     return nullptr;
-  StringView Name(First, First + Length);
+  std::string_view Name(First, Length);
   First += Length;
-  if (Name.startsWith("_GLOBAL__N"))
+  if (starts_with(Name, "_GLOBAL__N"))
     return make<NameType>("(anonymous namespace)");
   return make<NameType>(Name);
 }
 @@ -3447,7 +3459,7 @@ Node *AbstractManglingParser<Derived, Alloc>::parseUnresolvedName(bool Global) {
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseAbiTags(Node *N) {
   while (consumeIf('B')) {
-    StringView SN = parseBareSourceName();
+    std::string_view SN = parseBareSourceName();
     if (SN.empty())
       return nullptr;
     N = make<AbiTagAttr>(N, SN);
 @@ -3459,16 +3471,16 @@ Node *AbstractManglingParser<Derived, Alloc>::parseAbiTags(Node *N) {
 // <number> ::= [n] <non-negative decimal integer>
 template <typename Alloc, typename Derived>
-StringView
+std::string_view
 AbstractManglingParser<Alloc, Derived>::parseNumber(bool AllowNegative) {
   const char *Tmp = First;
   if (AllowNegative)
     consumeIf('n');
   if (numLeft() == 0 || !std::isdigit(*First))
-    return StringView();
+    return std::string_view();
   while (numLeft() != 0 && std::isdigit(*First))
     ++First;
-  return StringView(Tmp, First);
+  return std::string_view(Tmp, First - Tmp);
 }
 // <positive length number> ::= [0-9]*
 @@ -3485,11 +3497,11 @@ bool AbstractManglingParser<Alloc, Derived>::parsePositiveInteger(size_t *Out) {
 }
 template <typename Alloc, typename Derived>
-StringView AbstractManglingParser<Alloc, Derived>::parseBareSourceName() {
+std::string_view AbstractManglingParser<Alloc, Derived>::parseBareSourceName() {
   size_t Int = 0;
   if (parsePositiveInteger(&Int) || numLeft() < Int)
-    return StringView();
+    return {};
-  StringView R(First, First + Int);
+  std::string_view R(First, Int);
   First += Int;
   return R;
 }
 @@ -3673,7 +3685,7 @@ Node *AbstractManglingParser<Derived, Alloc>::parsePointerToMemberType() {
 //                   ::= Te <name>  # dependent elaborated type specifier using 'enum'
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseClassEnumType() {
-  StringView ElabSpef;
+  std::string_view ElabSpef;
   if (consumeIf("Ts"))
     ElabSpef = "struct";
   else if (consumeIf("Tu"))
 @@ -3697,17 +3709,18 @@ Node *AbstractManglingParser<Derived, Alloc>::parseClassEnumType() {
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseQualifiedType() {
   if (consumeIf('U')) {
-    StringView Qual = parseBareSourceName();
+    std::string_view Qual = parseBareSourceName();
     if (Qual.empty())
       return nullptr;
     // extension            ::= U <objc-name> <objc-type>  # objc-type<identifier>
-    if (Qual.startsWith("objcproto")) {
+    if (starts_with(Qual, "objcproto")) {
-      StringView ProtoSourceName = Qual.dropFront(std::strlen("objcproto"));
+      constexpr size_t Len = sizeof("objcproto") - 1;
-      StringView Proto;
+      std::string_view ProtoSourceName(Qual.data() + Len, Qual.size() - Len);
+      std::string_view Proto;
       {
-        ScopedOverride<const char *> SaveFirst(First, ProtoSourceName.begin()),
+        ScopedOverride<const char *> SaveFirst(First, ProtoSourceName.data()),
-            SaveLast(Last, ProtoSourceName.end());
+            SaveLast(Last, &*ProtoSourceName.rbegin() + 1);
         Proto = parseBareSourceName();
       }
       if (Proto.empty())
 @@ -3875,7 +3888,7 @@ Node *AbstractManglingParser<Derived, Alloc>::parseType() {
   // <builtin-type> ::= u <source-name>    # vendor extended type
   case 'u': {
     ++First;
-    StringView Res = parseBareSourceName();
+    std::string_view Res = parseBareSourceName();
     if (Res.empty())
       return nullptr;
     // Typically, <builtin-type>s are not considered substitution candidates,
 @@ -4123,8 +4136,9 @@ Node *AbstractManglingParser<Derived, Alloc>::parseType() {
 }
 template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parsePrefixExpr(StringView Kind,
+Node *
-                                                              Node::Prec Prec) {
+AbstractManglingParser<Derived, Alloc>::parsePrefixExpr(std::string_view Kind,
+                                                        Node::Prec Prec) {
   Node *E = getDerived().parseExpr();
   if (E == nullptr)
     return nullptr;
 @@ -4132,8 +4146,9 @@ Node *AbstractManglingParser<Derived, Alloc>::parsePrefixExpr(StringView Kind,
 }
 template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseBinaryExpr(StringView Kind,
+Node *
-                                                              Node::Prec Prec) {
+AbstractManglingParser<Derived, Alloc>::parseBinaryExpr(std::string_view Kind,
+                                                        Node::Prec Prec) {
   Node *LHS = getDerived().parseExpr();
   if (LHS == nullptr)
     return nullptr;
 @@ -4144,9 +4159,9 @@ Node *AbstractManglingParser<Derived, Alloc>::parseBinaryExpr(StringView Kind,
 }
 template <typename Derived, typename Alloc>
-Node *
+Node *AbstractManglingParser<Derived, Alloc>::parseIntegerLiteral(
-AbstractManglingParser<Derived, Alloc>::parseIntegerLiteral(StringView Lit) {
+    std::string_view Lit) {
-  StringView Tmp = parseNumber(true);
+  std::string_view Tmp = parseNumber(true);
   if (!Tmp.empty() && consumeIf('E'))
     return make<IntegerLiteral>(Lit, Tmp);
   return nullptr;
 @@ -4176,7 +4191,7 @@ Node *AbstractManglingParser<Derived, Alloc>::parseFunctionParam() {
     return make<NameType>("this");
   if (consumeIf("fp")) {
     parseCVQualifiers();
-    StringView Num = parseNumber();
+    std::string_view Num = parseNumber();
     if (!consumeIf('_'))
       return nullptr;
     return make<FunctionParam>(Num);
 @@ -4187,7 +4202,7 @@ Node *AbstractManglingParser<Derived, Alloc>::parseFunctionParam() {
     if (!consumeIf('p'))
       return nullptr;
     parseCVQualifiers();
-    StringView Num = parseNumber();
+    std::string_view Num = parseNumber();
     if (!consumeIf('_'))
       return nullptr;
     return make<FunctionParam>(Num);
 @@ -4341,7 +4356,7 @@ Node *AbstractManglingParser<Derived, Alloc>::parseExprPrimary() {
     Node *T = getDerived().parseType();
     if (T == nullptr)
       return nullptr;
-    StringView N = parseNumber(/*AllowNegative=*/true);
+    std::string_view N = parseNumber(/*AllowNegative=*/true);
     if (N.empty())
       return nullptr;
     if (!consumeIf('E'))
 @@ -4464,7 +4479,7 @@ AbstractManglingParser<Derived, Alloc>::parsePointerToMemberConversionExpr(
   Node *Expr = getDerived().parseExpr();
   if (!Expr)
     return nullptr;
-  StringView Offset = getDerived().parseNumber(true);
+  std::string_view Offset = getDerived().parseNumber(true);
   if (!consumeIf('E'))
     return nullptr;
   return make<PointerToMemberConversionExpr>(Ty, Expr, Offset, Prec);
 @@ -4482,7 +4497,7 @@ Node *AbstractManglingParser<Derived, Alloc>::parseSubobjectExpr() {
   Node *Expr = getDerived().parseExpr();
   if (!Expr)
     return nullptr;
-  StringView Offset = getDerived().parseNumber(true);
+  std::string_view Offset = getDerived().parseNumber(true);
   size_t SelectorsBegin = Names.size();
   while (consumeIf('_')) {
     Node *Selector = make<NameType>(parseNumber());
 @@ -5141,7 +5156,7 @@ Node *AbstractManglingParser<Alloc, Derived>::parseFloatingLiteral() {
   const size_t N = FloatData<Float>::mangled_size;
   if (numLeft() <= N)
     return nullptr;
-  StringView Data(First, First + N);
+  std::string_view Data(First, N);
   for (char C : Data)
     if (!std::isxdigit(C))
       return nullptr;
 @@ -5461,7 +5476,8 @@ Node *AbstractManglingParser<Derived, Alloc>::parse() {
     if (Encoding == nullptr)
       return nullptr;
     if (look() == '.') {
-      Encoding = make<DotSuffix>(Encoding, StringView(First, Last));
+      Encoding =
+          make<DotSuffix>(Encoding, std::string_view(First, Last - First));
       First = Last;
     }
     if (numLeft() != 0)
 @@ -5497,4 +5513,8 @@ struct ManglingParser : AbstractManglingParser<ManglingParser<Alloc>, Alloc> {
 DEMANGLE_NAMESPACE_END
+#ifdef _LIBCXXABI_COMPILER_CLANG
+#pragma clang diagnostic pop
+#endif
 #endif // DEMANGLE_ITANIUMDEMANGLE_H

lib/libcxxabi/src/demangle/StringView.h deleted-122

...	@@ -1,122 +0,0 @@
1	//===--- StringView.h -------------------------------------------- C++ --===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	//
9	// FIXME: Use std::string_view instead when we support C++17.
10	// There are two copies of this file in the source tree. The one under
11	// libcxxabi is the original and the one under llvm is the copy. Use
12	// cp-to-llvm.sh to update the copy. See README.txt for more details.
13	//
14	//===----------------------------------------------------------------------===//
15
16	#ifndef DEMANGLE_STRINGVIEW_H
17	#define DEMANGLE_STRINGVIEW_H
18
19	#include "DemangleConfig.h"
20	#include <cassert>
21	#include <cstring>
22
23	DEMANGLE_NAMESPACE_BEGIN
24
25	class StringView {
26	const char *First;
27	const char *Last;
28
29	public:
30	static const size_t npos = ~size_t(0);
31
32	template <size_t N>
33	StringView(const char (&Str)[N]) : First(Str), Last(Str + N - 1) {}
34	StringView(const char First_, const char Last_)
35	: First(First_), Last(Last_) {}
36	StringView(const char *First_, size_t Len)
37	: First(First_), Last(First_ + Len) {}
38	StringView(const char *Str) : First(Str), Last(Str + std::strlen(Str)) {}
39	StringView() : First(nullptr), Last(nullptr) {}
40
41	StringView substr(size_t Pos, size_t Len = npos) const {
42	assert(Pos <= size());
43	if (Len > size() - Pos)
44	Len = size() - Pos;
45	return StringView(begin() + Pos, Len);
46	}
47
48	size_t find(char C, size_t From = 0) const {
49	// Avoid calling memchr with nullptr.
50	if (From < size()) {
51	// Just forward to memchr, which is faster than a hand-rolled loop.
52	if (const void *P = ::memchr(First + From, C, size() - From))
53	return size_t(static_cast<const char *>(P) - First);
54	}
55	return npos;
56	}
57
58	StringView dropFront(size_t N = 1) const {
59	if (N >= size())
60	N = size();
61	return StringView(First + N, Last);
62	}
63
64	StringView dropBack(size_t N = 1) const {
65	if (N >= size())
66	N = size();
67	return StringView(First, Last - N);
68	}
69
70	char front() const {
71	assert(!empty());
72	return *begin();
73	}
74
75	char back() const {
76	assert(!empty());
77	return *(end() - 1);
78	}
79
80	char popFront() {
81	assert(!empty());
82	return *First++;
83	}
84
85	bool consumeFront(char C) {
86	if (!startsWith(C))
87	return false;
88	*this = dropFront(1);
89	return true;
90	}
91
92	bool consumeFront(StringView S) {
93	if (!startsWith(S))
94	return false;
95	*this = dropFront(S.size());
96	return true;
97	}
98
99	bool startsWith(char C) const { return !empty() && *begin() == C; }
100
101	bool startsWith(StringView Str) const {
102	if (Str.size() > size())
103	return false;
104	return std::strncmp(Str.begin(), begin(), Str.size()) == 0;
105	}
106
107	const char &operator[](size_t Idx) const { return *(begin() + Idx); }
108
109	const char *begin() const { return First; }
110	const char *end() const { return Last; }
111	size_t size() const { return static_cast<size_t>(Last - First); }
112	bool empty() const { return First == Last; }
113	};
114
115	inline bool operator==(const StringView &LHS, const StringView &RHS) {
116	return LHS.size() == RHS.size() &&
117	std::strncmp(LHS.begin(), RHS.begin(), LHS.size()) == 0;
118	}
119
120	DEMANGLE_NAMESPACE_END
121
122	#endif

lib/libcxxabi/src/demangle/StringViewExtras.h created+38

...	@@ -0,0 +1,38 @@
1	//===--- StringViewExtras.h -------------------------------------- C++ --===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	//
9	// There are two copies of this file in the source tree. The one under
10	// libcxxabi is the original and the one under llvm is the copy. Use
11	// cp-to-llvm.sh to update the copy. See README.txt for more details.
12	//
13	//===----------------------------------------------------------------------===//
14
15	#ifndef DEMANGLE_STRINGVIEW_H
16	#define DEMANGLE_STRINGVIEW_H
17
18	#include "DemangleConfig.h"
19
20	#include <string_view>
21
22	DEMANGLE_NAMESPACE_BEGIN
23
24	inline bool starts_with(std::string_view self, char C) noexcept {
25	return !self.empty() && *self.begin() == C;
26	}
27
28	inline bool starts_with(std::string_view haystack,
29	std::string_view needle) noexcept {
30	if (needle.size() > haystack.size())
31	return false;
32	haystack.remove_suffix(haystack.size() - needle.size());
33	return haystack == needle;
34	}
35
36	DEMANGLE_NAMESPACE_END
37
38	#endif

lib/libcxxabi/src/demangle/Utility.h+14-8

 @@ -16,13 +16,16 @@
 #ifndef DEMANGLE_UTILITY_H
 #define DEMANGLE_UTILITY_H
-#include "StringView.h"
+#include "DemangleConfig.h"
 #include <array>
+#include <cassert>
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <exception>
 #include <limits>
+#include <string_view>
 DEMANGLE_NAMESPACE_BEGIN
 @@ -64,7 +67,8 @@ class OutputBuffer {
     if (isNeg)
       *--TempPtr = '-';
-    return operator+=(StringView(TempPtr, Temp.data() + Temp.size()));
+    return operator+=(
+        std::string_view(TempPtr, Temp.data() + Temp.size() - TempPtr));
   }
 public:
 @@ -77,7 +81,9 @@ public:
   OutputBuffer(const OutputBuffer &) = delete;
   OutputBuffer &operator=(const OutputBuffer &) = delete;
-  operator StringView() const { return StringView(Buffer, CurrentPosition); }
+  operator std::string_view() const {
+    return std::string_view(Buffer, CurrentPosition);
+  }
   /// If a ParameterPackExpansion (or similar type) is encountered, the offset
   /// into the pack that we're currently printing.
 @@ -99,10 +105,10 @@ public:
     *this += Close;
   }
-  OutputBuffer &operator+=(StringView R) {
+  OutputBuffer &operator+=(std::string_view R) {
     if (size_t Size = R.size()) {
       grow(Size);
-      std::memcpy(Buffer + CurrentPosition, R.begin(), Size);
+      std::memcpy(Buffer + CurrentPosition, &*R.begin(), Size);
       CurrentPosition += Size;
     }
     return *this;
 @@ -114,18 +120,18 @@ public:
     return *this;
   }
-  OutputBuffer &prepend(StringView R) {
+  OutputBuffer &prepend(std::string_view R) {
     size_t Size = R.size();
     grow(Size);
     std::memmove(Buffer + Size, Buffer, CurrentPosition);
-    std::memcpy(Buffer, R.begin(), Size);
+    std::memcpy(Buffer, &*R.begin(), Size);
     CurrentPosition += Size;
     return *this;
   }
-  OutputBuffer &operator<<(StringView R) { return (*this += R); }
+  OutputBuffer &operator<<(std::string_view R) { return (*this += R); }
   OutputBuffer &operator<<(char C) { return (*this += C); }

lib/libcxxabi/src/fallback_malloc.cpp+1-1

 @@ -15,10 +15,10 @@
 #endif
 #endif
+#include <__memory/aligned_alloc.h>
 #include <assert.h>
 #include <stdlib.h> // for malloc, calloc, free
 #include <string.h> // for memset
-#include <new> // for std::__libcpp_aligned_{alloc,free}
 //  A small, simple heap manager based (loosely) on
 //  the startup heap manager from FreeBSD, optimized for space.

lib/libcxxabi/src/private_typeinfo.cpp+124-62

...	@@ -41,6 +41,7 @@	...	@@ -41,6 +41,7 @@
41	// Defining _LIBCXXABI_FORGIVING_DYNAMIC_CAST does not help since can_catch() calls	41	// Defining _LIBCXXABI_FORGIVING_DYNAMIC_CAST does not help since can_catch() calls
42	// is_equal() with use_strcmp=false so the string names are not compared.	42	// is_equal() with use_strcmp=false so the string names are not compared.
43		43
		44	#include <cstdint>
44	#include <string.h>	45	#include <string.h>
45		46
46	#ifdef _LIBCXXABI_FORGIVING_DYNAMIC_CAST	47	#ifdef _LIBCXXABI_FORGIVING_DYNAMIC_CAST
...	@@ -656,77 +657,138 @@ __dynamic_cast(const void static_ptr, const __class_type_info static_type,	...	@@ -656,77 +657,138 @@ __dynamic_cast(const void static_ptr, const __class_type_info static_type,
656	// Find out if we can use a giant short cut in the search	657	// Find out if we can use a giant short cut in the search
657	if (is_equal(dynamic_type, dst_type, false))	658	if (is_equal(dynamic_type, dst_type, false))
658	{	659	{
659	// Using giant short cut. Add that information to info.	660	// We're downcasting from src_type to the complete object's dynamic
660	info.number_of_dst_type = 1;	661	// type. This is a really hot path that can be further optimized
661	// Do the search	662	// with the `src2dst_offset` hint.
662	dynamic_type->search_above_dst(&info, dynamic_ptr, dynamic_ptr, public_path, false);	663	// In such a case, dynamic_ptr already gives the casting result if the
663	#ifdef _LIBCXXABI_FORGIVING_DYNAMIC_CAST	664	// casting ever succeeds. All we have to do now is to check
664	// The following if should always be false because we should definitely	665	// static_ptr points to a public base sub-object of dynamic_ptr.
665	// find (static_ptr, static_type), either on a public or private path	666
666	if (info.path_dst_ptr_to_static_ptr == unknown)	667	if (src2dst_offset >= 0)
667	{	668	{
668	// We get here only if there is some kind of visibility problem	669	// The static type is a unique public non-virtual base type of
669	// in client code.	670	// dst_type at offset `src2dst_offset` from the origin of dst.
670	static_assert(std::atomic<size_t>::is_always_lock_free, "");	671	// Note that there might be other non-public static_type bases. The
671	static std::atomic<size_t> error_count(0);	672	// hint only guarantees that the public base is non-virtual and
672	size_t error_count_snapshot = error_count.fetch_add(1, std::memory_order_relaxed);	673	// unique. So we have to check whether static_ptr points to that
673	if ((error_count_snapshot & (error_count_snapshot-1)) == 0)	674	// unique public base sub-object.
674	syslog(LOG_ERR, "dynamic_cast error 1: Both of the following type_info's "	675	if (offset_to_derived == -src2dst_offset)
675	"should have public visibility. At least one of them is hidden. %s"	676	dst_ptr = dynamic_ptr;
676	", %s.\n", static_type->name(), dynamic_type->name());	677	}
677	// Redo the search comparing type_info's using strcmp	678	else if (src2dst_offset == -2)
678	info = {dst_type, static_ptr, static_type, src2dst_offset, 0};	679	{
679	info.number_of_dst_type = 1;	680	// static_type is not a public base of dst_type.
680	dynamic_type->search_above_dst(&info, dynamic_ptr, dynamic_ptr, public_path, true);	681	dst_ptr = nullptr;
681	}	682	}
		683	else
		684	{
		685	// If src2dst_offset == -3, then:
		686	// src_type is a multiple public base type but never a virtual
		687	// base type. We can't conclude that static_ptr points to those
		688	// public base sub-objects because there might be other non-
		689	// public static_type bases. The search is inevitable.
		690
		691	// Fallback to the slow path to check that static_type is a public
		692	// base type of dynamic_type.
		693	// Using giant short cut. Add that information to info.
		694	info.number_of_dst_type = 1;
		695	// Do the search
		696	dynamic_type->search_above_dst(&info, dynamic_ptr, dynamic_ptr, public_path, false);
		697	#ifdef _LIBCXXABI_FORGIVING_DYNAMIC_CAST
		698	// The following if should always be false because we should
		699	// definitely find (static_ptr, static_type), either on a public
		700	// or private path
		701	if (info.path_dst_ptr_to_static_ptr == unknown)
		702	{
		703	// We get here only if there is some kind of visibility problem
		704	// in client code.
		705	static_assert(std::atomic<size_t>::is_always_lock_free, "");
		706	static std::atomic<size_t> error_count(0);
		707	size_t error_count_snapshot = error_count.fetch_add(1, std::memory_order_relaxed);
		708	if ((error_count_snapshot & (error_count_snapshot-1)) == 0)
		709	syslog(LOG_ERR, "dynamic_cast error 1: Both of the following type_info's "
		710	"should have public visibility. At least one of them is hidden. %s"
		711	", %s.\n", static_type->name(), dynamic_type->name());
		712	// Redo the search comparing type_info's using strcmp
		713	info = {dst_type, static_ptr, static_type, src2dst_offset, 0};
		714	info.number_of_dst_type = 1;
		715	dynamic_type->search_above_dst(&info, dynamic_ptr, dynamic_ptr, public_path, true);
		716	}
682	#endif // _LIBCXXABI_FORGIVING_DYNAMIC_CAST	717	#endif // _LIBCXXABI_FORGIVING_DYNAMIC_CAST
683	// Query the search.	718	// Query the search.
684	if (info.path_dst_ptr_to_static_ptr == public_path)	719	if (info.path_dst_ptr_to_static_ptr == public_path)
685	dst_ptr = dynamic_ptr;	720	dst_ptr = dynamic_ptr;
		721	}
686	}	722	}
687	else	723	else
688	{	724	{
689	// Not using giant short cut. Do the search	725	if (src2dst_offset >= 0)
690	dynamic_type->search_below_dst(&info, dynamic_ptr, public_path, false);
691	#ifdef _LIBCXXABI_FORGIVING_DYNAMIC_CAST
692	// The following if should always be false because we should definitely
693	// find (static_ptr, static_type), either on a public or private path
694	if (info.path_dst_ptr_to_static_ptr == unknown &&
695	info.path_dynamic_ptr_to_static_ptr == unknown)
696	{	726	{
697	static_assert(std::atomic<size_t>::is_always_lock_free, "");	727	// Optimize toward downcasting: dst_type has one unique public
698	static std::atomic<size_t> error_count(0);	728	// static_type bases. Let's first try to do a downcast before
699	size_t error_count_snapshot = error_count.fetch_add(1, std::memory_order_relaxed);	729	// falling back to the slow path. The downcast succeeds if there
700	if ((error_count_snapshot & (error_count_snapshot-1)) == 0)	730	// is at least one path regardless of visibility from
701	syslog(LOG_ERR, "dynamic_cast error 2: One or more of the following type_info's "	731	// dynamic_type to dst_type.
702	"has hidden visibility or is defined in more than one translation "	732	const void* dst_ptr_to_static = reinterpret_cast<const char*>(static_ptr) - src2dst_offset;
703	"unit. They should all have public visibility. "	733	if (reinterpret_cast<std::intptr_t>(dst_ptr_to_static) >= reinterpret_cast<std::intptr_t>(dynamic_ptr))
704	"%s, %s, %s.\n", static_type->name(), dynamic_type->name(),	734	{
705	dst_type->name());	735	// Try to search a path from dynamic_type to dst_type.
706	// Redo the search comparing type_info's using strcmp	736	__dynamic_cast_info dynamic_to_dst_info = {dynamic_type, dst_ptr_to_static, dst_type, src2dst_offset};
707	info = {dst_type, static_ptr, static_type, src2dst_offset, 0};	737	dynamic_to_dst_info.number_of_dst_type = 1;
708	dynamic_type->search_below_dst(&info, dynamic_ptr, public_path, true);	738	dynamic_type->search_above_dst(&dynamic_to_dst_info, dynamic_ptr, dynamic_ptr, public_path, false);
		739	if (dynamic_to_dst_info.path_dst_ptr_to_static_ptr != unknown) {
		740	// We have found at least one path from dynamic_ptr to
		741	// dst_ptr. The downcast can succeed.
		742	dst_ptr = dst_ptr_to_static;
		743	}
		744	}
709	}	745	}
710	#endif // _LIBCXXABI_FORGIVING_DYNAMIC_CAST	746
711	// Query the search.	747	if (!dst_ptr)
712	switch (info.number_to_static_ptr)
713	{	748	{
714	case 0:	749	// Not using giant short cut. Do the search
715	if (info.number_to_dst_ptr == 1 &&	750	dynamic_type->search_below_dst(&info, dynamic_ptr, public_path, false);
716	info.path_dynamic_ptr_to_static_ptr == public_path &&	751	#ifdef _LIBCXXABI_FORGIVING_DYNAMIC_CAST
717	info.path_dynamic_ptr_to_dst_ptr == public_path)	752	// The following if should always be false because we should
718	dst_ptr = info.dst_ptr_not_leading_to_static_ptr;	753	// definitely find (static_ptr, static_type), either on a public
719	break;	754	// or private path
720	case 1:	755	if (info.path_dst_ptr_to_static_ptr == unknown &&
721	if (info.path_dst_ptr_to_static_ptr == public_path \|\|	756	info.path_dynamic_ptr_to_static_ptr == unknown)
722	(	757	{
723	info.number_to_dst_ptr == 0 &&	758	static_assert(std::atomic<size_t>::is_always_lock_free, "");
724	info.path_dynamic_ptr_to_static_ptr == public_path &&	759	static std::atomic<size_t> error_count(0);
725	info.path_dynamic_ptr_to_dst_ptr == public_path	760	size_t error_count_snapshot = error_count.fetch_add(1, std::memory_order_relaxed);
726	)	761	if ((error_count_snapshot & (error_count_snapshot-1)) == 0)
727	)	762	syslog(LOG_ERR, "dynamic_cast error 2: One or more of the following type_info's "
728	dst_ptr = info.dst_ptr_leading_to_static_ptr;	763	"has hidden visibility or is defined in more than one translation "
729	break;	764	"unit. They should all have public visibility. "
		765	"%s, %s, %s.\n", static_type->name(), dynamic_type->name(),
		766	dst_type->name());
		767	// Redo the search comparing type_info's using strcmp
		768	info = {dst_type, static_ptr, static_type, src2dst_offset, 0};
		769	dynamic_type->search_below_dst(&info, dynamic_ptr, public_path, true);
		770	}
		771	#endif // _LIBCXXABI_FORGIVING_DYNAMIC_CAST
		772	// Query the search.
		773	switch (info.number_to_static_ptr)
		774	{
		775	case 0:
		776	if (info.number_to_dst_ptr == 1 &&
		777	info.path_dynamic_ptr_to_static_ptr == public_path &&
		778	info.path_dynamic_ptr_to_dst_ptr == public_path)
		779	dst_ptr = info.dst_ptr_not_leading_to_static_ptr;
		780	break;
		781	case 1:
		782	if (info.path_dst_ptr_to_static_ptr == public_path \|\|
		783	(
		784	info.number_to_dst_ptr == 0 &&
		785	info.path_dynamic_ptr_to_static_ptr == public_path &&
		786	info.path_dynamic_ptr_to_dst_ptr == public_path
		787	)
		788	)
		789	dst_ptr = info.dst_ptr_leading_to_static_ptr;
		790	break;
		791	}
730	}	792	}
731	}	793	}
732	return const_cast<void*>(dst_ptr);	794	return const_cast<void*>(dst_ptr);

lib/libcxxabi/src/stdlib_new_delete.cpp+57-46

 @@ -4,30 +4,40 @@
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
-//
-// This file implements the new and delete operators.
 //===----------------------------------------------------------------------===//
 #include "__cxxabi_config.h"
-#include <new>
+#include <__memory/aligned_alloc.h>
 #include <cstdlib>
+#include <new>
+// Perform a few sanity checks on libc++ and libc++abi macros to ensure that
+// the code below can be an exact copy of the code in libcxx/src/new.cpp.
+#if !defined(_THROW_BAD_ALLOC)
+#  error The _THROW_BAD_ALLOC macro should be already defined by libc++
+#endif
+#ifndef _LIBCPP_WEAK
+#  error The _LIBCPP_WEAK macro should be already defined by libc++
+#endif
-#if !defined(_THROW_BAD_ALLOC) || !defined(_LIBCXXABI_WEAK)
+#if defined(_LIBCXXABI_NO_EXCEPTIONS) != defined(_LIBCPP_HAS_NO_EXCEPTIONS)
-#error The _THROW_BAD_ALLOC and _LIBCXXABI_WEAK libc++ macros must \
+#  error libc++ and libc++abi seem to disagree on whether exceptions are enabled
-       already be defined by libc++.
 #endif
+// ------------------ BEGIN COPY ------------------
 // Implement all new and delete operators as weak definitions
 // in this shared library, so that they can be overridden by programs
 // that define non-weak copies of the functions.
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void *
 operator new(std::size_t size) _THROW_BAD_ALLOC
 {
     if (size == 0)
         size = 1;
     void* p;
-    while ((p = ::malloc(size)) == nullptr)
+    while ((p = std::malloc(size)) == nullptr)
     {
         // If malloc fails and there is a new_handler,
         // call it to try free up memory.
 @@ -35,7 +45,7 @@ operator new(std::size_t size) _THROW_BAD_ALLOC
         if (nh)
             nh();
         else
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
             throw std::bad_alloc();
 #else
             break;
 @@ -44,87 +54,87 @@ operator new(std::size_t size) _THROW_BAD_ALLOC
     return p;
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void*
 operator new(size_t size, const std::nothrow_t&) noexcept
 {
     void* p = nullptr;
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     try
     {
-#endif // _LIBCXXABI_NO_EXCEPTIONS
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
         p = ::operator new(size);
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
-#endif // _LIBCXXABI_NO_EXCEPTIONS
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
     return p;
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void*
 operator new[](size_t size) _THROW_BAD_ALLOC
 {
     return ::operator new(size);
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void*
 operator new[](size_t size, const std::nothrow_t&) noexcept
 {
     void* p = nullptr;
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     try
     {
-#endif // _LIBCXXABI_NO_EXCEPTIONS
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
         p = ::operator new[](size);
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
-#endif // _LIBCXXABI_NO_EXCEPTIONS
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
     return p;
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete(void* ptr) noexcept
 {
-    ::free(ptr);
+    std::free(ptr);
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete(void* ptr, const std::nothrow_t&) noexcept
 {
     ::operator delete(ptr);
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete(void* ptr, size_t) noexcept
 {
     ::operator delete(ptr);
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete[] (void* ptr) noexcept
 {
     ::operator delete(ptr);
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete[] (void* ptr, const std::nothrow_t&) noexcept
 {
     ::operator delete[](ptr);
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete[] (void* ptr, size_t) noexcept
 {
 @@ -133,7 +143,7 @@ operator delete[] (void* ptr, size_t) noexcept
 #if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION)
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void *
 operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
 {
 @@ -155,7 +165,7 @@ operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
         if (nh)
             nh();
         else {
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
             throw std::bad_alloc();
 #else
             break;
 @@ -165,87 +175,87 @@ operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
     return p;
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void*
 operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     void* p = nullptr;
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     try
     {
-#endif // _LIBCXXABI_NO_EXCEPTIONS
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
         p = ::operator new(size, alignment);
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
-#endif // _LIBCXXABI_NO_EXCEPTIONS
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
     return p;
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void*
 operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
 {
     return ::operator new(size, alignment);
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void*
 operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     void* p = nullptr;
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     try
     {
-#endif // _LIBCXXABI_NO_EXCEPTIONS
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
         p = ::operator new[](size, alignment);
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
-#endif // _LIBCXXABI_NO_EXCEPTIONS
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
     return p;
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete(void* ptr, std::align_val_t) noexcept
 {
     std::__libcpp_aligned_free(ptr);
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     ::operator delete(ptr, alignment);
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete(void* ptr, size_t, std::align_val_t alignment) noexcept
 {
     ::operator delete(ptr, alignment);
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete[] (void* ptr, std::align_val_t alignment) noexcept
 {
     ::operator delete(ptr, alignment);
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     ::operator delete[](ptr, alignment);
 }
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete[] (void* ptr, size_t, std::align_val_t alignment) noexcept
 {
 @@ -253,3 +263,4 @@ operator delete[] (void* ptr, size_t, std::align_val_t alignment) noexcept
 }
 #endif // !_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
+// ------------------ END COPY ------------------

...	@@ -255,7 +255,7 @@ struct InitByteNoThreads {	...	@@ -255,7 +255,7 @@ struct InitByteNoThreads {
255	if (*init_byte_address == COMPLETE_BIT)	255	if (*init_byte_address == COMPLETE_BIT)
256	return true;	256	return true;
257	if (*init_byte_address & PENDING_BIT)	257	if (*init_byte_address & PENDING_BIT)
258	ABORT_WITH_MESSAGE("__cxa_guard_acquire detected recursive initialization");	258	ABORT_WITH_MESSAGE("__cxa_guard_acquire detected recursive initialization: do you have a function-local static variable whose initialization depends on that function?");
259	*init_byte_address = PENDING_BIT;	259	*init_byte_address = PENDING_BIT;
260	return false;	260	return false;
261	}	261	}
...	@@ -325,7 +325,7 @@ public:	...	@@ -325,7 +325,7 @@ public:
325	// Check for possible recursive initialization.	325	// Check for possible recursive initialization.
326	if (has_thread_id_support && (*init_byte_address & PENDING_BIT)) {	326	if (has_thread_id_support && (*init_byte_address & PENDING_BIT)) {
327	if (*thread_id_address == current_thread_id.get())	327	if (*thread_id_address == current_thread_id.get())
328	ABORT_WITH_MESSAGE("__cxa_guard_acquire detected recursive initialization");	328	ABORT_WITH_MESSAGE("__cxa_guard_acquire detected recursive initialization: do you have a function-local static variable whose initialization depends on that function?");
329	}	329	}
330		330
331	// Wait until the pending bit is not set.	331	// Wait until the pending bit is not set.
...	@@ -460,7 +460,7 @@ public:	...	@@ -460,7 +460,7 @@ public:
460		460
461	// Check for recursive initialization	461	// Check for recursive initialization
462	if (has_thread_id_support && thread_id.load(std::_AO_Relaxed) == current_thread_id.get()) {	462	if (has_thread_id_support && thread_id.load(std::_AO_Relaxed) == current_thread_id.get()) {
463	ABORT_WITH_MESSAGE("__cxa_guard_acquire detected recursive initialization");	463	ABORT_WITH_MESSAGE("__cxa_guard_acquire detected recursive initialization: do you have a function-local static variable whose initialization depends on that function?");
464	}	464	}
465		465
466	if ((last_val & WAITING_BIT) == 0) {	466	if ((last_val & WAITING_BIT) == 0) {