HardenedBSD / src / d544fe5 / Merge llvm-project release/19.x llvmorg-19.1.0-rc1-0-ga4902a36d5c2

HardenedBSD/src d544fe5 — . ObsoleteFiles.inc, contrib/llvm-project/clang/include/clang/Basic DiagnosticSemaKinds.td TokenKinds.def

Dec 1, 2024 by Dimitry Andric (dim) on ⎇

freebsd/14-stable/main

Merge llvm-project release/19.x llvmorg-19.1.0-rc1-0-ga4902a36d5c2

This updates llvm, clang, compiler-rt, libc++, libunwind, lld, lldb and
openmp to llvm-project release/19.x llvmorg-19.1.0-rc1-0-ga4902a36d5c2.

PR:             280562
MFC after:      1 month

(cherry picked from commit 36b606ae6aa4b24061096ba18582e0a08ccd5dba)

Delta		File
+0	-2,136	lib/libc++/module.modulemap
+89	-0	contrib/llvm-project/libcxx/include/__math/hypot.h
+0	-62	contrib/llvm-project/llvm/lib/Transforms/Scalar/LICM.cpp
+58	-0	contrib/llvm-project/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
+24	-22	contrib/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_ptrauth.h
+44	-0	contrib/llvm-project/compiler-rt/lib/builtins/aarch64/sme-abi.S
+22	-22	contrib/llvm-project/llvm/include/llvm/MC/MCDwarf.h
+42	-0	contrib/llvm-project/compiler-rt/lib/builtins/trampoline_setup.c
+26	-13	contrib/llvm-project/clang/lib/Basic/Targets/PPC.cpp
+23	-9	contrib/llvm-project/clang/lib/AST/ExprConstant.cpp
+27	-2	contrib/llvm-project/libcxx/include/deque
+0	-28	contrib/llvm-project/compiler-rt/lib/builtins/aarch64/sme-abi-vg.c
+24	-4	contrib/llvm-project/llvm/lib/Analysis/BasicAliasAnalysis.cpp
+26	-1	contrib/llvm-project/clang/lib/Parse/ParseExpr.cpp
+1	-24	contrib/llvm-project/libcxx/include/cmath
+24	-0	contrib/llvm-project/libcxx/include/__iterator/bounded_iter.h
+23	-0	contrib/llvm-project/libcxx/include/__iterator/wrap_iter.h
+21	-2	contrib/llvm-project/clang/lib/Sema/SemaExpr.cpp
+14	-8	contrib/llvm-project/clang/lib/AST/Interp/Interp.h
+11	-11	contrib/llvm-project/llvm/lib/Analysis/ValueTracking.cpp
+19	-2	contrib/llvm-project/clang/lib/Headers/stddef.h
+17	-3	contrib/llvm-project/llvm/lib/Target/PowerPC/PPC.td
+1	-19	contrib/llvm-project/clang/lib/Sema/SemaOverload.cpp
+19	-0	contrib/llvm-project/clang/lib/Headers/ptrauth.h
+13	-6	contrib/llvm-project/clang/lib/Basic/Targets/PPC.h
+14	-3	contrib/llvm-project/libcxx/include/string
+14	-3	contrib/llvm-project/llvm/include/llvm/Analysis/AliasAnalysis.h
+7	-7	contrib/llvm-project/llvm/include/llvm/CodeGen/MachineFrameInfo.h
+14	-0	contrib/llvm-project/libcxx/include/__bit_reference
+6	-6	contrib/llvm-project/llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp
+5	-5	contrib/llvm-project/clang/include/clang/Driver/Options.td
+7	-3	contrib/llvm-project/clang/lib/Sema/SemaChecking.cpp
+5	-5	contrib/llvm-project/llvm/lib/CodeGen/CFIInstrInserter.cpp
+7	-2	contrib/llvm-project/llvm/lib/Target/AArch64/AArch64Subtarget.cpp
+4	-4	contrib/llvm-project/llvm/lib/Target/RISCV/RISCVInstrInfoC.td
+2	-6	contrib/llvm-project/llvm/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp
+8	-0	contrib/llvm-project/clang/lib/AST/ItaniumMangle.cpp
+4	-4	contrib/llvm-project/llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp
+7	-0	contrib/llvm-project/llvm/lib/TargetParser/Host.cpp
+6	-1	contrib/llvm-project/llvm/lib/Target/AArch64/AArch64InstrInfo.cpp
+6	-0	contrib/llvm-project/llvm/include/llvm/Analysis/SimplifyQuery.h
+3	-3	lib/clang/include/lldb/Version/Version.inc
+3	-3	contrib/llvm-project/llvm/lib/MC/MCDwarf.cpp
+3	-3	lib/clang/include/clang/Basic/Version.inc
+3	-3	lib/clang/include/VCSVersion.inc
+4	-2	contrib/llvm-project/llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp
+3	-2	contrib/llvm-project/llvm/lib/Target/NVPTX/NVPTXISelLowering.cpp
+5	-0	contrib/llvm-project/compiler-rt/lib/builtins/README.txt
+5	-0	lib/clang/libclang/Makefile
+2	-2	contrib/llvm-project/llvm/lib/CodeGen/PrologEpilogInserter.cpp
+2	-2	contrib/llvm-project/llvm/lib/Target/X86/X86FrameLowering.cpp
+4	-0	contrib/llvm-project/clang/lib/Driver/ToolChains/Clang.cpp
+4	-0	contrib/llvm-project/libcxx/include/locale
+2	-2	contrib/llvm-project/llvm/lib/Target/Hexagon/HexagonFrameLowering.cpp
+4	-0	contrib/llvm-project/llvm/lib/Target/AArch64/AArch64MachineFunctionInfo.cpp
+1	-3	lib/libc++/Makefile
+2	-2	contrib/llvm-project/llvm/lib/Target/PowerPC/PPCTargetTransformInfo.cpp
+2	-2	contrib/llvm-project/llvm/include/llvm/CodeGen/TargetFrameLowering.h
+2	-2	lib/clang/include/llvm/Config/llvm-config.h
+2	-2	contrib/llvm-project/clang/lib/Headers/stdarg.h
+2	-2	lib/clang/include/llvm/Config/config.h
+3	-1	contrib/llvm-project/clang/include/clang/Sema/Overload.h
+4	-0	contrib/llvm-project/clang/lib/Headers/stdatomic.h
+2	-2	contrib/llvm-project/llvm/lib/Target/ARM/ARMFrameLowering.cpp
+3	-0	contrib/llvm-project/clang/include/clang/Basic/DiagnosticSemaKinds.td
+3	-0	contrib/llvm-project/clang/lib/Driver/ToolChains/Arch/PPC.cpp
+2	-1	contrib/llvm-project/clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp
+3	-0	contrib/llvm-project/llvm/include/llvm/TargetParser/PPCTargetParser.def
+2	-1	contrib/llvm-project/llvm/lib/Target/AArch64/AArch64PointerAuth.cpp
+2	-1	contrib/llvm-project/llvm/lib/Target/AArch64/AArch64Subtarget.h
+3	-0	contrib/llvm-project/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
+1	-1	contrib/llvm-project/compiler-rt/lib/ubsan/ubsan_type_hash_itanium.cpp
+2	-0	contrib/llvm-project/clang/include/clang/Parse/Parser.h
+2	-0	contrib/llvm-project/clang/include/clang/Sema/Sema.h
+1	-1	lib/clang/include/llvm/Support/VCSRevision.h
+1	-1	contrib/llvm-project/llvm/include/llvm/MC/MCAsmBackend.h
+1	-1	contrib/llvm-project/libcxx/include/__config
+1	-1	contrib/llvm-project/llvm/lib/Target/MSP430/MSP430FrameLowering.cpp
+2	-0	contrib/llvm-project/clang/include/clang/Basic/TokenKinds.def
+1	-1	contrib/llvm-project/llvm/lib/Target/ARM/MCTargetDesc/ARMAsmBackendDarwin.h
+1	-1	contrib/llvm-project/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
+1	-1	contrib/llvm-project/llvm/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp
+2	-0	contrib/llvm-project/llvm/lib/Target/AArch64/AArch64ISelLowering.h
+1	-1	lib/clang/include/lld/Common/Version.inc
+1	-1	contrib/llvm-project/llvm/lib/CodeGen/MachineFrameInfo.cpp
+1	-0	contrib/llvm-project/llvm/lib/Target/PowerPC/PPCInstrInfo.cpp
+0	-1	ObsoleteFiles.inc
+1	-0	lib/clang/libllvm/Makefile
+0	-1	contrib/llvm-project/llvm/lib/Target/LoongArch/LoongArchInstrInfo.td
+1	-0	contrib/llvm-project/llvm/lib/Target/PowerPC/PPCSubtarget.h
+790	-2,476	90 files

Unified Split Raw

  OLD_FILES+=usr/include/c++/v1/__pstl/internal/unseq_backend_simd.h
  OLD_FILES+=usr/include/c++/v1/__pstl/internal/utils.h
  OLD_DIRS+=usr/include/c++/v1/__pstl/internal
--OLD_DIRS+=usr/include/c++/v1/__pstl
  OLD_FILES+=usr/include/c++/v1/__pstl_algorithm
  OLD_FILES+=usr/include/c++/v1/__pstl_memory
  OLD_FILES+=usr/include/c++/v1/__pstl_numeric

    InGroup<PtrAuthNullPointers>;
  def err_ptrauth_string_not_literal : Error<
    "argument must be a string literal%select{| of char type}0">;
++def err_ptrauth_type_disc_undiscriminated : Error<
++  "cannot pass undiscriminated type %0 to "
++  "'__builtin_ptrauth_type_discriminator'">;
  def note_ptrauth_virtual_function_pointer_incomplete_arg_ret :
    Note<"cannot take an address of a virtual member function if its return or "

  KEYWORD(__private_extern__          , KEYALL)
  KEYWORD(__module_private__          , KEYALL)
++UNARY_EXPR_OR_TYPE_TRAIT(__builtin_ptrauth_type_discriminator, PtrAuthTypeDiscriminator, KEYALL)
++
  // Extension that will be enabled for Microsoft, Borland and PS4, but can be
  // disabled via '-fno-declspec'.
  KEYWORD(__declspec                  , 0)

  def combine : Flag<["-", "--"], "combine">, Flags<[NoXarchOption, Unsupported]>;
  def compatibility__version : JoinedOrSeparate<["-"], "compatibility_version">;
  def config : Joined<["--"], "config=">, Flags<[NoXarchOption]>,
--  Visibility<[ClangOption, CLOption, DXCOption]>, MetaVarName<"<file>">,
++  Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>, MetaVarName<"<file>">,
    HelpText<"Specify configuration file">;
--def : Separate<["--"], "config">, Alias<config>;
++def : Separate<["--"], "config">, Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>, Alias<config>;
  def no_default_config : Flag<["--"], "no-default-config">,
--  Flags<[NoXarchOption]>, Visibility<[ClangOption, CLOption, DXCOption]>,
++  Flags<[NoXarchOption]>, Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>,
    HelpText<"Disable loading default configuration files">;
  def config_system_dir_EQ : Joined<["--"], "config-system-dir=">,
    Flags<[NoXarchOption, HelpHidden]>,
--  Visibility<[ClangOption, CLOption, DXCOption]>,
++  Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>,
    HelpText<"System directory for configuration files">;
  def config_user_dir_EQ : Joined<["--"], "config-user-dir=">,
    Flags<[NoXarchOption, HelpHidden]>,
--  Visibility<[ClangOption, CLOption, DXCOption]>,
++  Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>,
    HelpText<"User directory for configuration files">;
  def coverage : Flag<["-", "--"], "coverage">, Group<Link_Group>,
    Visibility<[ClangOption, CLOption]>;

    ExprResult ParseArrayTypeTrait();
    ExprResult ParseExpressionTrait();
++  ExprResult ParseBuiltinPtrauthTypeDiscriminator();
++
    //===--------------------------------------------------------------------===//
    // Preprocessor code-completion pass-through
    void CodeCompleteDirective(bool InConditional) override;

    private:
      friend class OverloadCandidateSet;
      OverloadCandidate()
--        : IsSurrogate(false), IsADLCandidate(CallExpr::NotADL), RewriteKind(CRK_None) {}
++        : IsSurrogate(false), IgnoreObjectArgument(false),
++          TookAddressOfOverload(false), IsADLCandidate(CallExpr::NotADL),
++          RewriteKind(CRK_None) {}
    };
    /// OverloadCandidateSet - A set of overload candidates, used in C++

                                      TemplateIdAnnotation *TemplateId,
                                      bool IsMemberSpecialization);
++  bool checkPointerAuthEnabled(SourceLocation Loc, SourceRange Range);
++
    bool checkConstantPointerAuthKey(Expr *keyExpr, unsigned &key);
    /// Diagnose function specifiers on a declaration of an identifier that

contrib/llvm-project/clang/lib/AST/ExprConstant.cpp
@@ -2839,6 +2839,8 @@ static bool handleIntIntBinOp(EvalInfo &Info, const BinaryOperator *E,
	// During constant-folding, a negative shift is an opposite shift. Such	// During constant-folding, a negative shift is an opposite shift. Such
	// a shift is not a constant expression.	// a shift is not a constant expression.
	Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;	Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
		+ if (!Info.noteUndefinedBehavior())
		+ return false;
	RHS = -RHS;	RHS = -RHS;
	goto shift_right;	goto shift_right;
	}	}
@@ -2849,19 +2851,23 @@ static bool handleIntIntBinOp(EvalInfo &Info, const BinaryOperator *E,
	if (SA != RHS) {	if (SA != RHS) {
	Info.CCEDiag(E, diag::note_constexpr_large_shift)	Info.CCEDiag(E, diag::note_constexpr_large_shift)
	<< RHS << E->getType() << LHS.getBitWidth();	<< RHS << E->getType() << LHS.getBitWidth();
		+ if (!Info.noteUndefinedBehavior())
		+ return false;
	} else if (LHS.isSigned() && !Info.getLangOpts().CPlusPlus20) {	} else if (LHS.isSigned() && !Info.getLangOpts().CPlusPlus20) {
	// C++11 [expr.shift]p2: A signed left shift must have a non-negative	// C++11 [expr.shift]p2: A signed left shift must have a non-negative
	// operand, and must not overflow the corresponding unsigned type.	// operand, and must not overflow the corresponding unsigned type.
	// C++2a [expr.shift]p2: E1 << E2 is the unique value congruent to	// C++2a [expr.shift]p2: E1 << E2 is the unique value congruent to
	// E1 x 2^E2 module 2^N.	// E1 x 2^E2 module 2^N.
	- if (LHS.isNegative())	+ if (LHS.isNegative()) {
	Info.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << LHS;	Info.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << LHS;
	- else if (LHS.countl_zero() < SA)	+ if (!Info.noteUndefinedBehavior())
		+ return false;
		+ } else if (LHS.countl_zero() < SA) {
	Info.CCEDiag(E, diag::note_constexpr_lshift_discards);	Info.CCEDiag(E, diag::note_constexpr_lshift_discards);
		+ if (!Info.noteUndefinedBehavior())
		+ return false;
		+ }
	}	}
	- if (Info.EvalStatus.Diag && !Info.EvalStatus.Diag->empty() &&
	- Info.getLangOpts().CPlusPlus11)
	- return false;
	Result = LHS << SA;	Result = LHS << SA;
	return true;	return true;
	}	}
@@ -2875,6 +2881,8 @@ static bool handleIntIntBinOp(EvalInfo &Info, const BinaryOperator *E,
	// During constant-folding, a negative shift is an opposite shift. Such a	// During constant-folding, a negative shift is an opposite shift. Such a
	// shift is not a constant expression.	// shift is not a constant expression.
	Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;	Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
		+ if (!Info.noteUndefinedBehavior())
		+ return false;
	RHS = -RHS;	RHS = -RHS;
	goto shift_left;	goto shift_left;
	}	}
@@ -2882,13 +2890,13 @@ static bool handleIntIntBinOp(EvalInfo &Info, const BinaryOperator *E,
	// C++11 [expr.shift]p1: Shift width must be less than the bit width of the	// C++11 [expr.shift]p1: Shift width must be less than the bit width of the
	// shifted type.	// shifted type.
	unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);	unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
	- if (SA != RHS)	+ if (SA != RHS) {
	Info.CCEDiag(E, diag::note_constexpr_large_shift)	Info.CCEDiag(E, diag::note_constexpr_large_shift)
	<< RHS << E->getType() << LHS.getBitWidth();	<< RHS << E->getType() << LHS.getBitWidth();
		+ if (!Info.noteUndefinedBehavior())
		+ return false;
		+ }

	- if (Info.EvalStatus.Diag && !Info.EvalStatus.Diag->empty() &&
	- Info.getLangOpts().CPlusPlus11)
	- return false;
	Result = LHS >> SA;	Result = LHS >> SA;
	return true;	return true;
	}	}
@@ -14054,6 +14062,12 @@ bool IntExprEvaluator::VisitUnaryExprOrTypeTraitExpr(
	E);	E);
	}	}

		+ case UETT_PtrAuthTypeDiscriminator: {
		+ if (E->getArgumentType()->isDependentType())
		+ return false;
		+ return Success(
		+ Info.Ctx.getPointerAuthTypeDiscriminator(E->getArgumentType()), E);
		+ }
	case UETT_VecStep: {	case UETT_VecStep: {
	QualType Ty = E->getTypeOfArgument();	QualType Ty = E->getTypeOfArgument();

    if (RHS.isNegative()) {
      const SourceInfo &Loc = S.Current->getSource(OpPC);
      S.CCEDiag(Loc, diag::note_constexpr_negative_shift) << RHS.toAPSInt();
--    return false;
++    if (!S.noteUndefinedBehavior())
++      return false;
    }
    // C++11 [expr.shift]p1: Shift width must be less than the bit width of
      const APSInt Val = RHS.toAPSInt();
      QualType Ty = E->getType();
      S.CCEDiag(E, diag::note_constexpr_large_shift) << Val << Ty << Bits;
--    return !(S.getEvalStatus().Diag && !S.getEvalStatus().Diag->empty() && S.getLangOpts().CPlusPlus11);
++    if (!S.noteUndefinedBehavior())
++      return false;
    }
    if (LHS.isSigned() && !S.getLangOpts().CPlusPlus20) {
      const Expr *E = S.Current->getExpr(OpPC);
      // C++11 [expr.shift]p2: A signed left shift must have a non-negative
      // operand, and must not overflow the corresponding unsigned type.
--    if (LHS.isNegative())
++    if (LHS.isNegative()) {
        S.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << LHS.toAPSInt();
--    else if (LHS.toUnsigned().countLeadingZeros() < static_cast<unsigned>(RHS))
++      if (!S.noteUndefinedBehavior())
++        return false;
++    } else if (LHS.toUnsigned().countLeadingZeros() <
++               static_cast<unsigned>(RHS)) {
        S.CCEDiag(E, diag::note_constexpr_lshift_discards);
++      if (!S.noteUndefinedBehavior())
++        return false;
++    }
    }
    // C++2a [expr.shift]p2: [P0907R4]:
      // shift is not a constant expression.
      const SourceInfo &Loc = S.Current->getSource(OpPC);
      S.CCEDiag(Loc, diag::note_constexpr_negative_shift) << RHS.toAPSInt();
--    if (S.getLangOpts().CPlusPlus11 && S.getEvalStatus().Diag &&
++    if (!S.noteUndefinedBehavior())
--        !S.getEvalStatus().Diag->empty())
        return false;
      RHS = -RHS;
      return DoShift < LT, RT,
        // E1 x 2^E2 module 2^N.
        const SourceInfo &Loc = S.Current->getSource(OpPC);
        S.CCEDiag(Loc, diag::note_constexpr_lshift_of_negative) << LHS.toAPSInt();
--      if (S.getLangOpts().CPlusPlus11 && S.getEvalStatus().Diag &&
++      if (!S.noteUndefinedBehavior())
--          !S.getEvalStatus().Diag->empty())
          return false;
      }
    }

contrib/llvm-project/clang/lib/AST/ItaniumMangle.cpp
@@ -5179,6 +5179,14 @@ recurse:
	Diags.Report(DiagID);	Diags.Report(DiagID);
	return;	return;
	}	}
		+ case UETT_PtrAuthTypeDiscriminator: {
		+ DiagnosticsEngine &Diags = Context.getDiags();
		+ unsigned DiagID = Diags.getCustomDiagID(
		+ DiagnosticsEngine::Error,
		+ "cannot yet mangle __builtin_ptrauth_type_discriminator expression");
		+ Diags.Report(E->getExprLoc(), DiagID);
		+ return;
		+ }
	case UETT_VecStep: {	case UETT_VecStep: {
	DiagnosticsEngine &Diags = Context.getDiags();	DiagnosticsEngine &Diags = Context.getDiags();
	unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,	unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,

contrib/llvm-project/clang/lib/Basic/Targets/PPC.cpp
@@ -385,6 +385,8 @@ void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
	Builder.defineMacro("_ARCH_PWR9");	Builder.defineMacro("_ARCH_PWR9");
	if (ArchDefs & ArchDefinePwr10)	if (ArchDefs & ArchDefinePwr10)
	Builder.defineMacro("_ARCH_PWR10");	Builder.defineMacro("_ARCH_PWR10");
		+ if (ArchDefs & ArchDefinePwr11)
		+ Builder.defineMacro("_ARCH_PWR11");
	if (ArchDefs & ArchDefineA2)	if (ArchDefs & ArchDefineA2)
	Builder.defineMacro("_ARCH_A2");	Builder.defineMacro("_ARCH_A2");
	if (ArchDefs & ArchDefineE500)	if (ArchDefs & ArchDefineE500)
@@ -622,10 +624,17 @@ bool PPCTargetInfo::initFeatureMap(
	addP10SpecificFeatures(Features);	addP10SpecificFeatures(Features);
	}	}

	- // ~~Future~~ ~~CPU~~ ~~should include~~ all of the features ~~of Power 10~~ as ~~well~~ as any	+ // Power11 includes all the same features as Power10 plus any features
		+ // specific to the Power11 core.
		+ if (CPU == "pwr11" \|\| CPU == "power11") {
		+ initFeatureMap(Features, Diags, "pwr10", FeaturesVec);
		+ addP11SpecificFeatures(Features);
		+ }
		+
		+ // Future CPU should include all of the features of Power 11 as well as any
	// additional features (yet to be determined) specific to it.	// additional features (yet to be determined) specific to it.
	if (CPU == "future") {	if (CPU == "future") {
	- initFeatureMap(Features, Diags, ~~"pwr10"~~, FeaturesVec);	+ initFeatureMap(Features, Diags, "pwr11", FeaturesVec);
	addFutureSpecificFeatures(Features);	addFutureSpecificFeatures(Features);
	}	}

@@ -696,6 +705,10 @@ void PPCTargetInfo::addP10SpecificFeatures(
	Features["isa-v31-instructions"] = true;	Features["isa-v31-instructions"] = true;
	}	}

		+// Add any Power11 specific features.
		+void PPCTargetInfo::addP11SpecificFeatures(
		+ llvm::StringMap<bool> &Features) const {}
		+
	// Add features specific to the "Future" CPU.	// Add features specific to the "Future" CPU.
	void PPCTargetInfo::addFutureSpecificFeatures(	void PPCTargetInfo::addFutureSpecificFeatures(
	llvm::StringMap<bool> &Features) const {}	llvm::StringMap<bool> &Features) const {}
@@ -870,17 +883,17 @@ ArrayRef<TargetInfo::AddlRegName> PPCTargetInfo::getGCCAddlRegNames() const {
	}	}

	static constexpr llvm::StringLiteral ValidCPUNames[] = {	static constexpr llvm::StringLiteral ValidCPUNames[] = {
	- {"generic"}, {"440"}, {"450"}, {"601"}, {"602"},	+ {"generic"}, {"440"}, {"450"}, {"601"}, {"602"},
	- {"603"}, {"603e"}, {"603ev"}, {"604"}, {"604e"},	+ {"603"}, {"603e"}, {"603ev"}, {"604"}, {"604e"},
	- {"620"}, {"630"}, {"g3"}, {"7400"}, {"g4"},	+ {"620"}, {"630"}, {"g3"}, {"7400"}, {"g4"},
	- {"7450"}, {"g4+"}, {"750"}, {"8548"}, {"970"},	+ {"7450"}, {"g4+"}, {"750"}, {"8548"}, {"970"},
	- {"g5"}, {"a2"}, {"e500"}, {"e500mc"}, {"e5500"},	+ {"g5"}, {"a2"}, {"e500"}, {"e500mc"}, {"e5500"},
	- {"power3"}, {"pwr3"}, {"power4"}, {"pwr4"}, {"power5"},	+ {"power3"}, {"pwr3"}, {"power4"}, {"pwr4"}, {"power5"},
	- {"pwr5"}, {"power5x"}, {"pwr5x"}, {"power6"}, {"pwr6"},	+ {"pwr5"}, {"power5x"}, {"pwr5x"}, {"power6"}, {"pwr6"},
	- {"power6x"}, {"pwr6x"}, {"power7"}, {"pwr7"}, {"power8"},	+ {"power6x"}, {"pwr6x"}, {"power7"}, {"pwr7"}, {"power8"},
	- {"pwr8"}, {"power9"}, {"pwr9"}, {"power10"}, {"pwr10"},	+ {"pwr8"}, {"power9"}, {"pwr9"}, {"power10"}, {"pwr10"},
	- {~~"powerpc"~~}, {~~"ppc"~~}, {~~"ppc32"~~}, {~~"powerpc64"~~}, {~~"ppc64"~~},	+ {"power11"}, {"pwr11"}, {"powerpc"}, {"ppc"}, {"ppc32"},
	- {"powerpc64le"}, {"ppc64le"}, {"future"}};	+ {"powerpc64"}, {"ppc64"}, {"powerpc64le"}, {"ppc64le"}, {"future"}};

	bool PPCTargetInfo::isValidCPUName(StringRef Name) const {	bool PPCTargetInfo::isValidCPUName(StringRef Name) const {
	return llvm::is_contained(ValidCPUNames, Name);	return llvm::is_contained(ValidCPUNames, Name);

contrib/llvm-project/clang/lib/Basic/Targets/PPC.h
@@ -44,8 +44,9 @@ class LLVM_LIBRARY_VISIBILITY PPCTargetInfo : public TargetInfo {
	ArchDefinePwr8 = 1 << 12,	ArchDefinePwr8 = 1 << 12,
	ArchDefinePwr9 = 1 << 13,	ArchDefinePwr9 = 1 << 13,
	ArchDefinePwr10 = 1 << 14,	ArchDefinePwr10 = 1 << 14,
	- ~~ArchDefineFuture~~ = 1 << 15,	+ ArchDefinePwr11 = 1 << 15,
	- ~~ArchDefineA2~~ = 1 << 16,	+ ArchDefineFuture = 1 << 16,
		+ ArchDefineA2 = 1 << 17,
	ArchDefineE500 = 1 << 18	ArchDefineE500 = 1 << 18
	} ArchDefineTypes;	} ArchDefineTypes;

@@ -166,11 +167,16 @@ public:
	ArchDefinePwr7 \| ArchDefinePwr6 \| ArchDefinePwr5x \|	ArchDefinePwr7 \| ArchDefinePwr6 \| ArchDefinePwr5x \|
	ArchDefinePwr5 \| ArchDefinePwr4 \| ArchDefinePpcgr \|	ArchDefinePwr5 \| ArchDefinePwr4 \| ArchDefinePpcgr \|
	ArchDefinePpcsq)	ArchDefinePpcsq)
		+ .Cases("power11", "pwr11",
		+ ArchDefinePwr11 \| ArchDefinePwr10 \| ArchDefinePwr9 \|
		+ ArchDefinePwr8 \| ArchDefinePwr7 \| ArchDefinePwr6 \|
		+ ArchDefinePwr5x \| ArchDefinePwr5 \| ArchDefinePwr4 \|
		+ ArchDefinePpcgr \| ArchDefinePpcsq)
	.Case("future",	.Case("future",
	- ArchDefineFuture \| ~~ArchDefinePwr10~~ \| ~~ArchDefinePwr9~~ \|	+ ArchDefineFuture \| ArchDefinePwr11 \| ArchDefinePwr10 \|
	- ~~ArchDefinePwr8~~ \| ~~ArchDefinePwr7~~ \| ~~ArchDefinePwr6~~ \|	+ ArchDefinePwr9 \| ArchDefinePwr8 \| ArchDefinePwr7 \|
	- ~~ArchDefinePwr5x~~ \| ~~ArchDefinePwr5~~ \| ~~ArchDefinePwr4~~ \|	+ ArchDefinePwr6 \| ArchDefinePwr5x \| ArchDefinePwr5 \|
	- ArchDefinePpcgr \| ArchDefinePpcsq)	+ ArchDefinePwr4 \| ArchDefinePpcgr \| ArchDefinePpcsq)
	.Cases("8548", "e500", ArchDefineE500)	.Cases("8548", "e500", ArchDefineE500)
	.Default(ArchDefineNone);	.Default(ArchDefineNone);
	}	}
@@ -192,6 +198,7 @@ public:
	const std::vector<std::string> &FeaturesVec) const override;	const std::vector<std::string> &FeaturesVec) const override;

	void addP10SpecificFeatures(llvm::StringMap<bool> &Features) const;	void addP10SpecificFeatures(llvm::StringMap<bool> &Features) const;
		+ void addP11SpecificFeatures(llvm::StringMap<bool> &Features) const;
	void addFutureSpecificFeatures(llvm::StringMap<bool> &Features) const;	void addFutureSpecificFeatures(llvm::StringMap<bool> &Features) const;

	bool handleTargetFeatures(std::vector<std::string> &Features,	bool handleTargetFeatures(std::vector<std::string> &Features,

                           CGF.AllocaInsertPt->getIterator());
    InsertPointTy CodeGenIP(CGF.Builder.GetInsertBlock(),
                            CGF.Builder.GetInsertPoint());
--  llvm::OpenMPIRBuilder::LocationDescription OmpLoc(CodeGenIP);
++  llvm::OpenMPIRBuilder::LocationDescription OmpLoc(
++      CodeGenIP, CGF.SourceLocToDebugLoc(Loc));
    llvm::SmallVector<llvm::OpenMPIRBuilder::ReductionInfo> ReductionInfos;
    CodeGenFunction::OMPPrivateScope Scope(CGF);

        .Case("power8", "pwr8")
        .Case("power9", "pwr9")
        .Case("power10", "pwr10")
++      .Case("power11", "pwr11")
        .Case("future", "future")
        .Case("powerpc", "ppc")
        .Case("powerpc64", "ppc64")
        .Case("power9", "-mpower9")
        .Case("pwr10", "-mpower10")
        .Case("power10", "-mpower10")
++      .Case("pwr11", "-mpower11")
++      .Case("power11", "-mpower11")
        .Default("-many");
  }

contrib/llvm-project/clang/lib/Driver/ToolChains/Clang.cpp
@@ -1516,6 +1516,10 @@ static void handlePAuthABI(const ArgList &DriverArgs, ArgStringList &CC1Args) {
	options::OPT_fno_ptrauth_vtable_pointer_type_discrimination))	options::OPT_fno_ptrauth_vtable_pointer_type_discrimination))
	CC1Args.push_back("-fptrauth-vtable-pointer-type-discrimination");	CC1Args.push_back("-fptrauth-vtable-pointer-type-discrimination");

		+ if (!DriverArgs.hasArg(options::OPT_fptrauth_indirect_gotos,
		+ options::OPT_fno_ptrauth_indirect_gotos))
		+ CC1Args.push_back("-fptrauth-indirect-gotos");
		+
	if (!DriverArgs.hasArg(options::OPT_fptrauth_init_fini,	if (!DriverArgs.hasArg(options::OPT_fptrauth_init_fini,
	options::OPT_fno_ptrauth_init_fini))	options::OPT_fno_ptrauth_init_fini))
	CC1Args.push_back("-fptrauth-init-fini");	CC1Args.push_back("-fptrauth-init-fini");

contrib/llvm-project/clang/lib/Headers/ptrauth.h
@@ -202,6 +202,23 @@ typedef __UINTPTR_TYPE__ ptrauth_generic_signature_t;
	#define ptrauth_string_discriminator(__string) \	#define ptrauth_string_discriminator(__string) \
	__builtin_ptrauth_string_discriminator(__string)	__builtin_ptrauth_string_discriminator(__string)

		+/* Compute a constant discriminator from the given type.
		+
		+ The result can be used as the second argument to
		+ ptrauth_blend_discriminator or the third argument to the
		+ __ptrauth qualifier. It has type size_t.
		+
		+ If the type is a C++ member function pointer type, the result is
		+ the discriminator used to signed member function pointers of that
		+ type. If the type is a function, function pointer, or function
		+ reference type, the result is the discriminator used to sign
		+ functions of that type. It is ill-formed to use this macro with any
		+ other type.
		+
		+ A call to this function is an integer constant expression. */
		+#define ptrauth_type_discriminator(__type) \
		+ __builtin_ptrauth_type_discriminator(__type)
		+
	/* Compute a signature for the given pair of pointer-sized values.	/* Compute a signature for the given pair of pointer-sized values.
	The order of the arguments is significant.	The order of the arguments is significant.

@@ -289,6 +306,8 @@ typedef __UINTPTR_TYPE__ ptrauth_generic_signature_t;
	((ptrauth_extra_data_t)0); \	((ptrauth_extra_data_t)0); \
	})	})

		+#define ptrauth_type_discriminator(__type) ((ptrauth_extra_data_t)0)
		+
	#define ptrauth_sign_generic_data(__value, __data) \	#define ptrauth_sign_generic_data(__value, __data) \
	({ \	({ \
	(void)__value; \	(void)__value; \

   * modules.
   */
  #if defined(__MVS__) && __has_include_next(<stdarg.h>)
--#include <__stdarg_header_macro.h>
  #undef __need___va_list
  #undef __need_va_list
  #undef __need_va_arg
  #undef __need___va_copy
  #undef __need_va_copy
++#include <__stdarg_header_macro.h>
  #include_next <stdarg.h>
  #else
  #if !defined(__need___va_list) && !defined(__need_va_list) &&                  \
      !defined(__need_va_arg) && !defined(__need___va_copy) &&                   \
      !defined(__need_va_copy)
--#include <__stdarg_header_macro.h>
  #define __need___va_list
  #define __need_va_list
  #define __need_va_arg
      !defined(__STRICT_ANSI__)
  #define __need_va_copy
  #endif
++#include <__stdarg_header_macro.h>
  #endif
  #ifdef __need___va_list

  typedef struct atomic_flag { atomic_bool _Value; } atomic_flag;
++#ifdef __cplusplus
++#define ATOMIC_FLAG_INIT {false}
++#else
  #define ATOMIC_FLAG_INIT { 0 }
++#endif
  /* These should be provided by the libc implementation. */
  #ifdef __cplusplus

contrib/llvm-project/clang/lib/Headers/stddef.h
@@ -20,7 +20,6 @@
	* modules.	* modules.
	*/	*/
	#if defined(__MVS__) && __has_include_next(<stddef.h>)	#if defined(__MVS__) && __has_include_next(<stddef.h>)
	-#include <__stddef_header_macro.h>
	#undef __need_ptrdiff_t	#undef __need_ptrdiff_t
	#undef __need_size_t	#undef __need_size_t
	#undef __need_rsize_t	#undef __need_rsize_t
@@ -31,6 +30,7 @@
	#undef __need_max_align_t	#undef __need_max_align_t
	#undef __need_offsetof	#undef __need_offsetof
	#undef __need_wint_t	#undef __need_wint_t
		+#include <__stddef_header_macro.h>
	#include_next <stddef.h>	#include_next <stddef.h>

	#else	#else
@@ -40,7 +40,6 @@
	!defined(__need_NULL) && !defined(__need_nullptr_t) && \	!defined(__need_NULL) && !defined(__need_nullptr_t) && \
	!defined(__need_unreachable) && !defined(__need_max_align_t) && \	!defined(__need_unreachable) && !defined(__need_max_align_t) && \
	!defined(__need_offsetof) && !defined(__need_wint_t)	!defined(__need_offsetof) && !defined(__need_wint_t)
	-#include <__stddef_header_macro.h>
	#define __need_ptrdiff_t	#define __need_ptrdiff_t
	#define __need_size_t	#define __need_size_t
	/* ISO9899:2011 7.20 (C11 Annex K): Define rsize_t if __STDC_WANT_LIB_EXT1__ is	/* ISO9899:2011 7.20 (C11 Annex K): Define rsize_t if __STDC_WANT_LIB_EXT1__ is
@@ -49,7 +48,24 @@
	#define __need_rsize_t	#define __need_rsize_t
	#endif	#endif
	#define __need_wchar_t	#define __need_wchar_t
		+#if !defined(__STDDEF_H) \|\| __has_feature(modules)
		+/*
		+ * __stddef_null.h is special when building without modules: if __need_NULL is
		+ * set, then it will unconditionally redefine NULL. To avoid stepping on client
		+ * definitions of NULL, __need_NULL should only be set the first time this
		+ * header is included, that is when __STDDEF_H is not defined. However, when
		+ * building with modules, this header is a textual header and needs to
		+ * unconditionally include __stdef_null.h to support multiple submodules
		+ * exporting _Builtin_stddef.null. Take module SM with submodules A and B, whose
		+ * headers both include stddef.h When SM.A builds, __STDDEF_H will be defined.
		+ * When SM.B builds, the definition from SM.A will leak when building without
		+ * local submodule visibility. stddef.h wouldn't include __stddef_null.h, and
		+ * SM.B wouldn't import _Builtin_stddef.null, and SM.B's `export *` wouldn't
		+ * export NULL as expected. When building with modules, always include
		+ * __stddef_null.h so that everything works as expected.
		+ */
	#define __need_NULL	#define __need_NULL
		+#endif
	#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L) \|\| \	#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L) \|\| \
	defined(__cplusplus)	defined(__cplusplus)
	#define __need_nullptr_t	#define __need_nullptr_t
@@ -65,6 +81,7 @@
	/* wint_t is provided by <wchar.h> and not <stddef.h>. It's here	/* wint_t is provided by <wchar.h> and not <stddef.h>. It's here
	* for compatibility, but must be explicitly requested. Therefore	* for compatibility, but must be explicitly requested. Therefore
	* __need_wint_t is intentionally not defined here. */	* __need_wint_t is intentionally not defined here. */
		+#include <__stddef_header_macro.h>
	#endif	#endif

	#if defined(__need_ptrdiff_t)	#if defined(__need_ptrdiff_t)

contrib/llvm-project/clang/lib/Parse/ParseExpr.cpp
@@ -763,6 +763,9 @@ class CastExpressionIdValidator final : public CorrectionCandidateCallback {
	bool Parser::isRevertibleTypeTrait(const IdentifierInfo *II,	bool Parser::isRevertibleTypeTrait(const IdentifierInfo *II,
	tok::TokenKind *Kind) {	tok::TokenKind *Kind) {
	if (RevertibleTypeTraits.empty()) {	if (RevertibleTypeTraits.empty()) {
		+// Revertible type trait is a feature for backwards compatibility with older
		+// standard libraries that declare their own structs with the same name as
		+// the builtins listed below. New builtins should NOT be added to this list.
	#define RTT_JOIN(X, Y) X##Y	#define RTT_JOIN(X, Y) X##Y
	#define REVERTIBLE_TYPE_TRAIT(Name) \	#define REVERTIBLE_TYPE_TRAIT(Name) \
	RevertibleTypeTraits[PP.getIdentifierInfo(#Name)] = RTT_JOIN(tok::kw_, Name)	RevertibleTypeTraits[PP.getIdentifierInfo(#Name)] = RTT_JOIN(tok::kw_, Name)
@@ -790,7 +793,6 @@ bool Parser::isRevertibleTypeTrait(const IdentifierInfo *II,
	REVERTIBLE_TYPE_TRAIT(__is_fundamental);	REVERTIBLE_TYPE_TRAIT(__is_fundamental);
	REVERTIBLE_TYPE_TRAIT(__is_integral);	REVERTIBLE_TYPE_TRAIT(__is_integral);
	REVERTIBLE_TYPE_TRAIT(__is_interface_class);	REVERTIBLE_TYPE_TRAIT(__is_interface_class);
	- REVERTIBLE_TYPE_TRAIT(__is_layout_compatible);
	REVERTIBLE_TYPE_TRAIT(__is_literal);	REVERTIBLE_TYPE_TRAIT(__is_literal);
	REVERTIBLE_TYPE_TRAIT(__is_lvalue_expr);	REVERTIBLE_TYPE_TRAIT(__is_lvalue_expr);
	REVERTIBLE_TYPE_TRAIT(__is_lvalue_reference);	REVERTIBLE_TYPE_TRAIT(__is_lvalue_reference);
@@ -841,6 +843,26 @@ bool Parser::isRevertibleTypeTrait(const IdentifierInfo *II,
	return false;	return false;
	}	}

		+ExprResult Parser::ParseBuiltinPtrauthTypeDiscriminator() {
		+ SourceLocation Loc = ConsumeToken();
		+
		+ BalancedDelimiterTracker T(*this, tok::l_paren);
		+ if (T.expectAndConsume())
		+ return ExprError();
		+
		+ TypeResult Ty = ParseTypeName();
		+ if (Ty.isInvalid()) {
		+ SkipUntil(tok::r_paren, StopAtSemi);
		+ return ExprError();
		+ }
		+
		+ SourceLocation EndLoc = Tok.getLocation();
		+ T.consumeClose();
		+ return Actions.ActOnUnaryExprOrTypeTraitExpr(
		+ Loc, UETT_PtrAuthTypeDiscriminator,
		+ /isType=/true, Ty.get().getAsOpaquePtr(), SourceRange(Loc, EndLoc));
		+}
		+
	/// Parse a cast-expression, or, if \pisUnaryExpression is true, parse	/// Parse a cast-expression, or, if \pisUnaryExpression is true, parse
	/// a unary-expression.	/// a unary-expression.
	///	///
@@ -1806,6 +1828,9 @@ ExprResult Parser::ParseCastExpression(CastParseKind ParseKind,
	Res = ParseArrayTypeTrait();	Res = ParseArrayTypeTrait();
	break;	break;

		+ case tok::kw___builtin_ptrauth_type_discriminator:
		+ return ParseBuiltinPtrauthTypeDiscriminator();
		+
	case tok::kw___is_lvalue_expr:	case tok::kw___is_lvalue_expr:
	case tok::kw___is_rvalue_expr:	case tok::kw___is_rvalue_expr:
	if (NotPrimaryExpression)	if (NotPrimaryExpression)

contrib/llvm-project/clang/lib/Sema/SemaChecking.cpp
@@ -1489,14 +1489,18 @@ enum PointerAuthOpKind {
	};	};
	}	}

	-static bool checkPointerAuthEnabled(Sema &S, Expr *E) {	+bool Sema::checkPointerAuthEnabled(SourceLocation Loc, SourceRange Range) {
	- if (S.getLangOpts().PointerAuthIntrinsics)	+ if (getLangOpts().PointerAuthIntrinsics)
	return false;	return false;

	- S.Diag(~~E->getExprLoc()~~, diag::err_ptrauth_disabled) << ~~E->getSourceRange();~~	+ Diag(Loc, diag::err_ptrauth_disabled) << Range;
	return true;	return true;
	}	}

		+static bool checkPointerAuthEnabled(Sema &S, Expr *E) {
		+ return S.checkPointerAuthEnabled(E->getExprLoc(), E->getSourceRange());
		+}
		+
	static bool checkPointerAuthKey(Sema &S, Expr *&Arg) {	static bool checkPointerAuthKey(Sema &S, Expr *&Arg) {
	// Convert it to type 'int'.	// Convert it to type 'int'.
	if (convertArgumentToType(S, Arg, S.Context.IntTy))	if (convertArgumentToType(S, Arg, S.Context.IntTy))

contrib/llvm-project/clang/lib/Sema/SemaExpr.cpp
@@ -4117,6 +4117,21 @@ static bool CheckVectorElementsTraitOperandType(Sema &S, QualType T,
	return false;	return false;
	}	}

		+static bool checkPtrAuthTypeDiscriminatorOperandType(Sema &S, QualType T,
		+ SourceLocation Loc,
		+ SourceRange ArgRange) {
		+ if (S.checkPointerAuthEnabled(Loc, ArgRange))
		+ return true;
		+
		+ if (!T->isFunctionType() && !T->isFunctionPointerType() &&
		+ !T->isFunctionReferenceType() && !T->isMemberFunctionPointerType()) {
		+ S.Diag(Loc, diag::err_ptrauth_type_disc_undiscriminated) << T << ArgRange;
		+ return true;
		+ }
		+
		+ return false;
		+}
		+
	static bool CheckExtensionTraitOperandType(Sema &S, QualType T,	static bool CheckExtensionTraitOperandType(Sema &S, QualType T,
	SourceLocation Loc,	SourceLocation Loc,
	SourceRange ArgRange,	SourceRange ArgRange,
@@ -4511,6 +4526,10 @@ bool Sema::CheckUnaryExprOrTypeTraitOperand(QualType ExprType,
	return CheckVectorElementsTraitOperandType(*this, ExprType, OpLoc,	return CheckVectorElementsTraitOperandType(*this, ExprType, OpLoc,
	ExprRange);	ExprRange);

		+ if (ExprKind == UETT_PtrAuthTypeDiscriminator)
		+ return checkPtrAuthTypeDiscriminatorOperandType(*this, ExprType, OpLoc,
		+ ExprRange);
		+
	// Explicitly list some types as extensions.	// Explicitly list some types as extensions.
	if (!CheckExtensionTraitOperandType(*this, ExprType, OpLoc, ExprRange,	if (!CheckExtensionTraitOperandType(*this, ExprType, OpLoc, ExprRange,
	ExprKind))	ExprKind))
@@ -5711,7 +5730,6 @@ static bool isParenthetizedAndQualifiedAddressOfExpr(Expr *Fn) {
	if (!UO \|\| UO->getOpcode() != clang::UO_AddrOf)	if (!UO \|\| UO->getOpcode() != clang::UO_AddrOf)
	return false;	return false;
	if (auto *DRE = dyn_cast<DeclRefExpr>(UO->getSubExpr()->IgnoreParens())) {	if (auto *DRE = dyn_cast<DeclRefExpr>(UO->getSubExpr()->IgnoreParens())) {
	- assert(isa<FunctionDecl>(DRE->getDecl()) && "expected a function");
	return DRE->hasQualifier();	return DRE->hasQualifier();
	}	}
	if (auto *OVL = dyn_cast<OverloadExpr>(UO->getSubExpr()->IgnoreParens()))	if (auto *OVL = dyn_cast<OverloadExpr>(UO->getSubExpr()->IgnoreParens()))
@@ -17027,7 +17045,8 @@ Sema::VerifyIntegerConstantExpression(Expr E, llvm::APSInt Result,
	// not a constant expression as a side-effect.	// not a constant expression as a side-effect.
	bool Folded =	bool Folded =
	E->EvaluateAsRValue(EvalResult, Context, /isConstantContext/ true) &&	E->EvaluateAsRValue(EvalResult, Context, /isConstantContext/ true) &&
	- EvalResult.Val.isInt() && !EvalResult.~~HasSideEffects;~~	+ EvalResult.Val.isInt() && !EvalResult.HasSideEffects &&
		+ (!getLangOpts().CPlusPlus \|\| !EvalResult.HasUndefinedBehavior);

	if (!isa<ConstantExpr>(E))	if (!isa<ConstantExpr>(E))
	E = ConstantExpr::Create(Context, E, EvalResult.Val);	E = ConstantExpr::Create(Context, E, EvalResult.Val);

    Candidate.Viable = true;
    Candidate.RewriteKind =
        CandidateSet.getRewriteInfo().getRewriteKind(Function, PO);
--  Candidate.IsSurrogate = false;
    Candidate.IsADLCandidate = IsADLCandidate;
--  Candidate.IgnoreObjectArgument = false;
--  Candidate.TookAddressOfOverload = false;
    Candidate.ExplicitCallArguments = Args.size();
    // Explicit functions are not actually candidates at all if we're not
    Candidate.Function = Method;
    Candidate.RewriteKind =
        CandidateSet.getRewriteInfo().getRewriteKind(Method, PO);
--  Candidate.IsSurrogate = false;
--  Candidate.IgnoreObjectArgument = false;
    Candidate.TookAddressOfOverload =
        CandidateSet.getKind() == OverloadCandidateSet::CSK_AddressOfOverloadSet;
    Candidate.ExplicitCallArguments = Args.size();
      Candidate.IgnoreObjectArgument =
          cast<CXXMethodDecl>(Candidate.Function)->isStatic() ||
          ObjectType.isNull();
--    Candidate.TookAddressOfOverload = false;
      Candidate.ExplicitCallArguments = Args.size();
      if (Result == TemplateDeductionResult::NonDependentConversionFailure)
        Candidate.FailureKind = ovl_fail_bad_conversion;
      Candidate.IgnoreObjectArgument =
          isa<CXXMethodDecl>(Candidate.Function) &&
          !isa<CXXConstructorDecl>(Candidate.Function);
--    Candidate.TookAddressOfOverload = false;
      Candidate.ExplicitCallArguments = Args.size();
      if (Result == TemplateDeductionResult::NonDependentConversionFailure)
        Candidate.FailureKind = ovl_fail_bad_conversion;
    OverloadCandidate &Candidate = CandidateSet.addCandidate(1);
    Candidate.FoundDecl = FoundDecl;
    Candidate.Function = Conversion;
--  Candidate.IsSurrogate = false;
--  Candidate.IgnoreObjectArgument = false;
--  Candidate.TookAddressOfOverload = false;
    Candidate.FinalConversion.setAsIdentityConversion();
    Candidate.FinalConversion.setFromType(ConvType);
    Candidate.FinalConversion.setAllToTypes(ToType);
      Candidate.Function = FunctionTemplate->getTemplatedDecl();
      Candidate.Viable = false;
      Candidate.FailureKind = ovl_fail_bad_deduction;
--    Candidate.IsSurrogate = false;
--    Candidate.IgnoreObjectArgument = false;
--    Candidate.TookAddressOfOverload = false;
      Candidate.ExplicitCallArguments = 1;
      Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
                                                            Info);
    Candidate.FoundDecl = FoundDecl;
    Candidate.Function = nullptr;
    Candidate.Surrogate = Conversion;
--  Candidate.Viable = true;
    Candidate.IsSurrogate = true;
--  Candidate.IgnoreObjectArgument = false;
++  Candidate.Viable = true;
--  Candidate.TookAddressOfOverload = false;
    Candidate.ExplicitCallArguments = Args.size();
    // Determine the implicit conversion sequence for the implicit
    OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size());
    Candidate.FoundDecl = DeclAccessPair::make(nullptr, AS_none);
    Candidate.Function = nullptr;
--  Candidate.IsSurrogate = false;
--  Candidate.IgnoreObjectArgument = false;
--  Candidate.TookAddressOfOverload = false;
    std::copy(ParamTys, ParamTys + Args.size(), Candidate.BuiltinParamTypes);
    // Determine the implicit conversion sequences for each of the

contrib/llvm-project/compiler-rt/lib/builtins/README.txt
@@ -272,6 +272,11 @@ switch32
	switch8	switch8
	switchu8	switchu8

		+// This function generates a custom trampoline function with the specific
		+// realFunc and localsPtr values.
		+void __trampoline_setup(uint32_t* trampOnStack, int trampSizeAllocated,
		+ const void* realFunc, void* localsPtr);
		+
	// There is no C interface to the *_vfp_d8_d15_regs functions. There are	// There is no C interface to the *_vfp_d8_d15_regs functions. There are
	// called in the prolog and epilog of Thumb1 functions. When the C++ ABI use	// called in the prolog and epilog of Thumb1 functions. When the C++ ABI use
	// SJLJ for exceptions, each function with a catch clause or destructors needs	// SJLJ for exceptions, each function with a catch clause or destructors needs

contrib/llvm-project/compiler-rt/lib/builtins/aarch64/sme-abi-vg.c
@@ -10,15 +10,6 @@ struct FEATURES {

	extern struct FEATURES __aarch64_cpu_features;	extern struct FEATURES __aarch64_cpu_features;

	-struct SME_STATE {
	- long PSTATE;
	- long TPIDR2_EL0;
	-};
	-
	-extern struct SME_STATE __arm_sme_state(void) __arm_streaming_compatible;
	-
	-extern bool __aarch64_has_sme_and_tpidr2_el0;
	-
	#if __GNUC__ >= 9	#if __GNUC__ >= 9
	#pragma GCC diagnostic ignored "-Wprio-ctor-dtor"	#pragma GCC diagnostic ignored "-Wprio-ctor-dtor"
	#endif	#endif
@@ -28,22 +19,3 @@ __attribute__((constructor(90))) static void get_aarch64_cpu_features(void) {

	__init_cpu_features();	__init_cpu_features();
	}	}
	-
	-__attribute__((target("sve"))) long
	-__arm_get_current_vg(void) __arm_streaming_compatible {
	- struct SME_STATE State = __arm_sme_state();
	- unsigned long long features =
	- __atomic_load_n(&__aarch64_cpu_features.features, __ATOMIC_RELAXED);
	- bool HasSVE = features & (1ULL << FEAT_SVE);
	-
	- if (!HasSVE && !__aarch64_has_sme_and_tpidr2_el0)
	- return 0;
	-
	- if (HasSVE \|\| (State.PSTATE & 1)) {
	- long vl;
	- __asm__ __volatile__("cntd %0" : "=r"(vl));
	- return vl;
	- }
	-
	- return 0;
	-}

contrib/llvm-project/compiler-rt/lib/builtins/aarch64/sme-abi.S
@@ -12,11 +12,15 @@
	#if !defined(__APPLE__)	#if !defined(__APPLE__)
	#define TPIDR2_SYMBOL SYMBOL_NAME(__aarch64_has_sme_and_tpidr2_el0)	#define TPIDR2_SYMBOL SYMBOL_NAME(__aarch64_has_sme_and_tpidr2_el0)
	#define TPIDR2_SYMBOL_OFFSET :lo12:SYMBOL_NAME(__aarch64_has_sme_and_tpidr2_el0)	#define TPIDR2_SYMBOL_OFFSET :lo12:SYMBOL_NAME(__aarch64_has_sme_and_tpidr2_el0)
		+#define CPU_FEATS_SYMBOL SYMBOL_NAME(__aarch64_cpu_features)
		+#define CPU_FEATS_SYMBOL_OFFSET :lo12:SYMBOL_NAME(__aarch64_cpu_features)
	#else	#else
	// MachO requires @page/@pageoff directives because the global is defined	// MachO requires @page/@pageoff directives because the global is defined
	// in a different file. Otherwise this file may fail to build.	// in a different file. Otherwise this file may fail to build.
	#define TPIDR2_SYMBOL SYMBOL_NAME(__aarch64_has_sme_and_tpidr2_el0)@page	#define TPIDR2_SYMBOL SYMBOL_NAME(__aarch64_has_sme_and_tpidr2_el0)@page
	#define TPIDR2_SYMBOL_OFFSET SYMBOL_NAME(__aarch64_has_sme_and_tpidr2_el0)@pageoff	#define TPIDR2_SYMBOL_OFFSET SYMBOL_NAME(__aarch64_has_sme_and_tpidr2_el0)@pageoff
		+#define CPU_FEATS_SYMBOL SYMBOL_NAME(__aarch64_cpu_features)@page
		+#define CPU_FEATS_SYMBOL_OFFSET SYMBOL_NAME(__aarch64_cpu_features)@pageoff
	#endif	#endif

	.arch armv9-a+sme	.arch armv9-a+sme
@@ -180,6 +184,46 @@ DEFINE_COMPILERRT_OUTLINE_FUNCTION_UNMANGLED(__arm_za_disable)
	ret	ret
	END_COMPILERRT_OUTLINE_FUNCTION(__arm_za_disable)	END_COMPILERRT_OUTLINE_FUNCTION(__arm_za_disable)

		+DEFINE_COMPILERRT_OUTLINE_FUNCTION_UNMANGLED(__arm_get_current_vg)
		+ .variant_pcs __arm_get_current_vg
		+ BTI_C
		+
		+ stp x29, x30, [sp, #-16]!
		+ .cfi_def_cfa_offset 16
		+ mov x29, sp
		+ .cfi_def_cfa w29, 16
		+ .cfi_offset w30, -8
		+ .cfi_offset w29, -16
		+ adrp x17, CPU_FEATS_SYMBOL
		+ ldr w17, [x17, CPU_FEATS_SYMBOL_OFFSET]
		+ tbnz w17, #30, 0f
		+ adrp x16, TPIDR2_SYMBOL
		+ ldrb w16, [x16, TPIDR2_SYMBOL_OFFSET]
		+ cbz w16, 1f
		+0:
		+ mov x18, x1
		+ bl __arm_sme_state
		+ mov x1, x18
		+ and x17, x17, #0x40000000
		+ bfxil x17, x0, #0, #1
		+ cbz x17, 1f
		+ cntd x0
		+ .cfi_def_cfa wsp, 16
		+ ldp x29, x30, [sp], #16
		+ .cfi_def_cfa_offset 0
		+ .cfi_restore w30
		+ .cfi_restore w29
		+ ret
		+1:
		+ mov x0, xzr
		+ .cfi_def_cfa wsp, 16
		+ ldp x29, x30, [sp], #16
		+ .cfi_def_cfa_offset 0
		+ .cfi_restore w30
		+ .cfi_restore w29
		+ ret
		+END_COMPILERRT_OUTLINE_FUNCTION(__arm_get_current_vg)
		+
	NO_EXEC_STACK_DIRECTIVE	NO_EXEC_STACK_DIRECTIVE

	// GNU property note for BTI and PAC	// GNU property note for BTI and PAC

contrib/llvm-project/compiler-rt/lib/builtins/trampoline_setup.c
@@ -41,3 +41,45 @@ COMPILER_RT_ABI void __trampoline_setup(uint32_t *trampOnStack,
	__clear_cache(trampOnStack, &trampOnStack[10]);	__clear_cache(trampOnStack, &trampOnStack[10]);
	}	}
	#endif // __powerpc__ && !defined(__powerpc64__)	#endif // __powerpc__ && !defined(__powerpc64__)
		+
		+// The AArch64 compiler generates calls to __trampoline_setup() when creating
		+// trampoline functions on the stack for use with nested functions.
		+// This function creates a custom 36-byte trampoline function on the stack
		+// which loads x18 with a pointer to the outer function's locals
		+// and then jumps to the target nested function.
		+// Note: x18 is a reserved platform register on Windows and macOS.
		+
		+#if defined(__aarch64__) && defined(__ELF__)
		+COMPILER_RT_ABI void __trampoline_setup(uint32_t *trampOnStack,
		+ int trampSizeAllocated,
		+ const void realFunc, void localsPtr) {
		+ // This should never happen, but if compiler did not allocate
		+ // enough space on stack for the trampoline, abort.
		+ if (trampSizeAllocated < 36)
		+ compilerrt_abort();
		+
		+ // create trampoline
		+ // Load realFunc into x17. mov/movk 16 bits at a time.
		+ trampOnStack[0] =
		+ 0xd2800000u \| ((((uint64_t)realFunc >> 0) & 0xffffu) << 5) \| 0x11;
		+ trampOnStack[1] =
		+ 0xf2a00000u \| ((((uint64_t)realFunc >> 16) & 0xffffu) << 5) \| 0x11;
		+ trampOnStack[2] =
		+ 0xf2c00000u \| ((((uint64_t)realFunc >> 32) & 0xffffu) << 5) \| 0x11;
		+ trampOnStack[3] =
		+ 0xf2e00000u \| ((((uint64_t)realFunc >> 48) & 0xffffu) << 5) \| 0x11;
		+ // Load localsPtr into x18
		+ trampOnStack[4] =
		+ 0xd2800000u \| ((((uint64_t)localsPtr >> 0) & 0xffffu) << 5) \| 0x12;
		+ trampOnStack[5] =
		+ 0xf2a00000u \| ((((uint64_t)localsPtr >> 16) & 0xffffu) << 5) \| 0x12;
		+ trampOnStack[6] =
		+ 0xf2c00000u \| ((((uint64_t)localsPtr >> 32) & 0xffffu) << 5) \| 0x12;
		+ trampOnStack[7] =
		+ 0xf2e00000u \| ((((uint64_t)localsPtr >> 48) & 0xffffu) << 5) \| 0x12;
		+ trampOnStack[8] = 0xd61f0220; // br x17
		+
		+ // Clear instruction cache.
		+ __clear_cache(trampOnStack, &trampOnStack[9]);
		+}
		+#endif // defined(__aarch64__) && !defined(__APPLE__) && !defined(_WIN64)

contrib/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_ptrauth.h
@@ -9,31 +9,33 @@
	#ifndef SANITIZER_PTRAUTH_H	#ifndef SANITIZER_PTRAUTH_H
	#define SANITIZER_PTRAUTH_H	#define SANITIZER_PTRAUTH_H

	-#if __has_feature(~~ptrauth_calls~~)	+#if __has_feature(ptrauth_intrinsics)
	-#include <ptrauth.h>	+# include <ptrauth.h>
	#elif defined(__ARM_FEATURE_PAC_DEFAULT) && !defined(__APPLE__)	#elif defined(__ARM_FEATURE_PAC_DEFAULT) && !defined(__APPLE__)
	-inline unsigned long ptrauth_strip(void* __value, unsigned int __key) {	+// On the stack the link register is protected with Pointer
	- // On the stack the link register is protected with Pointer	+// Authentication Code when compiled with -mbranch-protection.
	- // Authentication Code when compiled with -mbranch-protection.	+// Let's stripping the PAC unconditionally because xpaclri is in
	- // Let's stripping the PAC unconditionally because xpaclri is in	+// the NOP space so will do nothing when it is not enabled or not available.
	- // the NOP space so will do nothing when it is not enabled or not available.	+# define ptrauth_strip(__value, __key) \
	- unsigned long ret;	+ ({ \
	- asm volatile(	+ __typeof(__value) ret; \
	- "mov x30, %1\n\t"	+ asm volatile( \
	- "hint #7\n\t" // xpaclri	+ "mov x30, %1\n\t" \
	- "mov %0, x30\n\t"	+ "hint #7\n\t" \
	- : "=r"(ret)	+ "mov %0, x30\n\t" \
	- : "r"(__value)	+ "mov x30, xzr\n\t" \
	- : "x30");	+ : "=r"(ret) \
	- return ret;	+ : "r"(__value) \
	-}	+ : "x30"); \
	-#define ptrauth_auth_data(__value, __old_key, __old_data) __value	+ ret; \
	-#define ptrauth_string_discriminator(__string) ((int)0)	+ })
		+# define ptrauth_auth_data(__value, __old_key, __old_data) __value
		+# define ptrauth_string_discriminator(__string) ((int)0)
	#else	#else
	// Copied from <ptrauth.h>	// Copied from <ptrauth.h>
	-#define ptrauth_strip(__value, __key) __value	+# define ptrauth_strip(__value, __key) __value
	-#define ptrauth_auth_data(__value, __old_key, __old_data) __value	+# define ptrauth_auth_data(__value, __old_key, __old_data) __value
	-#define ptrauth_string_discriminator(__string) ((int)0)	+# define ptrauth_string_discriminator(__string) ((int)0)
	#endif	#endif

	#define STRIP_PAC_PC(pc) ((uptr)ptrauth_strip(pc, 0))	#define STRIP_PAC_PC(pc) ((uptr)ptrauth_strip(pc, 0))

    std::type_info *TypeInfo;
  };
  VtablePrefix *getVtablePrefix(void *Vtable) {
--  Vtable = ptrauth_auth_data(Vtable, ptrauth_key_cxx_vtable_pointer, 0);
++  Vtable = ptrauth_strip(Vtable, ptrauth_key_cxx_vtable_pointer);
    VtablePrefix *Vptr = reinterpret_cast<VtablePrefix*>(Vtable);
    VtablePrefix *Prefix = Vptr - 1;
    if (!IsAccessibleMemoryRange((uptr)Prefix, sizeof(VtablePrefix)))

contrib/llvm-project/libcxx/include/__bit_reference
@@ -16,6 +16,7 @@
	#include <__bit/countr.h>	#include <__bit/countr.h>
	#include <__bit/invert_if.h>	#include <__bit/invert_if.h>
	#include <__bit/popcount.h>	#include <__bit/popcount.h>
		+#include <__compare/ordering.h>
	#include <__config>	#include <__config>
	#include <__fwd/bit_reference.h>	#include <__fwd/bit_reference.h>
	#include <__iterator/iterator_traits.h>	#include <__iterator/iterator_traits.h>
@@ -913,6 +914,7 @@ public:
	return __x.__seg_ == __y.__seg_ && __x.__ctz_ == __y.__ctz_;	return __x.__seg_ == __y.__seg_ && __x.__ctz_ == __y.__ctz_;
	}	}

		+#if _LIBCPP_STD_VER <= 17
	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool
	operator!=(const __bit_iterator& __x, const __bit_iterator& __y) {	operator!=(const __bit_iterator& __x, const __bit_iterator& __y) {
	return !(__x == __y);	return !(__x == __y);
@@ -937,6 +939,18 @@ public:
	operator>=(const __bit_iterator& __x, const __bit_iterator& __y) {	operator>=(const __bit_iterator& __x, const __bit_iterator& __y) {
	return !(__x < __y);	return !(__x < __y);
	}	}
		+#else // _LIBCPP_STD_VER <= 17
		+ _LIBCPP_HIDE_FROM_ABI constexpr friend strong_ordering
		+ operator<=>(const __bit_iterator& __x, const __bit_iterator& __y) {
		+ if (__x.__seg_ < __y.__seg_)
		+ return strong_ordering::less;
		+
		+ if (__x.__seg_ == __y.__seg_)
		+ return __x.__ctz_ <=> __y.__ctz_;
		+
		+ return strong_ordering::greater;
		+ }
		+#endif // _LIBCPP_STD_VER <= 17

	private:	private:
	_LIBCPP_HIDE_FROM_ABI	_LIBCPP_HIDE_FROM_ABI

  // _LIBCPP_VERSION represents the version of libc++, which matches the version of LLVM.
  // Given a LLVM release LLVM XX.YY.ZZ (e.g. LLVM 17.0.1 == 17.00.01), _LIBCPP_VERSION is
  // defined to XXYYZZ.
--#  define _LIBCPP_VERSION 190000
++#  define _LIBCPP_VERSION 190100
  #  define _LIBCPP_CONCAT_IMPL(_X, _Y) _X##_Y
  #  define _LIBCPP_CONCAT(_X, _Y) _LIBCPP_CONCAT_IMPL(_X, _Y)

contrib/llvm-project/libcxx/include/__iterator/bounded_iter.h
@@ -11,6 +11,8 @@
	#define _LIBCPP___ITERATOR_BOUNDED_ITER_H	#define _LIBCPP___ITERATOR_BOUNDED_ITER_H

	#include <__assert>	#include <__assert>
		+#include <__compare/ordering.h>
		+#include <__compare/three_way_comparable.h>
	#include <__config>	#include <__config>
	#include <__iterator/iterator_traits.h>	#include <__iterator/iterator_traits.h>
	#include <__memory/pointer_traits.h>	#include <__memory/pointer_traits.h>
@@ -201,10 +203,15 @@ public:
	operator==(__bounded_iter const& __x, __bounded_iter const& __y) _NOEXCEPT {	operator==(__bounded_iter const& __x, __bounded_iter const& __y) _NOEXCEPT {
	return __x.__current_ == __y.__current_;	return __x.__current_ == __y.__current_;
	}	}
		+
		+#if _LIBCPP_STD_VER <= 17
	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR friend bool	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR friend bool
	operator!=(__bounded_iter const& __x, __bounded_iter const& __y) _NOEXCEPT {	operator!=(__bounded_iter const& __x, __bounded_iter const& __y) _NOEXCEPT {
	return __x.__current_ != __y.__current_;	return __x.__current_ != __y.__current_;
	}	}
		+#endif
		+
		+ // TODO(mordante) disable these overloads in the LLVM 20 release.
	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR friend bool	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR friend bool
	operator<(__bounded_iter const& __x, __bounded_iter const& __y) _NOEXCEPT {	operator<(__bounded_iter const& __x, __bounded_iter const& __y) _NOEXCEPT {
	return __x.__current_ < __y.__current_;	return __x.__current_ < __y.__current_;
@@ -222,6 +229,23 @@ public:
	return __x.__current_ >= __y.__current_;	return __x.__current_ >= __y.__current_;
	}	}

		+#if _LIBCPP_STD_VER >= 20
		+ _LIBCPP_HIDE_FROM_ABI constexpr friend strong_ordering
		+ operator<=>(__bounded_iter const& __x, __bounded_iter const& __y) noexcept {
		+ if constexpr (three_way_comparable<_Iterator, strong_ordering>) {
		+ return __x.__current_ <=> __y.__current_;
		+ } else {
		+ if (__x.__current_ < __y.__current_)
		+ return strong_ordering::less;
		+
		+ if (__x.__current_ == __y.__current_)
		+ return strong_ordering::equal;
		+
		+ return strong_ordering::greater;
		+ }
		+ }
		+#endif // _LIBCPP_STD_VER >= 20
		+
	private:	private:
	template <class>	template <class>
	friend struct pointer_traits;	friend struct pointer_traits;

contrib/llvm-project/libcxx/include/__iterator/wrap_iter.h
@@ -10,6 +10,8 @@
	#ifndef _LIBCPP___ITERATOR_WRAP_ITER_H	#ifndef _LIBCPP___ITERATOR_WRAP_ITER_H
	#define _LIBCPP___ITERATOR_WRAP_ITER_H	#define _LIBCPP___ITERATOR_WRAP_ITER_H

		+#include <__compare/ordering.h>
		+#include <__compare/three_way_comparable.h>
	#include <__config>	#include <__config>
	#include <__iterator/iterator_traits.h>	#include <__iterator/iterator_traits.h>
	#include <__memory/addressof.h>	#include <__memory/addressof.h>
@@ -131,6 +133,7 @@ operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXC
	return __x.base() < __y.base();	return __x.base() < __y.base();
	}	}

		+#if _LIBCPP_STD_VER <= 17
	template <class _Iter1>	template <class _Iter1>
	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
	operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT {	operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT {
@@ -142,7 +145,9 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
	operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT {	operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT {
	return !(__x == __y);	return !(__x == __y);
	}	}
		+#endif

		+// TODO(mordante) disable these overloads in the LLVM 20 release.
	template <class _Iter1>	template <class _Iter1>
	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
	operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT {	operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT {
@@ -179,6 +184,24 @@ operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEX
	return !(__y < __x);	return !(__y < __x);
	}	}

		+#if _LIBCPP_STD_VER >= 20
		+template <class _Iter1, class _Iter2>
		+_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering
		+operator<=>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) noexcept {
		+ if constexpr (three_way_comparable_with<_Iter1, _Iter2, strong_ordering>) {
		+ return __x.base() <=> __y.base();
		+ } else {
		+ if (__x.base() < __y.base())
		+ return strong_ordering::less;
		+
		+ if (__x.base() == __y.base())
		+ return strong_ordering::equal;
		+
		+ return strong_ordering::greater;
		+ }
		+}
		+#endif // _LIBCPP_STD_VER >= 20
		+
	template <class _Iter1, class _Iter2>	template <class _Iter1, class _Iter2>
	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
	#ifndef _LIBCPP_CXX03_LANG	#ifndef _LIBCPP_CXX03_LANG

contrib/llvm-project/libcxx/include/__math/hypot.h
@@ -15,10 +15,21 @@
	#include <__type_traits/is_same.h>	#include <__type_traits/is_same.h>
	#include <__type_traits/promote.h>	#include <__type_traits/promote.h>

		+#if _LIBCPP_STD_VER >= 17
		+# include <__algorithm/max.h>
		+# include <__math/abs.h>
		+# include <__math/roots.h>
		+# include <__utility/pair.h>
		+# include <limits>
		+#endif
		+
	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	# pragma GCC system_header	# pragma GCC system_header
	#endif	#endif

		+_LIBCPP_PUSH_MACROS
		+#include <__undef_macros>
		+
	_LIBCPP_BEGIN_NAMESPACE_STD	_LIBCPP_BEGIN_NAMESPACE_STD

	namespace __math {	namespace __math {
@@ -41,8 +52,86 @@ inline _LIBCPP_HIDE_FROM_ABI typename __promote<_A1, _A2>::type hypot(_A1 __x, _
	return __math::hypot((__result_type)__x, (__result_type)__y);	return __math::hypot((__result_type)__x, (__result_type)__y);
	}	}

		+#if _LIBCPP_STD_VER >= 17
		+// Factors needed to determine if over-/underflow might happen for `std::hypot(x,y,z)`.
		+// returns [overflow_threshold, overflow_scale]
		+template <class _Real>
		+_LIBCPP_HIDE_FROM_ABI std::pair<_Real, _Real> __hypot_factors() {
		+ static_assert(std::numeric_limits<_Real>::is_iec559);
		+
		+ if constexpr (std::is_same_v<_Real, float>) {
		+ static_assert(-125 == std::numeric_limits<_Real>::min_exponent);
		+ static_assert(+128 == std::numeric_limits<_Real>::max_exponent);
		+ return {0x1.0p+62f, 0x1.0p-70f};
		+ } else if constexpr (std::is_same_v<_Real, double>) {
		+ static_assert(-1021 == std::numeric_limits<_Real>::min_exponent);
		+ static_assert(+1024 == std::numeric_limits<_Real>::max_exponent);
		+ return {0x1.0p+510, 0x1.0p-600};
		+ } else { // long double
		+ static_assert(std::is_same_v<_Real, long double>);
		+
		+ // preprocessor guard necessary, otherwise literals (e.g. `0x1.0p+8'190l`) throw warnings even when shielded by `if
		+ // constexpr`
		+# if __DBL_MAX_EXP__ == __LDBL_MAX_EXP__
		+ static_assert(sizeof(_Real) == sizeof(double));
		+ return static_cast<std::pair<_Real, _Real>>(__math::__hypot_factors<double>());
		+# else
		+ static_assert(sizeof(_Real) > sizeof(double));
		+ static_assert(-16381 == std::numeric_limits<_Real>::min_exponent);
		+ static_assert(+16384 == std::numeric_limits<_Real>::max_exponent);
		+ return {0x1.0p+8190l, 0x1.0p-9000l};
		+# endif
		+ }
		+}
		+
		+// Computes the three-dimensional hypotenuse: `std::hypot(x,y,z)`.
		+// The naive implementation might over-/underflow which is why this implementation is more involved:
		+// If the square of an argument might run into issues, we scale the arguments appropriately.
		+// See https://github.com/llvm/llvm-project/issues/92782 for a detailed discussion and summary.
		+template <class _Real>
		+_LIBCPP_HIDE_FROM_ABI _Real __hypot(_Real __x, _Real __y, _Real __z) {
		+ const _Real __max_abs = std::max(__math::fabs(__x), std::max(__math::fabs(__y), __math::fabs(__z)));
		+ const auto [__overflow_threshold, __overflow_scale] = __math::__hypot_factors<_Real>();
		+ _Real __scale;
		+ if (__max_abs > __overflow_threshold) { // xx + yy + z*z might overflow
		+ __scale = __overflow_scale;
		+ __x *= __scale;
		+ __y *= __scale;
		+ __z *= __scale;
		+ } else if (__max_abs < 1 / __overflow_threshold) { // xx + yy + z*z might underflow
		+ __scale = 1 / __overflow_scale;
		+ __x *= __scale;
		+ __y *= __scale;
		+ __z *= __scale;
		+ } else
		+ __scale = 1;
		+ return __math::sqrt(__x * __x + __y * __y + __z * __z) / __scale;
		+}
		+
		+inline _LIBCPP_HIDE_FROM_ABI float hypot(float __x, float __y, float __z) { return __math::__hypot(__x, __y, __z); }
		+
		+inline _LIBCPP_HIDE_FROM_ABI double hypot(double __x, double __y, double __z) { return __math::__hypot(__x, __y, __z); }
		+
		+inline _LIBCPP_HIDE_FROM_ABI long double hypot(long double __x, long double __y, long double __z) {
		+ return __math::__hypot(__x, __y, __z);
		+}
		+
		+template <class _A1,
		+ class _A2,
		+ class _A3,
		+ std::enable_if_t< is_arithmetic_v<_A1> && is_arithmetic_v<_A2> && is_arithmetic_v<_A3>, int> = 0 >
		+_LIBCPP_HIDE_FROM_ABI typename __promote<_A1, _A2, _A3>::type hypot(_A1 __x, _A2 __y, _A3 __z) _NOEXCEPT {
		+ using __result_type = typename __promote<_A1, _A2, _A3>::type;
		+ static_assert(!(
		+ std::is_same_v<_A1, __result_type> && std::is_same_v<_A2, __result_type> && std::is_same_v<_A3, __result_type>));
		+ return __math::__hypot(
		+ static_cast<__result_type>(__x), static_cast<__result_type>(__y), static_cast<__result_type>(__z));
		+}
		+#endif
		+
	} // namespace __math	} // namespace __math

	_LIBCPP_END_NAMESPACE_STD	_LIBCPP_END_NAMESPACE_STD
		+_LIBCPP_POP_MACROS

	#endif // _LIBCPP___MATH_HYPOT_H	#endif // _LIBCPP___MATH_HYPOT_H

contrib/llvm-project/libcxx/include/cmath
@@ -313,6 +313,7 @@ constexpr long double lerp(long double a, long double b, long double t) noexcept
	*/	*/

	#include <__config>	#include <__config>
		+#include <__math/hypot.h>
	#include <__type_traits/enable_if.h>	#include <__type_traits/enable_if.h>
	#include <__type_traits/is_arithmetic.h>	#include <__type_traits/is_arithmetic.h>
	#include <__type_traits/is_constant_evaluated.h>	#include <__type_traits/is_constant_evaluated.h>
@@ -553,30 +554,6 @@ using ::scalbnl _LIBCPP_USING_IF_EXISTS;
	using ::tgammal _LIBCPP_USING_IF_EXISTS;	using ::tgammal _LIBCPP_USING_IF_EXISTS;
	using ::truncl _LIBCPP_USING_IF_EXISTS;	using ::truncl _LIBCPP_USING_IF_EXISTS;

	-#if _LIBCPP_STD_VER >= 17
	-inline _LIBCPP_HIDE_FROM_ABI float hypot(float __x, float __y, float __z) {
	- return sqrt(__x * __x + __y * __y + __z * __z);
	-}
	-inline _LIBCPP_HIDE_FROM_ABI double hypot(double __x, double __y, double __z) {
	- return sqrt(__x * __x + __y * __y + __z * __z);
	-}
	-inline _LIBCPP_HIDE_FROM_ABI long double hypot(long double __x, long double __y, long double __z) {
	- return sqrt(__x * __x + __y * __y + __z * __z);
	-}
	-
	-template <class _A1, class _A2, class _A3>
	-inline _LIBCPP_HIDE_FROM_ABI
	-typename enable_if_t< is_arithmetic<_A1>::value && is_arithmetic<_A2>::value && is_arithmetic<_A3>::value,
	- __promote<_A1, _A2, _A3> >::type
	-hypot(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT {
	- typedef typename __promote<_A1, _A2, _A3>::type __result_type;
	- static_assert(
	- !(is_same<_A1, __result_type>::value && is_same<_A2, __result_type>::value && is_same<_A3, __result_type>::value),
	- "");
	- return std::hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z);
	-}
	-#endif
	-
	template <class _A1, __enable_if_t<is_floating_point<_A1>::value, int> = 0>	template <class _A1, __enable_if_t<is_floating_point<_A1>::value, int> = 0>
	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool __constexpr_isnan(_A1 __lcpp_x) _NOEXCEPT {	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool __constexpr_isnan(_A1 __lcpp_x) _NOEXCEPT {
	#if __has_builtin(__builtin_isnan)	#if __has_builtin(__builtin_isnan)

contrib/llvm-project/libcxx/include/deque
@@ -376,10 +376,13 @@ public:
	return __x.__ptr_ == __y.__ptr_;	return __x.__ptr_ == __y.__ptr_;
	}	}

		+#if _LIBCPP_STD_VER <= 17
	_LIBCPP_HIDE_FROM_ABI friend bool operator!=(const __deque_iterator& __x, const __deque_iterator& __y) {	_LIBCPP_HIDE_FROM_ABI friend bool operator!=(const __deque_iterator& __x, const __deque_iterator& __y) {
	return !(__x == __y);	return !(__x == __y);
	}	}
		+#endif

		+ // TODO(mordante) disable these overloads in the LLVM 20 release.
	_LIBCPP_HIDE_FROM_ABI friend bool operator<(const __deque_iterator& __x, const __deque_iterator& __y) {	_LIBCPP_HIDE_FROM_ABI friend bool operator<(const __deque_iterator& __x, const __deque_iterator& __y) {
	return __x.__m_iter_ < __y.__m_iter_ \|\| (__x.__m_iter_ == __y.__m_iter_ && __x.__ptr_ < __y.__ptr_);	return __x.__m_iter_ < __y.__m_iter_ \|\| (__x.__m_iter_ == __y.__m_iter_ && __x.__ptr_ < __y.__ptr_);
	}	}
@@ -396,6 +399,29 @@ public:
	return !(__x < __y);	return !(__x < __y);
	}	}

		+#if _LIBCPP_STD_VER >= 20
		+ _LIBCPP_HIDE_FROM_ABI friend strong_ordering operator<=>(const __deque_iterator& __x, const __deque_iterator& __y) {
		+ if (__x.__m_iter_ < __y.__m_iter_)
		+ return strong_ordering::less;
		+
		+ if (__x.__m_iter_ == __y.__m_iter_) {
		+ if constexpr (three_way_comparable<pointer, strong_ordering>) {
		+ return __x.__ptr_ <=> __y.__ptr_;
		+ } else {
		+ if (__x.__ptr_ < __y.__ptr_)
		+ return strong_ordering::less;
		+
		+ if (__x.__ptr_ == __y.__ptr_)
		+ return strong_ordering::equal;
		+
		+ return strong_ordering::greater;
		+ }
		+ }
		+
		+ return strong_ordering::greater;
		+ }
		+#endif // _LIBCPP_STD_VER >= 20
		+
	private:	private:
	_LIBCPP_HIDE_FROM_ABI explicit __deque_iterator(__map_iterator __m, pointer __p) _NOEXCEPT	_LIBCPP_HIDE_FROM_ABI explicit __deque_iterator(__map_iterator __m, pointer __p) _NOEXCEPT
	: __m_iter_(__m),	: __m_iter_(__m),
@@ -2530,8 +2556,7 @@ inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const deque<_Tp, _Allocator>& __x,
	template <class _Tp, class _Allocator>	template <class _Tp, class _Allocator>
	_LIBCPP_HIDE_FROM_ABI __synth_three_way_result<_Tp>	_LIBCPP_HIDE_FROM_ABI __synth_three_way_result<_Tp>
	operator<=>(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) {	operator<=>(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) {
	- return std::lexicographical_compare_three_way(	+ return std::lexicographical_compare_three_way(__x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way);
	- __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way);
	}	}

	#endif // _LIBCPP_STD_VER <= 17	#endif // _LIBCPP_STD_VER <= 17

contrib/llvm-project/libcxx/include/locale
@@ -232,6 +232,10 @@ template <class charT> class messages_byname;
	# include <__locale_dir/locale_base_api/bsd_locale_fallbacks.h>	# include <__locale_dir/locale_base_api/bsd_locale_fallbacks.h>
	# endif	# endif

		+# if defined(__APPLE__) \|\| defined(__FreeBSD__)
		+# include <xlocale.h>
		+# endif
		+
	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	# pragma GCC system_header	# pragma GCC system_header
	# endif	# endif

contrib/llvm-project/libcxx/include/string
@@ -3358,23 +3358,34 @@ basic_string<_CharT, _Traits, _Allocator>::__shrink_or_extend(size_type __target
	__p = __get_long_pointer();	__p = __get_long_pointer();
	} else {	} else {
	if (__target_capacity > __cap) {	if (__target_capacity > __cap) {
		+ // Extend
		+ // - called from reserve should propagate the exception thrown.
	auto __allocation = std::__allocate_at_least(__alloc(), __target_capacity + 1);	auto __allocation = std::__allocate_at_least(__alloc(), __target_capacity + 1);
	__new_data = __allocation.ptr;	__new_data = __allocation.ptr;
	__target_capacity = __allocation.count - 1;	__target_capacity = __allocation.count - 1;
	} else {	} else {
		+ // Shrink
		+ // - called from shrink_to_fit should not throw.
		+ // - called from reserve may throw but is not required to.
	#ifndef _LIBCPP_HAS_NO_EXCEPTIONS	#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
	try {	try {
	#endif // _LIBCPP_HAS_NO_EXCEPTIONS	#endif // _LIBCPP_HAS_NO_EXCEPTIONS
	auto __allocation = std::__allocate_at_least(__alloc(), __target_capacity + 1);	auto __allocation = std::__allocate_at_least(__alloc(), __target_capacity + 1);
		+
		+ // The Standard mandates shrink_to_fit() does not increase the capacity.
		+ // With equal capacity keep the existing buffer. This avoids extra work
		+ // due to swapping the elements.
		+ if (__allocation.count - 1 > __target_capacity) {
		+ __alloc_traits::deallocate(__alloc(), __allocation.ptr, __allocation.count);
		+ __annotate_new(__sz); // Undoes the __annotate_delete()
		+ return;
		+ }
	__new_data = __allocation.ptr;	__new_data = __allocation.ptr;
	__target_capacity = __allocation.count - 1;	__target_capacity = __allocation.count - 1;
	#ifndef _LIBCPP_HAS_NO_EXCEPTIONS	#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
	} catch (...) {	} catch (...) {
	return;	return;
	}	}
	-#else // _LIBCPP_HAS_NO_EXCEPTIONS
	- if (__new_data == nullptr)
	- return;
	#endif // _LIBCPP_HAS_NO_EXCEPTIONS	#endif // _LIBCPP_HAS_NO_EXCEPTIONS
	}	}
	__begin_lifetime(__new_data, __target_capacity + 1);	__begin_lifetime(__new_data, __target_capacity + 1);

contrib/llvm-project/llvm/include/llvm/Analysis/AliasAnalysis.h
@@ -244,12 +244,23 @@ class AAQueryInfo {
	public:	public:
	using LocPair = std::pair<AACacheLoc, AACacheLoc>;	using LocPair = std::pair<AACacheLoc, AACacheLoc>;
	struct CacheEntry {	struct CacheEntry {
		+ /// Cache entry is neither an assumption nor does it use a (non-definitive)
		+ /// assumption.
		+ static constexpr int Definitive = -2;
		+ /// Cache entry is not an assumption itself, but may be using an assumption
		+ /// from higher up the stack.
		+ static constexpr int AssumptionBased = -1;
		+
	AliasResult Result;	AliasResult Result;
	- /// Number of times a NoAlias assumption has been used.	+ /// Number of times a NoAlias assumption has been used, 0 for assumptions
	- /// ~~0 for assumptions~~ that have not been used, -1 ~~for~~ ~~definitive~~ ~~results.~~	+ /// that have not been used. Can also take one of the Definitive or
		+ /// AssumptionBased values documented above.
	int NumAssumptionUses;	int NumAssumptionUses;
		+
	/// Whether this is a definitive (non-assumption) result.	/// Whether this is a definitive (non-assumption) result.
	- bool isDefinitive() const { return NumAssumptionUses < 0; }	+ bool isDefinitive() const { return NumAssumptionUses == Definitive; }
		+ /// Whether this is an assumption that has not been proven yet.
		+ bool isAssumption() const { return NumAssumptionUses >= 0; }
	};	};

	// Alias analysis result aggregration using which this query is performed.	// Alias analysis result aggregration using which this query is performed.

contrib/llvm-project/llvm/include/llvm/Analysis/SimplifyQuery.h
@@ -130,6 +130,12 @@ struct SimplifyQuery {
	Copy.CC = &CC;	Copy.CC = &CC;
	return Copy;	return Copy;
	}	}
		+
		+ SimplifyQuery getWithoutCondContext() const {
		+ SimplifyQuery Copy(*this);
		+ Copy.CC = nullptr;
		+ return Copy;
		+ }
	};	};

	} // end namespace llvm	} // end namespace llvm

    /// targets, this value is only used when generating debug info (via
    /// TargetRegisterInfo::getFrameIndexReference); when generating code, the
    /// corresponding adjustments are performed directly.
--  int OffsetAdjustment = 0;
++  int64_t OffsetAdjustment = 0;
    /// The prolog/epilog code inserter may process objects that require greater
    /// alignment than the default alignment the target provides.
    /// setup/destroy pseudo instructions (as defined in the TargetFrameInfo
    /// class).  This information is important for frame pointer elimination.
    /// It is only valid during and after prolog/epilog code insertion.
--  unsigned MaxCallFrameSize = ~0u;
++  uint64_t MaxCallFrameSize = ~UINT64_C(0);
    /// The number of bytes of callee saved registers that the target wants to
    /// report for the current function in the CodeView S_FRAMEPROC record.
    uint64_t estimateStackSize(const MachineFunction &MF) const;
    /// Return the correction for frame offsets.
--  int getOffsetAdjustment() const { return OffsetAdjustment; }
++  int64_t getOffsetAdjustment() const { return OffsetAdjustment; }
    /// Set the correction for frame offsets.
--  void setOffsetAdjustment(int Adj) { OffsetAdjustment = Adj; }
++  void setOffsetAdjustment(int64_t Adj) { OffsetAdjustment = Adj; }
    /// Return the alignment in bytes that this function must be aligned to,
    /// which is greater than the default stack alignment provided by the target.
    /// CallFrameSetup/Destroy pseudo instructions are used by the target, and
    /// then only during or after prolog/epilog code insertion.
    ///
--  unsigned getMaxCallFrameSize() const {
++  uint64_t getMaxCallFrameSize() const {
      // TODO: Enable this assert when targets are fixed.
      //assert(isMaxCallFrameSizeComputed() && "MaxCallFrameSize not computed yet");
      if (!isMaxCallFrameSizeComputed())
      return MaxCallFrameSize;
    }
    bool isMaxCallFrameSizeComputed() const {
--    return MaxCallFrameSize != ~0u;
++    return MaxCallFrameSize != ~UINT64_C(0);
    }
--  void setMaxCallFrameSize(unsigned S) { MaxCallFrameSize = S; }
++  void setMaxCallFrameSize(uint64_t S) { MaxCallFrameSize = S; }
    /// Returns how many bytes of callee-saved registers the target pushed in the
    /// prologue. Only used for debug info.

    // Maps a callee saved register to a stack slot with a fixed offset.
    struct SpillSlot {
      unsigned Reg;
--    int Offset; // Offset relative to stack pointer on function entry.
++    int64_t Offset; // Offset relative to stack pointer on function entry.
    };
    struct DwarfFrameBase {
        // Used with FrameBaseKind::Register.
        unsigned Reg;
        // Used with FrameBaseKind::CFA.
--      int Offset;
++      int64_t Offset;
        struct WasmFrameBase WasmLoc;
      } Location;
    };

    virtual void handleAssemblerFlag(MCAssemblerFlag Flag) {}
    /// Generate the compact unwind encoding for the CFI instructions.
--  virtual uint32_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
++  virtual uint64_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
                                                   const MCContext *Ctxt) const {
      return 0;
    }

    union {
      struct {
        unsigned Register;
--      int Offset;
++      int64_t Offset;
      } RI;
      struct {
        unsigned Register;
--      int Offset;
++      int64_t Offset;
        unsigned AddressSpace;
      } RIA;
      struct {
    std::vector<char> Values;
    std::string Comment;
--  MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int O, SMLoc Loc,
++  MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int64_t O, SMLoc Loc,
                     StringRef V = "", StringRef Comment = "")
        : Label(L), Operation(Op), Loc(Loc), Values(V.begin(), V.end()),
          Comment(Comment) {
      assert(Op == OpRegister);
      U.RR = {R1, R2};
    }
--  MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int O, unsigned AS,
++  MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int64_t O, unsigned AS,
                     SMLoc Loc)
        : Label(L), Operation(Op), Loc(Loc) {
      assert(Op == OpLLVMDefAspaceCfa);
  public:
    /// .cfi_def_cfa defines a rule for computing CFA as: take address from
    /// Register and add Offset to it.
--  static MCCFIInstruction cfiDefCfa(MCSymbol *L, unsigned Register, int Offset,
++  static MCCFIInstruction cfiDefCfa(MCSymbol *L, unsigned Register,
--                                    SMLoc Loc = {}) {
++                                    int64_t Offset, SMLoc Loc = {}) {
      return MCCFIInstruction(OpDefCfa, L, Register, Offset, Loc);
    }
    /// on Register will be used instead of the old one. Offset remains the same.
    static MCCFIInstruction createDefCfaRegister(MCSymbol *L, unsigned Register,
                                                 SMLoc Loc = {}) {
--    return MCCFIInstruction(OpDefCfaRegister, L, Register, 0, Loc);
++    return MCCFIInstruction(OpDefCfaRegister, L, Register, INT64_C(0), Loc);
    }
    /// .cfi_def_cfa_offset modifies a rule for computing CFA. Register
    /// remains the same, but offset is new. Note that it is the absolute offset
    /// that will be added to a defined register to the compute CFA address.
--  static MCCFIInstruction cfiDefCfaOffset(MCSymbol *L, int Offset,
++  static MCCFIInstruction cfiDefCfaOffset(MCSymbol *L, int64_t Offset,
                                            SMLoc Loc = {}) {
      return MCCFIInstruction(OpDefCfaOffset, L, 0, Offset, Loc);
    }
    /// .cfi_adjust_cfa_offset Same as .cfi_def_cfa_offset, but
    /// Offset is a relative value that is added/subtracted from the previous
    /// offset.
--  static MCCFIInstruction createAdjustCfaOffset(MCSymbol *L, int Adjustment,
++  static MCCFIInstruction createAdjustCfaOffset(MCSymbol *L, int64_t Adjustment,
                                                  SMLoc Loc = {}) {
      return MCCFIInstruction(OpAdjustCfaOffset, L, 0, Adjustment, Loc);
    }
    /// be the result of evaluating the DWARF operation expression
    /// `DW_OP_constu AS; DW_OP_aspace_bregx R, B` as a location description.
    static MCCFIInstruction createLLVMDefAspaceCfa(MCSymbol *L, unsigned Register,
--                                                 int Offset,
++                                                 int64_t Offset,
                                                   unsigned AddressSpace,
                                                   SMLoc Loc) {
      return MCCFIInstruction(OpLLVMDefAspaceCfa, L, Register, Offset,
    /// .cfi_offset Previous value of Register is saved at offset Offset
    /// from CFA.
    static MCCFIInstruction createOffset(MCSymbol *L, unsigned Register,
--                                       int Offset, SMLoc Loc = {}) {
++                                       int64_t Offset, SMLoc Loc = {}) {
      return MCCFIInstruction(OpOffset, L, Register, Offset, Loc);
    }
    /// Offset from the current CFA register. This is transformed to .cfi_offset
    /// using the known displacement of the CFA register from the CFA.
    static MCCFIInstruction createRelOffset(MCSymbol *L, unsigned Register,
--                                          int Offset, SMLoc Loc = {}) {
++                                          int64_t Offset, SMLoc Loc = {}) {
      return MCCFIInstruction(OpRelOffset, L, Register, Offset, Loc);
    }
    /// .cfi_window_save SPARC register window is saved.
    static MCCFIInstruction createWindowSave(MCSymbol *L, SMLoc Loc = {}) {
--    return MCCFIInstruction(OpWindowSave, L, 0, 0, Loc);
++    return MCCFIInstruction(OpWindowSave, L, 0, INT64_C(0), Loc);
    }
    /// .cfi_negate_ra_state AArch64 negate RA state.
    static MCCFIInstruction createNegateRAState(MCSymbol *L, SMLoc Loc = {}) {
--    return MCCFIInstruction(OpNegateRAState, L, 0, 0, Loc);
++    return MCCFIInstruction(OpNegateRAState, L, 0, INT64_C(0), Loc);
    }
    /// .cfi_restore says that the rule for Register is now the same as it
    /// by .cfi_startproc were executed.
    static MCCFIInstruction createRestore(MCSymbol *L, unsigned Register,
                                          SMLoc Loc = {}) {
--    return MCCFIInstruction(OpRestore, L, Register, 0, Loc);
++    return MCCFIInstruction(OpRestore, L, Register, INT64_C(0), Loc);
    }
    /// .cfi_undefined From now on the previous value of Register can't be
    /// restored anymore.
    static MCCFIInstruction createUndefined(MCSymbol *L, unsigned Register,
                                            SMLoc Loc = {}) {
--    return MCCFIInstruction(OpUndefined, L, Register, 0, Loc);
++    return MCCFIInstruction(OpUndefined, L, Register, INT64_C(0), Loc);
    }
    /// .cfi_same_value Current value of Register is the same as in the
    /// previous frame. I.e., no restoration is needed.
    static MCCFIInstruction createSameValue(MCSymbol *L, unsigned Register,
                                            SMLoc Loc = {}) {
--    return MCCFIInstruction(OpSameValue, L, Register, 0, Loc);
++    return MCCFIInstruction(OpSameValue, L, Register, INT64_C(0), Loc);
    }
    /// .cfi_remember_state Save all current rules for all registers.
    static MCCFIInstruction createRememberState(MCSymbol *L, SMLoc Loc = {}) {
--    return MCCFIInstruction(OpRememberState, L, 0, 0, Loc);
++    return MCCFIInstruction(OpRememberState, L, 0, INT64_C(0), Loc);
    }
    /// .cfi_restore_state Restore the previously saved state.
    static MCCFIInstruction createRestoreState(MCSymbol *L, SMLoc Loc = {}) {
--    return MCCFIInstruction(OpRestoreState, L, 0, 0, Loc);
++    return MCCFIInstruction(OpRestoreState, L, 0, INT64_C(0), Loc);
    }
    /// .cfi_escape Allows the user to add arbitrary bytes to the unwind
    }
    /// A special wrapper for .cfi_escape that indicates GNU_ARGS_SIZE
--  static MCCFIInstruction createGnuArgsSize(MCSymbol *L, int Size,
++  static MCCFIInstruction createGnuArgsSize(MCSymbol *L, int64_t Size,
                                              SMLoc Loc = {}) {
      return MCCFIInstruction(OpGnuArgsSize, L, 0, Size, Loc);
    }
      return U.RIA.AddressSpace;
    }
--  int getOffset() const {
++  int64_t getOffset() const {
      if (Operation == OpLLVMDefAspaceCfa)
        return U.RIA.Offset;
      assert(Operation == OpDefCfa || Operation == OpOffset ||
    unsigned CurrentCfaRegister = 0;
    unsigned PersonalityEncoding = 0;
    unsigned LsdaEncoding = 0;
--  uint32_t CompactUnwindEncoding = 0;
++  uint64_t CompactUnwindEncoding = 0;
    bool IsSignalFrame = false;
    bool IsSimple = false;
    unsigned RAReg = static_cast<unsigned>(INT_MAX);

  #undef AIX_PPC8_VALUE
  #undef AIX_PPC9_VALUE
  #undef AIX_PPC10_VALUE
++#undef AIX_PPC11_VALUE
  #else
  #ifndef PPC_LNX_FEATURE
  #define PPC_LNX_FEATURE(NAME, DESC, ENUMNAME, ENUMVAL, HWCAPN)
  #define AIX_PPC8_VALUE 0x00010000
  #define AIX_PPC9_VALUE 0x00020000
  #define AIX_PPC10_VALUE 0x00040000
++#define AIX_PPC11_VALUE 0x00080000
  // __builtin_cpu_is() and __builtin_cpu_supports() are supported only on Power7 and up on AIX.
  // PPC_CPU(Name, Linux_SUPPORT_METHOD, LinuxID, AIX_SUPPORT_METHOD, AIXID)
  PPC_CPU("power8",SYS_CALL,45,USE_SYS_CONF,AIX_PPC8_VALUE)
  PPC_CPU("power9",SYS_CALL,46,USE_SYS_CONF,AIX_PPC9_VALUE)
  PPC_CPU("power10",SYS_CALL,47,USE_SYS_CONF,AIX_PPC10_VALUE)
++PPC_CPU("power11",SYS_CALL,48,USE_SYS_CONF,AIX_PPC11_VALUE)
  #undef PPC_CPU
  // PPC features on Linux:

contrib/llvm-project/llvm/lib/Analysis/BasicAliasAnalysis.cpp
@@ -1692,9 +1692,12 @@ AliasResult BasicAAResult::aliasCheck(const Value *V1, LocationSize V1Size,
	if (!Pair.second) {	if (!Pair.second) {
	auto &Entry = Pair.first->second;	auto &Entry = Pair.first->second;
	if (!Entry.isDefinitive()) {	if (!Entry.isDefinitive()) {
	- // Remember that we used an assumption.	+ // Remember that we used an assumption. This may either be a direct use
	- ++Entry.NumAssumptionUses;	+ // of an assumption, or a use of an entry that may itself be based on an
		+ // assumption.
	++AAQI.NumAssumptionUses;	++AAQI.NumAssumptionUses;
		+ if (Entry.isAssumption())
		+ ++Entry.NumAssumptionUses;
	}	}
	// Cache contains sorted {V1,V2} pairs but we should return original order.	// Cache contains sorted {V1,V2} pairs but we should return original order.
	auto Result = Entry.Result;	auto Result = Entry.Result;
@@ -1722,7 +1725,6 @@ AliasResult BasicAAResult::aliasCheck(const Value *V1, LocationSize V1Size,
	Entry.Result = Result;	Entry.Result = Result;
	// Cache contains sorted {V1,V2} pairs.	// Cache contains sorted {V1,V2} pairs.
	Entry.Result.swap(Swapped);	Entry.Result.swap(Swapped);
	- Entry.NumAssumptionUses = -1;

	// If the assumption has been disproven, remove any results that may have	// If the assumption has been disproven, remove any results that may have
	// been based on this assumption. Do this after the Entry updates above to	// been based on this assumption. Do this after the Entry updates above to
@@ -1734,8 +1736,26 @@ AliasResult BasicAAResult::aliasCheck(const Value *V1, LocationSize V1Size,
	// The result may still be based on assumptions higher up in the chain.	// The result may still be based on assumptions higher up in the chain.
	// Remember it, so it can be purged from the cache later.	// Remember it, so it can be purged from the cache later.
	if (OrigNumAssumptionUses != AAQI.NumAssumptionUses &&	if (OrigNumAssumptionUses != AAQI.NumAssumptionUses &&
	- Result != AliasResult::MayAlias)	+ Result != AliasResult::MayAlias) {
	AAQI.AssumptionBasedResults.push_back(Locs);	AAQI.AssumptionBasedResults.push_back(Locs);
		+ Entry.NumAssumptionUses = AAQueryInfo::CacheEntry::AssumptionBased;
		+ } else {
		+ Entry.NumAssumptionUses = AAQueryInfo::CacheEntry::Definitive;
		+ }
		+
		+ // Depth is incremented before this function is called, so Depth==1 indicates
		+ // a root query.
		+ if (AAQI.Depth == 1) {
		+ // Any remaining assumption based results must be based on proven
		+ // assumptions, so convert them to definitive results.
		+ for (const auto &Loc : AAQI.AssumptionBasedResults) {
		+ auto It = AAQI.AliasCache.find(Loc);
		+ if (It != AAQI.AliasCache.end())
		+ It->second.NumAssumptionUses = AAQueryInfo::CacheEntry::Definitive;
		+ }
		+ AAQI.AssumptionBasedResults.clear();
		+ AAQI.NumAssumptionUses = 0;
		+ }
	return Result;	return Result;
	}	}

          // inferred hold at original context instruction.  TODO: It may be
          // correct to use the original context.  IF warranted, explore and
          // add sufficient tests to cover.
--        SimplifyQuery RecQ = Q;
++        SimplifyQuery RecQ = Q.getWithoutCondContext();
          RecQ.CxtI = P;
          computeKnownBits(R, DemandedElts, Known2, Depth + 1, RecQ);
          switch (Opcode) {
          // phi. This is important because that is where the value is actually
          // "evaluated" even though it is used later somewhere else. (see also
          // D69571).
--        SimplifyQuery RecQ = Q;
++        SimplifyQuery RecQ = Q.getWithoutCondContext();
          unsigned OpNum = P->getOperand(0) == R ? 0 : 1;
          Instruction *RInst = P->getIncomingBlock(OpNum)->getTerminator();
          // phi. This is important because that is where the value is actually
          // "evaluated" even though it is used later somewhere else. (see also
          // D69571).
--        SimplifyQuery RecQ = Q;
++        SimplifyQuery RecQ = Q.getWithoutCondContext();
          RecQ.CxtI = P->getIncomingBlock(u)->getTerminator();
          Known2 = KnownBits(BitWidth);
      // it is an induction variable where in each step its value is a power of
      // two.
      auto *PN = cast<PHINode>(I);
--    SimplifyQuery RecQ = Q;
++    SimplifyQuery RecQ = Q.getWithoutCondContext();
      // Check if it is an induction variable and always power of two.
      if (isPowerOfTwoRecurrence(PN, OrZero, Depth, RecQ))
        return true;
      // Check if all incoming values are non-zero using recursion.
--    SimplifyQuery RecQ = Q;
++    SimplifyQuery RecQ = Q.getWithoutCondContext();
      unsigned NewDepth = std::max(Depth, MaxAnalysisRecursionDepth - 1);
      return llvm::all_of(PN->operands(), [&](const Use &U) {
        if (U.get() == PN)
      if (UsedFullRecursion)
        return false;
--    SimplifyQuery RecQ = Q;
++    SimplifyQuery RecQ = Q.getWithoutCondContext();
      RecQ.CxtI = IncomBB->getTerminator();
      if (!isKnownNonEqual(IV1, IV2, DemandedElts, Depth + 1, RecQ))
        return false;
        // Take the minimum of all incoming values.  This can't infinitely loop
        // because of our depth threshold.
--      SimplifyQuery RecQ = Q;
++      SimplifyQuery RecQ = Q.getWithoutCondContext();
        Tmp = TyBits;
        for (unsigned i = 0, e = NumIncomingValues; i != e; ++i) {
          if (Tmp == 1) return Tmp;
          // Recurse, but cap the recursion to two levels, because we don't want
          // to waste time spinning around in loops. We need at least depth 2 to
          // detect known sign bits.
--        computeKnownFPClass(
++        computeKnownFPClass(IncValue, DemandedElts, InterestedClasses, KnownSrc,
--            IncValue, DemandedElts, InterestedClasses, KnownSrc,
++                            PhiRecursionLimit,
--            PhiRecursionLimit,
++                            Q.getWithoutCondContext().getWithInstruction(
--            Q.getWithInstruction(P->getIncomingBlock(U)->getTerminator()));
++                                P->getIncomingBlock(U)->getTerminator()));
          if (First) {
            Known = KnownSrc;

    struct MBBCFAInfo {
      MachineBasicBlock *MBB;
      /// Value of cfa offset valid at basic block entry.
--    int IncomingCFAOffset = -1;
++    int64_t IncomingCFAOffset = -1;
      /// Value of cfa offset valid at basic block exit.
--    int OutgoingCFAOffset = -1;
++    int64_t OutgoingCFAOffset = -1;
      /// Value of cfa register valid at basic block entry.
      unsigned IncomingCFARegister = 0;
      /// Value of cfa register valid at basic block exit.
    /// Return the cfa offset value that should be set at the beginning of a MBB
    /// if needed. The negated value is needed when creating CFI instructions that
    /// set absolute offset.
--  int getCorrectCFAOffset(MachineBasicBlock *MBB) {
++  int64_t getCorrectCFAOffset(MachineBasicBlock *MBB) {
      return MBBVector[MBB->getNumber()].IncomingCFAOffset;
    }
  void CFIInstrInserter::calculateOutgoingCFAInfo(MBBCFAInfo &MBBInfo) {
    // Outgoing cfa offset set by the block.
--  int SetOffset = MBBInfo.IncomingCFAOffset;
++  int64_t SetOffset = MBBInfo.IncomingCFAOffset;
    // Outgoing cfa register set by the block.
    unsigned SetRegister = MBBInfo.IncomingCFARegister;
    MachineFunction *MF = MBBInfo.MBB->getParent();
    for (MachineInstr &MI : *MBBInfo.MBB) {
      if (MI.isCFIInstruction()) {
        std::optional<unsigned> CSRReg;
--      std::optional<int> CSROffset;
++      std::optional<int64_t> CSROffset;
        unsigned CFIIndex = MI.getOperand(0).getCFIIndex();
        const MCCFIInstruction &CFI = Instrs[CFIIndex];
        switch (CFI.getOperation()) {

      for (MachineInstr &MI : MBB) {
        unsigned Opcode = MI.getOpcode();
        if (Opcode == FrameSetupOpcode || Opcode == FrameDestroyOpcode) {
--        unsigned Size = TII.getFrameSize(MI);
++        uint64_t Size = TII.getFrameSize(MI);
          MaxCallFrameSize = std::max(MaxCallFrameSize, Size);
          if (FrameSDOps != nullptr)
            FrameSDOps->push_back(&MI);

      return;
    // (Re-)Compute the MaxCallFrameSize.
--  [[maybe_unused]] uint32_t MaxCFSIn =
++  [[maybe_unused]] uint64_t MaxCFSIn =
--      MFI.isMaxCallFrameSizeComputed() ? MFI.getMaxCallFrameSize() : UINT32_MAX;
++      MFI.isMaxCallFrameSizeComputed() ? MFI.getMaxCallFrameSize() : UINT64_MAX;
    std::vector<MachineBasicBlock::iterator> FrameSDOps;
    MFI.computeMaxCallFrameSize(MF, &FrameSDOps);
    assert(MFI.getMaxCallFrameSize() <= MaxCFSIn &&

  namespace {
  class FrameEmitterImpl {
--  int CFAOffset = 0;
++  int64_t CFAOffset = 0;
--  int InitialCFAOffset = 0;
++  int64_t InitialCFAOffset = 0;
    bool IsEH;
    MCObjectStreamer &Streamer;
      if (!IsEH)
        Reg = MRI->getDwarfRegNumFromDwarfEHRegNum(Reg);
--    int Offset = Instr.getOffset();
++    int64_t Offset = Instr.getOffset();
      if (IsRelative)
        Offset -= CFAOffset;
      Offset = Offset / dataAlignmentFactor;

contrib/llvm-project/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
@@ -1080,6 +1080,10 @@ AArch64TargetLowering::AArch64TargetLowering(const TargetMachine &TM,
	// Try to create BICs for vector ANDs.	// Try to create BICs for vector ANDs.
	setTargetDAGCombine(ISD::AND);	setTargetDAGCombine(ISD::AND);

		+ // llvm.init.trampoline and llvm.adjust.trampoline
		+ setOperationAction(ISD::INIT_TRAMPOLINE, MVT::Other, Custom);
		+ setOperationAction(ISD::ADJUST_TRAMPOLINE, MVT::Other, Custom);
		+
	// Vector add and sub nodes may conceal a high-half opportunity.	// Vector add and sub nodes may conceal a high-half opportunity.
	// Also, try to fold ADD into CSINC/CSINV..	// Also, try to fold ADD into CSINC/CSINV..
	setTargetDAGCombine({ISD::ADD, ISD::ABS, ISD::SUB, ISD::XOR, ISD::SINT_TO_FP,	setTargetDAGCombine({ISD::ADD, ISD::ABS, ISD::SUB, ISD::XOR, ISD::SINT_TO_FP,
@@ -6688,6 +6692,56 @@ static SDValue LowerFLDEXP(SDValue Op, SelectionDAG &DAG) {
	return Final;	return Final;
	}	}

		+SDValue AArch64TargetLowering::LowerADJUST_TRAMPOLINE(SDValue Op,
		+ SelectionDAG &DAG) const {
		+ // Note: x18 cannot be used for the Nest parameter on Windows and macOS.
		+ if (Subtarget->isTargetDarwin() \|\| Subtarget->isTargetWindows())
		+ report_fatal_error(
		+ "ADJUST_TRAMPOLINE operation is only supported on Linux.");
		+
		+ return Op.getOperand(0);
		+}
		+
		+SDValue AArch64TargetLowering::LowerINIT_TRAMPOLINE(SDValue Op,
		+ SelectionDAG &DAG) const {
		+
		+ // Note: x18 cannot be used for the Nest parameter on Windows and macOS.
		+ if (Subtarget->isTargetDarwin() \|\| Subtarget->isTargetWindows())
		+ report_fatal_error("INIT_TRAMPOLINE operation is only supported on Linux.");
		+
		+ SDValue Chain = Op.getOperand(0);
		+ SDValue Trmp = Op.getOperand(1); // trampoline
		+ SDValue FPtr = Op.getOperand(2); // nested function
		+ SDValue Nest = Op.getOperand(3); // 'nest' parameter value
		+ SDLoc dl(Op);
		+
		+ EVT PtrVT = getPointerTy(DAG.getDataLayout());
		+ Type IntPtrTy = DAG.getDataLayout().getIntPtrType(DAG.getContext());
		+
		+ TargetLowering::ArgListTy Args;
		+ TargetLowering::ArgListEntry Entry;
		+
		+ Entry.Ty = IntPtrTy;
		+ Entry.Node = Trmp;
		+ Args.push_back(Entry);
		+ Entry.Node = DAG.getConstant(20, dl, MVT::i64);
		+ Args.push_back(Entry);
		+
		+ Entry.Node = FPtr;
		+ Args.push_back(Entry);
		+ Entry.Node = Nest;
		+ Args.push_back(Entry);
		+
		+ // Lower to a call to __trampoline_setup(Trmp, TrampSize, FPtr, ctx_reg)
		+ TargetLowering::CallLoweringInfo CLI(DAG);
		+ CLI.setDebugLoc(dl).setChain(Chain).setLibCallee(
		+ CallingConv::C, Type::getVoidTy(*DAG.getContext()),
		+ DAG.getExternalSymbol("__trampoline_setup", PtrVT), std::move(Args));
		+
		+ std::pair<SDValue, SDValue> CallResult = LowerCallTo(CLI);
		+ return CallResult.second;
		+}
		+
	SDValue AArch64TargetLowering::LowerOperation(SDValue Op,	SDValue AArch64TargetLowering::LowerOperation(SDValue Op,
	SelectionDAG &DAG) const {	SelectionDAG &DAG) const {
	LLVM_DEBUG(dbgs() << "Custom lowering: ");	LLVM_DEBUG(dbgs() << "Custom lowering: ");
@@ -6705,6 +6759,10 @@ SDValue AArch64TargetLowering::LowerOperation(SDValue Op,
	return LowerGlobalTLSAddress(Op, DAG);	return LowerGlobalTLSAddress(Op, DAG);
	case ISD::PtrAuthGlobalAddress:	case ISD::PtrAuthGlobalAddress:
	return LowerPtrAuthGlobalAddress(Op, DAG);	return LowerPtrAuthGlobalAddress(Op, DAG);
		+ case ISD::ADJUST_TRAMPOLINE:
		+ return LowerADJUST_TRAMPOLINE(Op, DAG);
		+ case ISD::INIT_TRAMPOLINE:
		+ return LowerINIT_TRAMPOLINE(Op, DAG);
	case ISD::SETCC:	case ISD::SETCC:
	case ISD::STRICT_FSETCC:	case ISD::STRICT_FSETCC:
	case ISD::STRICT_FSETCCS:	case ISD::STRICT_FSETCCS:

    SDValue LowerSELECT_CC(ISD::CondCode CC, SDValue LHS, SDValue RHS,
                           SDValue TVal, SDValue FVal, const SDLoc &dl,
                           SelectionDAG &DAG) const;
++  SDValue LowerINIT_TRAMPOLINE(SDValue Op, SelectionDAG &DAG) const;
++  SDValue LowerADJUST_TRAMPOLINE(SDValue Op, SelectionDAG &DAG) const;
    SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
    SDValue LowerBR_JT(SDValue Op, SelectionDAG &DAG) const;
    SDValue LowerBRIND(SDValue Op, SelectionDAG &DAG) const;

      NumBytesToCreateFrame += 8;
      // PAuth is enabled - set extra tail call cost, if any.
--    auto LRCheckMethod = Subtarget.getAuthenticatedLRCheckMethod();
++    auto LRCheckMethod = Subtarget.getAuthenticatedLRCheckMethod(
++        *RepeatedSequenceLocs[0].getMF());
      NumBytesToCheckLRInTCEpilogue =
          AArch64PAuth::getCheckerSizeInBytes(LRCheckMethod);
      // Checking the authenticated LR value may significantly impact
    // behaviour of one of them
    const auto &CFn = Candidates.front().getMF()->getFunction();
++  if (CFn.hasFnAttribute("ptrauth-returns"))
++    F.addFnAttr(CFn.getFnAttribute("ptrauth-returns"));
++  if (CFn.hasFnAttribute("ptrauth-auth-traps"))
++    F.addFnAttr(CFn.getFnAttribute("ptrauth-auth-traps"));
    // Since all candidates belong to the same module, just copy the
    // function-level attributes of an arbitrary function.
    if (CFn.hasFnAttribute("sign-return-address"))

  }
  static std::pair<bool, bool> GetSignReturnAddress(const Function &F) {
++  if (F.hasFnAttribute("ptrauth-returns"))
++    return {true, false}; // non-leaf
    // The function should be signed in the following situations:
    // - sign-return-address=all
    // - sign-return-address=non-leaf and the functions spills the LR
  }
  static bool ShouldSignWithBKey(const Function &F, const AArch64Subtarget &STI) {
++  if (F.hasFnAttribute("ptrauth-returns"))
++    return true;
    if (!F.hasFnAttribute("sign-return-address-key")) {
      if (STI.getTargetTriple().isOSWindows())
        return true;

    AArch64PACKey::ID KeyId =
        MFnI->shouldSignWithBKey() ? AArch64PACKey::IB : AArch64PACKey::IA;
--  AuthCheckMethod Method = Subtarget->getAuthenticatedLRCheckMethod();
++  AuthCheckMethod Method =
++      Subtarget->getAuthenticatedLRCheckMethod(*TI->getMF());
    if (Method == AuthCheckMethod::None)
      return false;

contrib/llvm-project/llvm/lib/Target/AArch64/AArch64Subtarget.cpp
@@ -565,8 +565,13 @@ bool AArch64Subtarget::useAA() const { return UseAA; }
	// exception on its own. Later, if the callee spills the signed LR value and	// exception on its own. Later, if the callee spills the signed LR value and
	// neither FEAT_PAuth2 nor FEAT_EPAC are implemented, the valid PAC replaces	// neither FEAT_PAuth2 nor FEAT_EPAC are implemented, the valid PAC replaces
	// the higher bits of LR thus hiding the authentication failure.	// the higher bits of LR thus hiding the authentication failure.
	-AArch64PAuth::AuthCheckMethod	+AArch64PAuth::AuthCheckMethod AArch64Subtarget::getAuthenticatedLRCheckMethod(
	-AArch64Subtarget::getAuthenticatedLRCheckMethod() const {	+ const MachineFunction &MF) const {
		+ // TODO: Check subtarget for the scheme. Present variant is a default for
		+ // pauthtest ABI.
		+ if (MF.getFunction().hasFnAttribute("ptrauth-returns") &&
		+ MF.getFunction().hasFnAttribute("ptrauth-auth-traps"))
		+ return AArch64PAuth::AuthCheckMethod::HighBitsNoTBI;
	if (AuthenticatedLRCheckMethod.getNumOccurrences())	if (AuthenticatedLRCheckMethod.getNumOccurrences())
	return AuthenticatedLRCheckMethod;	return AuthenticatedLRCheckMethod;

    }
    /// Choose a method of checking LR before performing a tail call.
--  AArch64PAuth::AuthCheckMethod getAuthenticatedLRCheckMethod() const;
++  AArch64PAuth::AuthCheckMethod
++  getAuthenticatedLRCheckMethod(const MachineFunction &MF) const;
    /// Compute the integer discriminator for a given BlockAddress constant, if
    /// blockaddress signing is enabled, or std::nullopt otherwise.

    }
    /// Generate the compact unwind encoding from the CFI directives.
--  uint32_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
++  uint64_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
                                           const MCContext *Ctxt) const override {
      ArrayRef<MCCFIInstruction> Instrs = FI->Instructions;
      if (Instrs.empty())
        return CU::UNWIND_ARM64_MODE_DWARF;
      bool HasFP = false;
--    unsigned StackSize = 0;
++    uint64_t StackSize = 0;
--    uint32_t CompactUnwindEncoding = 0;
++    uint64_t CompactUnwindEncoding = 0;
--    int CurOffset = 0;
++    int64_t CurOffset = 0;
      for (size_t i = 0, e = Instrs.size(); i != e; ++i) {
        const MCCFIInstruction &Inst = Instrs[i];

          if (STI.splitFramePushPop(MF)) {
            unsigned DwarfReg = MRI->getDwarfRegNum(
                Reg == ARM::R12 ? ARM::RA_AUTH_CODE : Reg, true);
--          unsigned Offset = MFI.getObjectOffset(FI);
++          int64_t Offset = MFI.getObjectOffset(FI);
            unsigned CFIIndex = MF.addFrameInst(
                MCCFIInstruction::createOffset(nullptr, DwarfReg, Offset));
            BuildMI(MBB, Pos, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
        if ((Reg >= ARM::D0 && Reg <= ARM::D31) &&
            (Reg < ARM::D8 || Reg >= ARM::D8 + AFI->getNumAlignedDPRCS2Regs())) {
          unsigned DwarfReg = MRI->getDwarfRegNum(Reg, true);
--        unsigned Offset = MFI.getObjectOffset(FI);
++        int64_t Offset = MFI.getObjectOffset(FI);
          unsigned CFIIndex = MF.addFrameInst(
              MCCFIInstruction::createOffset(nullptr, DwarfReg, Offset));
          BuildMI(MBB, Pos, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))

  /// instructions. If the CFI instructions describe a frame that cannot be
  /// encoded in compact unwind, the method returns UNWIND_ARM_MODE_DWARF which
  /// tells the runtime to fallback and unwind using dwarf.
--uint32_t ARMAsmBackendDarwin::generateCompactUnwindEncoding(
++uint64_t ARMAsmBackendDarwin::generateCompactUnwindEncoding(
      const MCDwarfFrameInfo *FI, const MCContext *Ctxt) const {
    DEBUG_WITH_TYPE("compact-unwind", llvm::dbgs() << "generateCU()\n");
    // Only armv7k uses CFI based unwinding.

          /*Is64Bit=*/false, cantFail(MachO::getCPUType(TT)), Subtype);
    }
--  uint32_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
++  uint64_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
                                           const MCContext *Ctxt) const override;
  };
  } // end namespace llvm

    }
    void EmitMappingSymbol(StringRef Name) {
--    auto *Symbol = cast<MCSymbolELF>(getContext().getOrCreateSymbol(
++    auto *Symbol = cast<MCSymbolELF>(getContext().createLocalSymbol(Name));
--        Name + "." + Twine(MappingSymbolCounter++)));
      emitLabel(Symbol);
      Symbol->setType(ELF::STT_NOTYPE);
    }
    void emitMappingSymbol(StringRef Name, MCDataFragment &F, uint64_t Offset) {
--    auto *Symbol = cast<MCSymbolELF>(getContext().getOrCreateSymbol(
++    auto *Symbol = cast<MCSymbolELF>(getContext().createLocalSymbol(Name));
--        Name + "." + Twine(MappingSymbolCounter++)));
      emitLabelAtPos(Symbol, SMLoc(), F, Offset);
      Symbol->setType(ELF::STT_NOTYPE);
      Symbol->setBinding(ELF::STB_LOCAL);
    bool IsThumb;
    bool IsAndroid;
--  int64_t MappingSymbolCounter = 0;
    DenseMap<const MCSection *, std::unique_ptr<ElfMappingSymbolInfo>>
        LastMappingSymbols;
    MCTargetStreamer &TS = *getTargetStreamer();
    ARMTargetStreamer &ATS = static_cast<ARMTargetStreamer &>(TS);
    ATS.reset();
--  MappingSymbolCounter = 0;
    MCELFStreamer::reset();
    LastMappingSymbols.clear();
    LastEMSInfo.reset();

    using SpillSlot = TargetFrameLowering::SpillSlot;
    unsigned NumFixed;
--  int MinOffset = 0;  // CS offsets are negative.
++  int64_t MinOffset = 0; // CS offsets are negative.
    const SpillSlot *FixedSlots = getCalleeSavedSpillSlots(NumFixed);
    for (const SpillSlot *S = FixedSlots; S != FixedSlots+NumFixed; ++S) {
      if (!SRegs[S->Reg])
      Register R = x;
      const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(R);
      unsigned Size = TRI->getSpillSize(*RC);
--    int Off = MinOffset - Size;
++    int64_t Off = MinOffset - Size;
      Align Alignment = std::min(TRI->getSpillAlign(*RC), getStackAlign());
      Off &= -Alignment.value();
      int FI = MFI.CreateFixedSpillStackObject(Size, Off);

  def : PatGprGpr<loongarch_mod_wu, MOD_WU>;
  def : PatGprGpr<rotr, ROTR_D>;
  def : PatGprGpr<loongarch_rotr_w, ROTR_W>;
--def : PatGprGpr_32<rotr, ROTR_W>;
  def : PatGprImm<rotr, ROTRI_D, uimm6>;
  def : PatGprImm_32<rotr, ROTRI_W, uimm5>;
  def : PatGprImm<loongarch_rotr_w, ROTRI_W, uimm5>;

    if (!hasFP(MF)) {
      MBBI = FirstCSPop;
--    int64_t Offset = -CSSize - 2;
++    int64_t Offset = -(int64_t)CSSize - 2;
      // Mark callee-saved pop instruction.
      // Define the current CFA rule to use the provided offset.
      while (MBBI != MBB.end()) {

    bool first = true;
--  const Function *F = CB.getFunction();
    unsigned NumArgs = VAInfo ? VAInfo->first : Args.size();
    for (unsigned i = 0, OIdx = 0; i != NumArgs; ++i, ++OIdx) {
      Type *Ty = Args[i].Ty;
        continue;
      }
++    // Indirect calls need strict ABI alignment so we disable optimizations by
++    // not providing a function to optimize.
      Type *ETy = Args[i].IndirectType;
      Align InitialAlign = Outs[OIdx].Flags.getNonZeroByValAlign();
      Align ParamByValAlign =
--        getFunctionByValParamAlign(F, ETy, InitialAlign, DL);
++        getFunctionByValParamAlign(/*F=*/nullptr, ETy, InitialAlign, DL);
      O << ".param .align " << ParamByValAlign.value() << " .b8 ";
      O << "_";

contrib/llvm-project/llvm/lib/Target/PowerPC/PPC.td
@@ -52,6 +52,7 @@ def DirectivePwr7: SubtargetFeature<"", "CPUDirective", "PPC::DIR_PWR7", "">;
	def DirectivePwr8: SubtargetFeature<"", "CPUDirective", "PPC::DIR_PWR8", "">;	def DirectivePwr8: SubtargetFeature<"", "CPUDirective", "PPC::DIR_PWR8", "">;
	def DirectivePwr9: SubtargetFeature<"", "CPUDirective", "PPC::DIR_PWR9", "">;	def DirectivePwr9: SubtargetFeature<"", "CPUDirective", "PPC::DIR_PWR9", "">;
	def DirectivePwr10: SubtargetFeature<"", "CPUDirective", "PPC::DIR_PWR10", "">;	def DirectivePwr10: SubtargetFeature<"", "CPUDirective", "PPC::DIR_PWR10", "">;
		+def DirectivePwr11: SubtargetFeature<"", "CPUDirective", "PPC::DIR_PWR11", "">;
	def DirectivePwrFuture	def DirectivePwrFuture
	: SubtargetFeature<"", "CPUDirective", "PPC::DIR_PWR_FUTURE", "">;	: SubtargetFeature<"", "CPUDirective", "PPC::DIR_PWR_FUTURE", "">;

@@ -467,13 +468,25 @@ def ProcessorFeatures {
	list<SubtargetFeature> P10Features =	list<SubtargetFeature> P10Features =
	!listconcat(P10InheritableFeatures, P10SpecificFeatures);	!listconcat(P10InheritableFeatures, P10SpecificFeatures);

	- // Future	+ // Power11
	- // For ~~future~~ CPU we assume that all of the existing features from Power10	+ // For P11 CPU we assume that all the existing features from Power10
	// still exist with the exception of those we know are Power10 specific.	// still exist with the exception of those we know are Power10 specific.
		+ list<SubtargetFeature> P11AdditionalFeatures =
		+ [DirectivePwr11];
		+ list<SubtargetFeature> P11SpecificFeatures =
		+ [];
		+ list<SubtargetFeature> P11InheritableFeatures =
		+ !listconcat(P10InheritableFeatures, P11AdditionalFeatures);
		+ list<SubtargetFeature> P11Features =
		+ !listconcat(P11InheritableFeatures, P11SpecificFeatures);
		+
		+ // Future
		+ // For future CPU we assume that all of the existing features from Power11
		+ // still exist with the exception of those we know are Power11 specific.
	list<SubtargetFeature> FutureAdditionalFeatures = [FeatureISAFuture];	list<SubtargetFeature> FutureAdditionalFeatures = [FeatureISAFuture];
	list<SubtargetFeature> FutureSpecificFeatures = [];	list<SubtargetFeature> FutureSpecificFeatures = [];
	list<SubtargetFeature> FutureInheritableFeatures =	list<SubtargetFeature> FutureInheritableFeatures =
	- !listconcat(~~P10InheritableFeatures~~, FutureAdditionalFeatures);	+ !listconcat(P11InheritableFeatures, FutureAdditionalFeatures);
	list<SubtargetFeature> FutureFeatures =	list<SubtargetFeature> FutureFeatures =
	!listconcat(FutureInheritableFeatures, FutureSpecificFeatures);	!listconcat(FutureInheritableFeatures, FutureSpecificFeatures);
	}	}
@@ -672,6 +685,7 @@ def : ProcessorModel<"pwr7", P7Model, ProcessorFeatures.P7Features>;
	def : ProcessorModel<"pwr8", P8Model, ProcessorFeatures.P8Features>;	def : ProcessorModel<"pwr8", P8Model, ProcessorFeatures.P8Features>;
	def : ProcessorModel<"pwr9", P9Model, ProcessorFeatures.P9Features>;	def : ProcessorModel<"pwr9", P9Model, ProcessorFeatures.P9Features>;
	def : ProcessorModel<"pwr10", P10Model, ProcessorFeatures.P10Features>;	def : ProcessorModel<"pwr10", P10Model, ProcessorFeatures.P10Features>;
		+def : ProcessorModel<"pwr11", P10Model, ProcessorFeatures.P11Features>;
	// No scheduler model for future CPU.	// No scheduler model for future CPU.
	def : ProcessorModel<"future", NoSchedModel,	def : ProcessorModel<"future", NoSchedModel,
	ProcessorFeatures.FutureFeatures>;	ProcessorFeatures.FutureFeatures>;

    case PPC::DIR_PWR8:
    case PPC::DIR_PWR9:
    case PPC::DIR_PWR10:
++  case PPC::DIR_PWR11:
    case PPC::DIR_PWR_FUTURE:
      setPrefLoopAlignment(Align(16));
      setPrefFunctionAlignment(Align(16));
    case PPC::DIR_PWR8:
    case PPC::DIR_PWR9:
    case PPC::DIR_PWR10:
++  case PPC::DIR_PWR11:
    case PPC::DIR_PWR_FUTURE: {
      if (!ML)
        break;
        return true;
      case PPC::DIR_PWR9:
      case PPC::DIR_PWR10:
++    case PPC::DIR_PWR11:
      case PPC::DIR_PWR_FUTURE:
        //  type        mul     add    shl
        // scalar        5       2      2

    // With P10, we may need to spill paired vector registers or accumulator
    // registers. MMA implies paired vectors, so we can just check that.
    bool IsP10Variant = Subtarget.isISA3_1() || Subtarget.pairedVectorMemops();
++  // P11 uses the P10 target.
    return Subtarget.isISAFuture() ? 3 : IsP10Variant ?
 : Subtarget.hasP9Vector() ?
 : 0;

    DIR_PWR8,
    DIR_PWR9,
    DIR_PWR10,
++  DIR_PWR11,
    DIR_PWR_FUTURE,
    DIR_64
  };

    // Assume that Future CPU has the same cache line size as the others.
    if (Directive == PPC::DIR_PWR7 || Directive == PPC::DIR_PWR8 ||
        Directive == PPC::DIR_PWR9 || Directive == PPC::DIR_PWR10 ||
--      Directive == PPC::DIR_PWR_FUTURE)
++      Directive == PPC::DIR_PWR11 || Directive == PPC::DIR_PWR_FUTURE)
      return 128;
    // On other processors return a default of 64 bytes.
    // Assume that future is the same as the others.
    if (Directive == PPC::DIR_PWR7 || Directive == PPC::DIR_PWR8 ||
        Directive == PPC::DIR_PWR9 || Directive == PPC::DIR_PWR10 ||
--      Directive == PPC::DIR_PWR_FUTURE)
++      Directive == PPC::DIR_PWR11 || Directive == PPC::DIR_PWR_FUTURE)
      return 12;
    // For most things, modern systems have two execution units (and

                                                       uimm4:$funct4,
                                                       AnyReg:$rs2),
                               "$opcode, $funct4, $rd, $rs2">;
--def InsnCI : DirectiveInsnCI<(outs AnyRegC:$rd), (ins uimm2_opcode:$opcode,
++def InsnCI : DirectiveInsnCI<(outs AnyReg:$rd), (ins uimm2_opcode:$opcode,
--                                                      uimm3:$funct3,
++                                                     uimm3:$funct3,
--                                                      simm6:$imm6),
++                                                     simm6:$imm6),
                               "$opcode, $funct3, $rd, $imm6">;
  def InsnCIW : DirectiveInsnCIW<(outs AnyRegC:$rd), (ins uimm2_opcode:$opcode,
                                                          uimm3:$funct3,
                  (InsnCR AnyReg:$rd, uimm2_opcode:$opcode, uimm4:$funct4,
                          AnyReg:$rs2)>;
  def : InstAlias<".insn_ci $opcode, $funct3, $rd, $imm6",
--                (InsnCI AnyRegC:$rd, uimm2_opcode:$opcode, uimm3:$funct3,
++                (InsnCI AnyReg:$rd, uimm2_opcode:$opcode, uimm3:$funct3,
                          simm6:$imm6)>;
  def : InstAlias<".insn_ciw $opcode, $funct3, $rd, $imm8",
                  (InsnCIW AnyRegC:$rd, uimm2_opcode:$opcode, uimm3:$funct3,

    /// Implementation of algorithm to generate the compact unwind encoding
    /// for the CFI instructions.
--  uint32_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
++  uint64_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
                                           const MCContext *Ctxt) const override {
      ArrayRef<MCCFIInstruction> Instrs = FI->Instructions;
      if (Instrs.empty()) return 0;
      bool HasFP = false;
      // Encode that we are using EBP/RBP as the frame pointer.
--    uint32_t CompactUnwindEncoding = 0;
++    uint64_t CompactUnwindEncoding = 0;
      unsigned SubtractInstrIdx = Is64Bit ? 3 : 2;
      unsigned InstrOffset = 0;
      unsigned StackAdjust = 0;
--    unsigned StackSize = 0;
++    uint64_t StackSize = 0;
--    int MinAbsOffset = std::numeric_limits<int>::max();
++    int64_t MinAbsOffset = std::numeric_limits<int64_t>::max();
      for (const MCCFIInstruction &Inst : Instrs) {
        switch (Inst.getOperation()) {
          memset(SavedRegs, 0, sizeof(SavedRegs));
          StackAdjust = 0;
          SavedRegIdx = 0;
--        MinAbsOffset = std::numeric_limits<int>::max();
++        MinAbsOffset = std::numeric_limits<int64_t>::max();
          InstrOffset += MoveInstrSize;
          break;
        }
          unsigned Reg = *MRI.getLLVMRegNum(Inst.getRegister(), true);
          SavedRegs[SavedRegIdx++] = Reg;
          StackAdjust += OffsetSize;
--        MinAbsOffset = std::min(MinAbsOffset, abs(Inst.getOffset()));
++        MinAbsOffset = std::min(MinAbsOffset, std::abs(Inst.getOffset()));
          InstrOffset += PushInstrSize(Reg);
          break;
        }

                                 : FramePtr;
    unsigned DwarfReg = MRI->getDwarfRegNum(MachineFramePtr, true);
    // Offset = space for return address + size of the frame pointer itself.
--  unsigned Offset = (Is64Bit ? 8 : 4) + (Uses64BitFramePtr ? 8 : 4);
++  int64_t Offset = (Is64Bit ? 8 : 4) + (Uses64BitFramePtr ? 8 : 4);
    BuildCFI(MBB, MBBI, DebugLoc{},
             MCCFIInstruction::createOffset(nullptr, DwarfReg, -Offset));
    emitCalleeSavedFrameMoves(MBB, MBBI, DebugLoc{}, true);
    if (!HasFP && NeedsDwarfCFI) {
      MBBI = FirstCSPop;
--    int64_t Offset = -CSSize - SlotSize;
++    int64_t Offset = -(int64_t)CSSize - SlotSize;
      // Mark callee-saved pop instruction.
      // Define the current CFA rule to use the provided offset.
      while (MBBI != MBB.end()) {

        .Case("POWER8NVL", "pwr8")
        .Case("POWER9", "pwr9")
        .Case("POWER10", "pwr10")
++      .Case("POWER11", "pwr11")
        // FIXME: If we get a simulator or machine with the capabilities of
        // mcpu=future, we should revisit this and add the name reported by the
        // simulator/machine.
    case 0x40000:
  #endif
      return "pwr10";
++#ifdef POWER_11
++  case POWER_11:
++#else
++  case 0x80000:
++#endif
++    return "pwr11";
    default:
      return "generic";
    }

contrib/llvm-project/llvm/lib/Transforms/Scalar/LICM.cpp
@@ -113,8 +113,6 @@ STATISTIC(NumFPAssociationsHoisted, "Number of invariant FP expressions "
	STATISTIC(NumIntAssociationsHoisted,	STATISTIC(NumIntAssociationsHoisted,
	"Number of invariant int expressions "	"Number of invariant int expressions "
	"reassociated and hoisted out of the loop");	"reassociated and hoisted out of the loop");
	-STATISTIC(NumBOAssociationsHoisted, "Number of invariant BinaryOp expressions "
	- "reassociated and hoisted out of the loop");

	/// Memory promotion is enabled by default.	/// Memory promotion is enabled by default.
	static cl::opt<bool>	static cl::opt<bool>
@@ -2781,60 +2779,6 @@ static bool hoistMulAddAssociation(Instruction &I, Loop &L,
	return true;	return true;
	}	}

	-/// Reassociate general associative binary expressions of the form
	-///
	-/// 1. "(LV op C1) op C2" ==> "LV op (C1 op C2)"
	-///
	-/// where op is an associative binary op, LV is a loop variant, and C1 and C2
	-/// are loop invariants that we want to hoist.
	-///
	-/// TODO: This can be extended to more cases such as
	-/// 2. "C1 op (C2 op LV)" ==> "(C1 op C2) op LV"
	-/// 3. "(C1 op LV) op C2" ==> "LV op (C1 op C2)" if op is commutative
	-/// 4. "C1 op (LV op C2)" ==> "(C1 op C2) op LV" if op is commutative
	-static bool hoistBOAssociation(Instruction &I, Loop &L,
	- ICFLoopSafetyInfo &SafetyInfo,
	- MemorySSAUpdater &MSSAU, AssumptionCache *AC,
	- DominatorTree *DT) {
	- BinaryOperator *BO = dyn_cast<BinaryOperator>(&I);
	- if (!BO \|\| !BO->isAssociative())
	- return false;
	-
	- Instruction::BinaryOps Opcode = BO->getOpcode();
	- BinaryOperator *Op0 = dyn_cast<BinaryOperator>(BO->getOperand(0));
	-
	- // Transform: "(LV op C1) op C2" ==> "LV op (C1 op C2)"
	- if (Op0 && Op0->getOpcode() == Opcode) {
	- Value *LV = Op0->getOperand(0);
	- Value *C1 = Op0->getOperand(1);
	- Value *C2 = BO->getOperand(1);
	-
	- if (L.isLoopInvariant(LV) \|\| !L.isLoopInvariant(C1) \|\|
	- !L.isLoopInvariant(C2))
	- return false;
	-
	- auto *Preheader = L.getLoopPreheader();
	- assert(Preheader && "Loop is not in simplify form?");
	- IRBuilder<> Builder(Preheader->getTerminator());
	- Value *Inv = Builder.CreateBinOp(Opcode, C1, C2, "invariant.op");
	-
	- auto *NewBO =
	- BinaryOperator::Create(Opcode, LV, Inv, BO->getName() + ".reass", BO);
	- NewBO->copyIRFlags(BO);
	- BO->replaceAllUsesWith(NewBO);
	- eraseInstruction(*BO, SafetyInfo, MSSAU);
	-
	- // Note: (LV op C1) might not be erased if it has more uses than the one we
	- // just replaced.
	- if (Op0->use_empty())
	- eraseInstruction(*Op0, SafetyInfo, MSSAU);
	-
	- return true;
	- }
	-
	- return false;
	-}
	-
	static bool hoistArithmetics(Instruction &I, Loop &L,	static bool hoistArithmetics(Instruction &I, Loop &L,
	ICFLoopSafetyInfo &SafetyInfo,	ICFLoopSafetyInfo &SafetyInfo,
	MemorySSAUpdater &MSSAU, AssumptionCache *AC,	MemorySSAUpdater &MSSAU, AssumptionCache *AC,
@@ -2872,12 +2816,6 @@ static bool hoistArithmetics(Instruction &I, Loop &L,
	return true;	return true;
	}	}

	- if (hoistBOAssociation(I, L, SafetyInfo, MSSAU, AC, DT)) {
	- ++NumHoisted;
	- ++NumBOAssociationsHoisted;
	- return true;
	- }
	-
	return false;	return false;
	}	}

                             // FIXME: AR->getNoWrapFlags(SCEV::FlagNW)
                             SCEV::FlagAnyWrap);
      return Result;
--  } else if (EnableVScaleImmediates)
++  } else if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(S)) {
--    if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(S))
++    if (EnableVScaleImmediates && M->getNumOperands() == 2) {
        if (const SCEVConstant *C = dyn_cast<SCEVConstant>(M->getOperand(0)))
          if (isa<SCEVVScale>(M->getOperand(1))) {
            S = SE.getConstant(M->getType(), 0);
            return Immediate::getScalable(C->getValue()->getSExtValue());
          }
++    }
++  }
    return Immediate::getZero();
  }

      cl::desc("The maximum allowed number of runtime memory checks"));
  static cl::opt<bool> UseLegacyCostModel(
--    "vectorize-use-legacy-cost-model", cl::init(false), cl::Hidden,
++    "vectorize-use-legacy-cost-model", cl::init(true), cl::Hidden,
      cl::desc("Use the legacy cost model instead of the VPlan-based cost model. "
               "This option will be removed in the future."));

lib/clang/include/VCSVersion.inc
@@ -1,8 +1,8 @@
	-#define LLVM_REVISION "llvmorg-19-~~init~~-~~18630~~-~~gf2ccf80136a0"~~	+#define LLVM_REVISION "llvmorg-19.1.0-rc1-0-ga4902a36d5c2"
	#define LLVM_REPOSITORY "https://github.com/llvm/llvm-project.git"	#define LLVM_REPOSITORY "https://github.com/llvm/llvm-project.git"

	-#define CLANG_REVISION "llvmorg-19-~~init~~-~~18630~~-~~gf2ccf80136a0"~~	+#define CLANG_REVISION "llvmorg-19.1.0-rc1-0-ga4902a36d5c2"
	#define CLANG_REPOSITORY "https://github.com/llvm/llvm-project.git"	#define CLANG_REPOSITORY "https://github.com/llvm/llvm-project.git"

	-#define LLDB_REVISION "llvmorg-19-~~init~~-~~18630~~-~~gf2ccf80136a0"~~	+#define LLDB_REVISION "llvmorg-19.1.0-rc1-0-ga4902a36d5c2"
	#define LLDB_REPOSITORY "https://github.com/llvm/llvm-project.git"	#define LLDB_REPOSITORY "https://github.com/llvm/llvm-project.git"

lib/clang/include/clang/Basic/Version.inc
@@ -1,8 +1,8 @@
	-#define CLANG_VERSION 19.0.0	+#define CLANG_VERSION 19.1.0-rc1
	-#define CLANG_VERSION_STRING "19.0.0"	+#define CLANG_VERSION_STRING "19.1.0-rc1"
	#define CLANG_VERSION_MAJOR 19	#define CLANG_VERSION_MAJOR 19
	#define CLANG_VERSION_MAJOR_STRING "19"	#define CLANG_VERSION_MAJOR_STRING "19"
	-#define CLANG_VERSION_MINOR 0	+#define CLANG_VERSION_MINOR 1
	#define CLANG_VERSION_PATCHLEVEL 0	#define CLANG_VERSION_PATCHLEVEL 0

	#define CLANG_VENDOR "FreeBSD "	#define CLANG_VENDOR "FreeBSD "

  // Local identifier in __FreeBSD_version style
  #define LLD_FREEBSD_VERSION 1400007
--#define LLD_VERSION_STRING "19.0.0 (FreeBSD llvmorg-19-init-18630-gf2ccf80136a0-" __XSTRING(LLD_FREEBSD_VERSION) ")"
++#define LLD_VERSION_STRING "19.1.0 (FreeBSD llvmorg-19.1.0-rc1-0-ga4902a36d5c2-" __XSTRING(LLD_FREEBSD_VERSION) ")"

lib/clang/include/lldb/Version/Version.inc
@@ -1,6 +1,6 @@
	-#define LLDB_VERSION 19.0.0	+#define LLDB_VERSION 19.1.0-rc1
	-#define LLDB_VERSION_STRING "19.0.0"	+#define LLDB_VERSION_STRING "19.1.0-rc1"
	#define LLDB_VERSION_MAJOR 19	#define LLDB_VERSION_MAJOR 19
	-#define LLDB_VERSION_MINOR 0	+#define LLDB_VERSION_MINOR 1
	#define LLDB_VERSION_PATCH 0	#define LLDB_VERSION_PATCH 0
	/* #undef LLDB_FULL_VERSION_STRING */	/* #undef LLDB_FULL_VERSION_STRING */

  #define PACKAGE_NAME "LLVM"
  /* Define to the full name and version of this package. */
--#define PACKAGE_STRING "LLVM 19.0.0"
++#define PACKAGE_STRING "LLVM 19.1.0-rc1"
  /* Define to the version of this package. */
--#define PACKAGE_VERSION "19.0.0"
++#define PACKAGE_VERSION "19.1.0-rc1"
  /* Define to the vendor of this package. */
  /* #undef PACKAGE_VENDOR */

  #define LLVM_VERSION_MAJOR 19
  /* Minor version of the LLVM API */
--#define LLVM_VERSION_MINOR 0
++#define LLVM_VERSION_MINOR 1
  /* Patch version of the LLVM API */
  #define LLVM_VERSION_PATCH 0
  /* LLVM version string */
--#define LLVM_VERSION_STRING "19.0.0"
++#define LLVM_VERSION_STRING "19.1.0-rc1"
  /* Whether LLVM records statistics for use with GetStatistics(),
   * PrintStatistics() or PrintStatisticsJSON()

lib/clang/include/llvm/Support/VCSRevision.h
@@ -1,2 +1,2 @@
	-#define LLVM_REVISION "llvmorg-19-~~init~~-~~18630~~-~~gf2ccf80136a0"~~	+#define LLVM_REVISION "llvmorg-19.1.0-rc1-0-ga4902a36d5c2"
	#define LLVM_REPOSITORY "https://github.com/llvm/llvm-project.git"	#define LLVM_REPOSITORY "https://github.com/llvm/llvm-project.git"

  SRCS_FUL+=        StaticAnalyzer/Checkers/CheckObjCInstMethSignature.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/CheckPlacementNew.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp
++SRCS_FUL+=        StaticAnalyzer/Checkers/CheckerDocumentation.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/ChrootChecker.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/CloneChecker.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/ContainerModeling.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/MoveChecker.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/NSAutoreleasePoolChecker.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/NSErrorChecker.cpp
++SRCS_FUL+=        StaticAnalyzer/Checkers/NoOwnershipChangeVisitor.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/NoReturnFunctionChecker.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/NonNullParamChecker.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/NonnullGlobalConstantsChecker.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/PointerSortingChecker.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/PointerSubChecker.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/PthreadLockChecker.cpp
++SRCS_FUL+=        StaticAnalyzer/Checkers/PutenvStackArrayChecker.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/ReturnValueChecker.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/RunLoopAutoreleaseLeakChecker.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/STLAlgorithmModeling.cpp
++SRCS_FUL+=        StaticAnalyzer/Checkers/SetgidSetuidOrderChecker.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/SimpleStreamChecker.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/SmartPtrChecker.cpp
  SRCS_FUL+=        StaticAnalyzer/Checkers/SmartPtrModeling.cpp
  SRCS_FUL+=        StaticAnalyzer/Core/SymbolManager.cpp
  SRCS_FUL+=        StaticAnalyzer/Core/TextDiagnostics.cpp
  SRCS_FUL+=        StaticAnalyzer/Core/WorkList.cpp
++SRCS_FUL+=        StaticAnalyzer/Core/Z3CrosscheckVisitor.cpp
  SRCS_FUL+=        StaticAnalyzer/Frontend/AnalysisConsumer.cpp
  SRCS_FUL+=        StaticAnalyzer/Frontend/AnalyzerHelpFlags.cpp
  SRCS_FUL+=        StaticAnalyzer/Frontend/CheckerRegistry.cpp

  SRCS_MIN+=        ProfileData/InstrProfWriter.cpp
  SRCS_MIN+=        ProfileData/ItaniumManglingCanonicalizer.cpp
  SRCS_MIN+=        ProfileData/MemProf.cpp
++SRCS_COV+=        ProfileData/MemProfReader.cpp
  SRCS_MIN+=        ProfileData/ProfileSummaryBuilder.cpp
  SRCS_MIN+=        ProfileData/SampleProf.cpp
  SRCS_MIN+=        ProfileData/SampleProfReader.cpp

  STD_HEADERS+=        mdspan
  STD_HEADERS+=        memory
  STD_HEADERS+=        memory_resource
++STD_HEADERS+=        module.modulemap
  STD_HEADERS+=        mutex
  STD_HEADERS+=        new
  STD_HEADERS+=        numbers
  # Generated by CMake as of libc++ 19.
  STD_HEADERS+=        ${.CURDIR}/libcxx.imp
--# Generated by CMake as of libc++ 15.
--STD+=                ${.CURDIR}/module.modulemap
  RT_HEADERS+=        cxxabi.h
  .for hdr in ${RT_HEADERS}
  STD+=                ${_LIBCXXRTDIR}/${hdr}

lib/libc++/module.modulemap→/dev/null
@@ -1,2136 +0,0 @@
	-// Main C++ standard library interfaces
	-module std_algorithm [system] {
	- header "algorithm"
	- export *
	-}
	-module std_any [system] {
	- header "any"
	- export *
	-}
	-module std_array [system] {
	- header "array"
	- export *
	-}
	-module std_atomic [system] {
	- header "atomic"
	- export *
	-}
	-module std_barrier [system] {
	- header "barrier"
	- export *
	-}
	-module std_bit [system] {
	- header "bit"
	- export *
	-}
	-module std_bitset [system] {
	- header "bitset"
	- export *
	-}
	-module std_charconv [system] {
	- header "charconv"
	- export *
	-}
	-module std_chrono [system] {
	- header "chrono"
	- export *
	-}
	-module std_codecvt [system] {
	- header "codecvt"
	- export *
	-}
	-module std_compare [system] {
	- header "compare"
	- export *
	-}
	-module std_complex [system] {
	- header "complex"
	- export *
	-}
	-module std_concepts [system] {
	- header "concepts"
	- export *
	-}
	-module std_condition_variable [system] {
	- header "condition_variable"
	- export *
	-}
	-module std_coroutine [system] {
	- header "coroutine"
	- export *
	-}
	-module std_deque [system] {
	- header "deque"
	- export *
	-}
	-module std_exception [system] {
	- header "exception"
	- export *
	-}
	-module std_execution [system] {
	- header "execution"
	- export *
	-}
	-module std_expected [system] {
	- header "expected"
	- export *
	-}
	-module std_filesystem [system] {
	- header "filesystem"
	- export *
	-}
	-module std_format [system] {
	- header "format"
	- export *
	-}
	-module std_forward_list [system] {
	- header "forward_list"
	- export *
	-}
	-module std_fstream [system] {
	- header "fstream"
	- export *
	-}
	-module std_functional [system] {
	- header "functional"
	- export *
	-}
	-module std_future [system] {
	- header "future"
	- export *
	-}
	-module std_initializer_list [system] {
	- header "initializer_list"
	- export *
	-}
	-module std_iomanip [system] {
	- header "iomanip"
	- export *
	-}
	-module std_ios [system] {
	- header "ios"
	- export *
	-}
	-module std_iosfwd [system] {
	- header "iosfwd"
	- export *
	-}
	-module std_iostream [system] {
	- header "iostream"
	- export *
	-}
	-module std_istream [system] {
	- header "istream"
	- export *
	-}
	-module std_iterator [system] {
	- header "iterator"
	- export *
	-}
	-module std_latch [system] {
	- header "latch"
	- export *
	-}
	-module std_limits [system] {
	- header "limits"
	- export *
	-}
	-module std_list [system] {
	- header "list"
	- export *
	-}
	-module std_locale [system] {
	- header "locale"
	- export *
	-}
	-module std_map [system] {
	- header "map"
	- export *
	-}
	-module std_mdspan [system] {
	- header "mdspan"
	- export *
	-}
	-module std_memory [system] {
	- header "memory"
	- export *
	-}
	-module std_memory_resource [system] {
	- header "memory_resource"
	- export *
	-}
	-module std_mutex [system] {
	- header "mutex"
	- export *
	-}
	-module std_new [system] {
	- header "new"
	- export *
	-}
	-module std_numbers [system] {
	- header "numbers"
	- export *
	-}
	-module std_numeric [system] {
	- header "numeric"
	- export *
	-}
	-module std_optional [system] {
	- header "optional"
	- export *
	-}
	-module std_ostream [system] {
	- header "ostream"
	- export *
	-}
	-module std_print [system] {
	- header "print"
	- export *
	-}
	-module std_queue [system] {
	- header "queue"
	- export *
	-}
	-module std_random [system] {
	- header "random"
	- export *
	-}
	-module std_ranges [system] {
	- header "ranges"
	- export *
	-}
	-module std_ratio [system] {
	- header "ratio"
	- export *
	-}
	-module std_regex [system] {
	- header "regex"
	- export *
	-}
	-module std_scoped_allocator [system] {
	- header "scoped_allocator"
	- export *
	-}
	-module std_semaphore [system] {
	- header "semaphore"
	- export *
	-}
	-module std_set [system] {
	- header "set"
	- export *
	-}
	-module std_shared_mutex [system] {
	- header "shared_mutex"
	- export std_version
	-}
	-module std_source_location [system] {
	- header "source_location"
	- export *
	-}
	-module std_span [system] {
	- header "span"
	- export std_private_ranges_enable_borrowed_range
	- export std_version
	- export std_private_span_span_fwd
	-}
	-module std_sstream [system] {
	- header "sstream"
	- export *
	-}
	-module std_stack [system] {
	- header "stack"
	- export *
	-}
	-module std_stdexcept [system] {
	- header "stdexcept"
	- export *
	-}
	-module std_stop_token {
	- header "stop_token"
	- export *
	-}
	-module std_streambuf [system] {
	- header "streambuf"
	- export *
	-}
	-module std_string [system] {
	- header "string"
	- export *
	-}
	-module std_string_view [system] {
	- header "string_view"
	- export *
	-}
	-module std_strstream [system] {
	- header "strstream"
	- export *
	-}
	-module std_syncstream [system] {
	- header "syncstream"
	- export *
	-}
	-module std_system_error [system] {
	- header "system_error"
	- export *
	-}
	-module std_thread [system] {
	- header "thread"
	- export *
	-}
	-module std_tuple [system] {
	- header "tuple"
	- export *
	-}
	-module std_type_traits [system] {
	- header "type_traits"
	- export *
	-}
	-module std_typeindex [system] {
	- header "typeindex"
	- export *
	-}
	-module std_typeinfo [system] {
	- header "typeinfo"
	- export *
	-}
	-module std_unordered_map [system] {
	- header "unordered_map"
	- export *
	-}
	-module std_unordered_set [system] {
	- header "unordered_set"
	- export *
	-}
	-module std_utility [system] {
	- header "utility"
	- export *
	-}
	-module std_valarray [system] {
	- header "valarray"
	- export *
	-}
	-module std_variant [system] {
	- header "variant"
	- export *
	-}
	-module std_vector [system] {
	- header "vector"
	- export *
	-}
	-module std_version [system] {
	- header "version"
	- export *
	-}
	-
	-// C standard library interface wrappers
	-module std_cassert [system] {
	- // <cassert>'s use of NDEBUG requires textual inclusion.
	- textual header "cassert"
	-}
	-module std_ccomplex [system] {
	- header "ccomplex"
	- export *
	-}
	-module std_cctype [system] {
	- header "cctype"
	- export *
	-}
	-module std_cerrno [system] {
	- header "cerrno"
	- export *
	-}
	-module std_cfenv [system] {
	- header "cfenv"
	- export *
	-}
	-module std_cfloat [system] {
	- header "cfloat"
	- export *
	-}
	-module std_cinttypes [system] {
	- header "cinttypes"
	- export *
	-}
	-module std_ciso646 [system] {
	- header "ciso646"
	- export *
	-}
	-module std_climits [system] {
	- header "climits"
	- export *
	-}
	-module std_clocale [system] {
	- header "clocale"
	- export *
	-}
	-module std_cmath [system] {
	- header "cmath"
	- export *
	-}
	-module std_csetjmp [system] {
	- header "csetjmp"
	- export *
	-}
	-module std_csignal [system] {
	- header "csignal"
	- export *
	-}
	-// FIXME: <cstdalign> is missing.
	-module std_cstdarg [system] {
	- header "cstdarg"
	- export *
	-}
	-module std_cstdbool [system] {
	- header "cstdbool"
	- export *
	-}
	-module std_cstddef [system] {
	- header "cstddef"
	- export *
	-}
	-module std_cstdint [system] {
	- header "cstdint"
	- export *
	-}
	-module std_cstdio [system] {
	- header "cstdio"
	- export *
	-}
	-module std_cstdlib [system] {
	- header "cstdlib"
	- export *
	-}
	-module std_cstring [system] {
	- header "cstring"
	- export *
	-}
	-module std_ctgmath [system] {
	- header "ctgmath"
	- export *
	-}
	-module std_ctime [system] {
	- header "ctime"
	- export *
	-}
	-module std_cuchar [system] {
	- header "cuchar"
	- export *
	-}
	-module std_cwchar [system] {
	- header "cwchar"
	- export *
	-}
	-module std_cwctype [system] {
	- header "cwctype"
	- export *
	-}
	-
	-// C standard library interfaces augmented/replaced in C++
	-// <assert.h> provided by C library.
	-module std_complex_h [system] {
	- header "complex.h"
	- export *
	-}
	-module std_ctype_h [system] {
	- header "ctype.h"
	- export *
	-}
	-module std_errno_h [system] {
	- header "errno.h"
	- export *
	-}
	-module std_fenv_h [system] {
	- header "fenv.h"
	- export *
	-}
	-module std_float_h [system] {
	- header "float.h"
	- export *
	-}
	-module std_inttypes_h [system] {
	- header "inttypes.h"
	- export *
	-}
	-// <iso646.h> provided by compiler.
	-module std_locale_h [system] {
	- header "locale.h"
	- export *
	-}
	-module std_math_h [system] {
	- header "math.h"
	- export *
	-}
	-// <setjmp.h> provided by C library.
	-// <signal.h> provided by C library.
	-// FIXME: <stdalign.h> is missing.
	-// <stdarg.h> provided by compiler.
	-module std_stdatomic_h [system] {
	- header "stdatomic.h"
	- export *
	-}
	-module std_stdbool_h [system] {
	- // <stdbool.h>'s __bool_true_false_are_defined macro requires textual inclusion.
	- textual header "stdbool.h"
	- export *
	-}
	-module std_stddef_h [system] {
	- // <stddef.h>'s __need_* macros require textual inclusion.
	- textual header "stddef.h"
	- export *
	-}
	-module std_stdint_h [system] {
	- header "stdint.h"
	- export *
	-}
	-module std_stdio_h [system] {
	- // <stdio.h>'s __need_* macros require textual inclusion.
	- textual header "stdio.h"
	- export *
	-}
	-module std_stdlib_h [system] {
	- // <stdlib.h>'s __need_* macros require textual inclusion.
	- textual header "stdlib.h"
	- export *
	-}
	-module std_string_h [system] {
	- header "string.h"
	- export *
	-}
	-module std_tgmath_h [system] {
	- header "tgmath.h"
	- export *
	-}
	-module std_uchar_h [system] {
	- header "uchar.h"
	- export *
	-}
	-// <time.h> provided by C library.
	-module std_wchar_h [system] {
	- // <wchar.h>'s __need_* macros require textual inclusion.
	- textual header "wchar.h"
	- export *
	-}
	-module std_wctype_h [system] {
	- header "wctype.h"
	- export *
	-}
	-
	-// Experimental C++ standard library interfaces
	-module std_experimental [system] {
	- module iterator {
	- header "experimental/iterator"
	- export *
	- }
	- module memory {
	- header "experimental/memory"
	- export *
	- }
	- module propagate_const {
	- header "experimental/propagate_const"
	- export *
	- }
	- module simd {
	- module aligned_tag { private header "experimental/__simd/aligned_tag.h" }
	- module declaration { private header "experimental/__simd/declaration.h" }
	- module reference { private header "experimental/__simd/reference.h" }
	- module scalar { private header "experimental/__simd/scalar.h" }
	- module simd { private header "experimental/__simd/simd.h" }
	- module simd_mask { private header "experimental/__simd/simd_mask.h" }
	- module traits { private header "experimental/__simd/traits.h" }
	- module utility { private header "experimental/__simd/utility.h" }
	- module vec_ext { private header "experimental/__simd/vec_ext.h" }
	-
	- header "experimental/simd"
	- export *
	- }
	- module type_traits {
	- header "experimental/type_traits"
	- export *
	- }
	- module utility {
	- header "experimental/utility"
	- export *
	- }
	- module __config {
	- textual header "experimental/__config"
	- export *
	- }
	-}
	-
	-// Convenience method to get all of the above modules in a single import statement.
	-// Importing only the needed modules is likely to be more performant.
	-module std [system] {
	- header "__std_clang_module"
	- export *
	-}
	-
	-// Implementation detail headers that are private to libc++. These modules
	-// must not be directly imported.
	-module std_private_assert [system] {
	- header "__assert"
	- export *
	-}
	-module std_private_bit_reference [system] {
	- header "__bit_reference"
	- export *
	-}
	-module std_private_fwd_bit_reference [system] {
	- header "__fwd/bit_reference.h"
	-}
	-module std_private_config [system] {
	- textual header "__config"
	- textual header "__configuration/abi.h"
	- textual header "__configuration/availability.h"
	- textual header "__configuration/compiler.h"
	- textual header "__configuration/language.h"
	- textual header "__configuration/platform.h"
	- export *
	-}
	-module std_private_hash_table [system] {
	- header "__hash_table"
	- export *
	-}
	-module std_private_locale [system] {
	- header "__locale"
	- export *
	-}
	-module std_private_mbstate_t [system] {
	- header "__mbstate_t.h"
	- export *
	-}
	-module std_private_node_handle [system] {
	- header "__node_handle"
	- export *
	-}
	-module std_private_split_buffer [system] {
	- header "__split_buffer"
	- export *
	-}
	-module std_private_std_mbstate_t [system] {
	- header "__std_mbstate_t.h"
	- export *
	-}
	-module std_private_tree [system] {
	- header "__tree"
	- export *
	-}
	-module std_private_undef_macros [system] {
	- textual header "__undef_macros"
	- export *
	-}
	-module std_private_verbose_abort [system] {
	- header "__verbose_abort"
	- export *
	-}
	-
	-module std_private_algorithm_adjacent_find [system] { header "__algorithm/adjacent_find.h" }
	-module std_private_algorithm_all_of [system] { header "__algorithm/all_of.h" }
	-module std_private_algorithm_any_of [system] { header "__algorithm/any_of.h" }
	-module std_private_algorithm_binary_search [system] { header "__algorithm/binary_search.h" }
	-module std_private_algorithm_clamp [system] { header "__algorithm/clamp.h" }
	-module std_private_algorithm_comp [system] { header "__algorithm/comp.h" }
	-module std_private_algorithm_comp_ref_type [system] { header "__algorithm/comp_ref_type.h" }
	-module std_private_algorithm_copy [system] {
	- header "__algorithm/copy.h"
	- export std_private_algorithm_copy_move_common
	-}
	-module std_private_algorithm_copy_backward [system] { header "__algorithm/copy_backward.h" }
	-module std_private_algorithm_copy_if [system] { header "__algorithm/copy_if.h" }
	-module std_private_algorithm_copy_move_common [system] {
	- header "__algorithm/copy_move_common.h"
	- export std_private_type_traits_is_trivially_copyable
	-}
	-module std_private_algorithm_copy_n [system] { header "__algorithm/copy_n.h" }
	-module std_private_algorithm_count [system] { header "__algorithm/count.h" }
	-module std_private_algorithm_count_if [system] { header "__algorithm/count_if.h" }
	-module std_private_algorithm_equal [system] { header "__algorithm/equal.h" }
	-module std_private_algorithm_equal_range [system] { header "__algorithm/equal_range.h" }
	-module std_private_algorithm_fill [system] { header "__algorithm/fill.h" }
	-module std_private_algorithm_fill_n [system] { header "__algorithm/fill_n.h" }
	-module std_private_algorithm_find [system] {
	- header "__algorithm/find.h"
	- export std_private_algorithm_unwrap_iter
	-}
	-module std_private_algorithm_find_end [system] { header "__algorithm/find_end.h" }
	-module std_private_algorithm_find_first_of [system] { header "__algorithm/find_first_of.h" }
	-module std_private_algorithm_find_if [system] { header "__algorithm/find_if.h" }
	-module std_private_algorithm_find_if_not [system] { header "__algorithm/find_if_not.h" }
	-module std_private_algorithm_find_segment_if [system] { header "__algorithm/find_segment_if.h" }
	-module std_private_algorithm_fold [system] { header "__algorithm/fold.h" }
	-module std_private_algorithm_for_each [system] { header "__algorithm/for_each.h" }
	-module std_private_algorithm_for_each_n [system] { header "__algorithm/for_each_n.h" }
	-module std_private_algorithm_for_each_segment [system] { header "__algorithm/for_each_segment.h" }
	-module std_private_algorithm_generate [system] { header "__algorithm/generate.h" }
	-module std_private_algorithm_generate_n [system] { header "__algorithm/generate_n.h" }
	-module std_private_algorithm_half_positive [system] { header "__algorithm/half_positive.h" }
	-module std_private_algorithm_in_found_result [system] { header "__algorithm/in_found_result.h" }
	-module std_private_algorithm_in_fun_result [system] { header "__algorithm/in_fun_result.h" }
	-module std_private_algorithm_in_in_out_result [system] { header "__algorithm/in_in_out_result.h" }
	-module std_private_algorithm_in_in_result [system] { header "__algorithm/in_in_result.h" }
	-module std_private_algorithm_in_out_out_result [system] { header "__algorithm/in_out_out_result.h" }
	-module std_private_algorithm_in_out_result [system] { header "__algorithm/in_out_result.h" }
	-module std_private_algorithm_includes [system] { header "__algorithm/includes.h" }
	-module std_private_algorithm_inplace_merge [system] { header "__algorithm/inplace_merge.h" }
	-module std_private_algorithm_is_heap [system] { header "__algorithm/is_heap.h" }
	-module std_private_algorithm_is_heap_until [system] { header "__algorithm/is_heap_until.h" }
	-module std_private_algorithm_is_partitioned [system] { header "__algorithm/is_partitioned.h" }
	-module std_private_algorithm_is_permutation [system] { header "__algorithm/is_permutation.h" }
	-module std_private_algorithm_is_sorted [system] { header "__algorithm/is_sorted.h" }
	-module std_private_algorithm_is_sorted_until [system] { header "__algorithm/is_sorted_until.h" }
	-module std_private_algorithm_iter_swap [system] { header "__algorithm/iter_swap.h" }
	-module std_private_algorithm_iterator_operations [system] {
	- header "__algorithm/iterator_operations.h"
	- export *
	-}
	-module std_private_algorithm_lexicographical_compare [system] { header "__algorithm/lexicographical_compare.h" }
	-module std_private_algorithm_lexicographical_compare_three_way [system] { header "__algorithm/lexicographical_compare_three_way.h" }
	-module std_private_algorithm_lower_bound [system] { header "__algorithm/lower_bound.h" }
	-module std_private_algorithm_make_heap [system] { header "__algorithm/make_heap.h" }
	-module std_private_algorithm_make_projected [system] { header "__algorithm/make_projected.h" }
	-module std_private_algorithm_max [system] { header "__algorithm/max.h" }
	-module std_private_algorithm_max_element [system] { header "__algorithm/max_element.h" }
	-module std_private_algorithm_merge [system] { header "__algorithm/merge.h" }
	-module std_private_algorithm_min [system] { header "__algorithm/min.h" }
	-module std_private_algorithm_min_element [system] { header "__algorithm/min_element.h" }
	-module std_private_algorithm_min_max_result [system] { header "__algorithm/min_max_result.h" }
	-module std_private_algorithm_minmax [system] {
	- header "__algorithm/minmax.h"
	- export *
	-}
	-module std_private_algorithm_minmax_element [system] { header "__algorithm/minmax_element.h" }
	-module std_private_algorithm_mismatch [system] {
	- header "__algorithm/mismatch.h"
	- export std_private_algorithm_simd_utils
	- export std_private_iterator_aliasing_iterator
	-}
	-module std_private_algorithm_move [system] { header "__algorithm/move.h" }
	-module std_private_algorithm_move_backward [system] { header "__algorithm/move_backward.h" }
	-module std_private_algorithm_next_permutation [system] { header "__algorithm/next_permutation.h" }
	-module std_private_algorithm_none_of [system] { header "__algorithm/none_of.h" }
	-module std_private_algorithm_nth_element [system] { header "__algorithm/nth_element.h" }
	-module std_private_algorithm_partial_sort [system] { header "__algorithm/partial_sort.h" }
	-module std_private_algorithm_partial_sort_copy [system] { header "__algorithm/partial_sort_copy.h" }
	-module std_private_algorithm_partition [system] { header "__algorithm/partition.h" }
	-module std_private_algorithm_partition_copy [system] { header "__algorithm/partition_copy.h" }
	-module std_private_algorithm_partition_point [system] { header "__algorithm/partition_point.h" }
	-module std_private_algorithm_pop_heap [system] { header "__algorithm/pop_heap.h" }
	-module std_private_algorithm_prev_permutation [system] { header "__algorithm/prev_permutation.h" }
	-module std_private_algorithm_pstl [system] {
	- header "__algorithm/pstl.h"
	- export *
	-}
	-module std_private_algorithm_push_heap [system] { header "__algorithm/push_heap.h" }
	-module std_private_algorithm_ranges_adjacent_find [system] { header "__algorithm/ranges_adjacent_find.h" }
	-module std_private_algorithm_ranges_all_of [system] { header "__algorithm/ranges_all_of.h" }
	-module std_private_algorithm_ranges_any_of [system] { header "__algorithm/ranges_any_of.h" }
	-module std_private_algorithm_ranges_binary_search [system] {
	- header "__algorithm/ranges_binary_search.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_clamp [system] {
	- header "__algorithm/ranges_clamp.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_contains [system] { header "__algorithm/ranges_contains.h" }
	-module std_private_algorithm_ranges_contains_subrange [system] { header "__algorithm/ranges_contains_subrange.h" }
	-module std_private_algorithm_ranges_copy [system] {
	- header "__algorithm/ranges_copy.h"
	- export std_private_algorithm_in_out_result
	-}
	-module std_private_algorithm_ranges_copy_backward [system] {
	- header "__algorithm/ranges_copy_backward.h"
	- export std_private_algorithm_in_out_result
	-}
	-module std_private_algorithm_ranges_copy_if [system] {
	- header "__algorithm/ranges_copy_if.h"
	- export std_private_algorithm_in_out_result
	-}
	-module std_private_algorithm_ranges_copy_n [system] {
	- header "__algorithm/ranges_copy_n.h"
	- export std_private_algorithm_in_out_result
	-}
	-module std_private_algorithm_ranges_count [system] { header "__algorithm/ranges_count.h" }
	-module std_private_algorithm_ranges_count_if [system] { header "__algorithm/ranges_count_if.h" }
	-module std_private_algorithm_ranges_ends_with [system] { header "__algorithm/ranges_ends_with.h" }
	-module std_private_algorithm_ranges_equal [system] { header "__algorithm/ranges_equal.h" }
	-module std_private_algorithm_ranges_equal_range [system] {
	- header "__algorithm/ranges_equal_range.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_fill [system] { header "__algorithm/ranges_fill.h" }
	-module std_private_algorithm_ranges_fill_n [system] { header "__algorithm/ranges_fill_n.h" }
	-module std_private_algorithm_ranges_find [system] { header "__algorithm/ranges_find.h" }
	-module std_private_algorithm_ranges_find_end [system] { header "__algorithm/ranges_find_end.h" }
	-module std_private_algorithm_ranges_find_first_of [system] { header "__algorithm/ranges_find_first_of.h" }
	-module std_private_algorithm_ranges_find_if [system] { header "__algorithm/ranges_find_if.h" }
	-module std_private_algorithm_ranges_find_if_not [system] { header "__algorithm/ranges_find_if_not.h" }
	-module std_private_algorithm_ranges_find_last [system] { header "__algorithm/ranges_find_last.h" }
	-module std_private_algorithm_ranges_for_each [system] {
	- header "__algorithm/ranges_for_each.h"
	- export std_private_algorithm_in_fun_result
	-}
	-module std_private_algorithm_ranges_for_each_n [system] {
	- header "__algorithm/ranges_for_each_n.h"
	- export std_private_algorithm_in_fun_result
	-}
	-module std_private_algorithm_ranges_generate [system] { header "__algorithm/ranges_generate.h" }
	-module std_private_algorithm_ranges_generate_n [system] { header "__algorithm/ranges_generate_n.h" }
	-module std_private_algorithm_ranges_includes [system] {
	- header "__algorithm/ranges_includes.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_inplace_merge [system] {
	- header "__algorithm/ranges_inplace_merge.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_is_heap [system] {
	- header "__algorithm/ranges_is_heap.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_is_heap_until [system] {
	- header "__algorithm/ranges_is_heap_until.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_is_partitioned [system] { header "__algorithm/ranges_is_partitioned.h" }
	-module std_private_algorithm_ranges_is_permutation [system] { header "__algorithm/ranges_is_permutation.h" }
	-module std_private_algorithm_ranges_is_sorted [system] {
	- header "__algorithm/ranges_is_sorted.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_is_sorted_until [system] {
	- header "__algorithm/ranges_is_sorted_until.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_iterator_concept [system] { header "__algorithm/ranges_iterator_concept.h" }
	-module std_private_algorithm_ranges_lexicographical_compare [system] {
	- header "__algorithm/ranges_lexicographical_compare.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_lower_bound [system] {
	- header "__algorithm/ranges_lower_bound.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_make_heap [system] {
	- header "__algorithm/ranges_make_heap.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_max [system] {
	- header "__algorithm/ranges_max.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_max_element [system] {
	- header "__algorithm/ranges_max_element.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_merge [system] {
	- header "__algorithm/ranges_merge.h"
	- export std_private_algorithm_in_in_out_result
	-}
	-module std_private_algorithm_ranges_min [system] {
	- header "__algorithm/ranges_min.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_min_element [system] {
	- header "__algorithm/ranges_min_element.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_minmax [system] {
	- header "__algorithm/ranges_minmax.h"
	- export std_private_functional_ranges_operations
	- export std_private_algorithm_min_max_result
	-}
	-module std_private_algorithm_ranges_minmax_element [system] {
	- header "__algorithm/ranges_minmax_element.h"
	- export std_private_functional_ranges_operations
	- export std_private_algorithm_min_max_result
	-}
	-module std_private_algorithm_ranges_mismatch [system] {
	- header "__algorithm/ranges_mismatch.h"
	- export std_private_algorithm_in_in_result
	-}
	-module std_private_algorithm_ranges_move [system] {
	- header "__algorithm/ranges_move.h"
	- export std_private_algorithm_in_out_result
	-}
	-module std_private_algorithm_ranges_move_backward [system] {
	- header "__algorithm/ranges_move_backward.h"
	- export std_private_algorithm_in_out_result
	-}
	-module std_private_algorithm_ranges_next_permutation [system] {
	- header "__algorithm/ranges_next_permutation.h"
	- export std_private_algorithm_in_found_result
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_none_of [system] { header "__algorithm/ranges_none_of.h" }
	-module std_private_algorithm_ranges_nth_element [system] {
	- header "__algorithm/ranges_nth_element.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_partial_sort [system] {
	- header "__algorithm/ranges_partial_sort.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_partial_sort_copy [system] {
	- header "__algorithm/ranges_partial_sort_copy.h"
	- export std_private_algorithm_in_out_result
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_partition [system] { header "__algorithm/ranges_partition.h" }
	-module std_private_algorithm_ranges_partition_copy [system] { header "__algorithm/ranges_partition_copy.h" }
	-module std_private_algorithm_ranges_partition_point [system] { header "__algorithm/ranges_partition_point.h" }
	-module std_private_algorithm_ranges_pop_heap [system] {
	- header "__algorithm/ranges_pop_heap.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_prev_permutation [system] {
	- header "__algorithm/ranges_prev_permutation.h"
	- export std_private_algorithm_in_found_result
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_push_heap [system] {
	- header "__algorithm/ranges_push_heap.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_remove [system] { header "__algorithm/ranges_remove.h" }
	-module std_private_algorithm_ranges_remove_copy [system] {
	- header "__algorithm/ranges_remove_copy.h"
	- export std_private_algorithm_in_out_result
	-}
	-module std_private_algorithm_ranges_remove_copy_if [system] {
	- header "__algorithm/ranges_remove_copy_if.h"
	- export std_private_algorithm_in_out_result
	-}
	-module std_private_algorithm_ranges_remove_if [system] { header "__algorithm/ranges_remove_if.h" }
	-module std_private_algorithm_ranges_replace [system] { header "__algorithm/ranges_replace.h" }
	-module std_private_algorithm_ranges_replace_copy [system] {
	- header "__algorithm/ranges_replace_copy.h"
	- export std_private_algorithm_in_out_result
	-}
	-module std_private_algorithm_ranges_replace_copy_if [system] {
	- header "__algorithm/ranges_replace_copy_if.h"
	- export std_private_algorithm_in_out_result
	-}
	-module std_private_algorithm_ranges_replace_if [system] { header "__algorithm/ranges_replace_if.h" }
	-module std_private_algorithm_ranges_reverse [system] { header "__algorithm/ranges_reverse.h" }
	-module std_private_algorithm_ranges_reverse_copy [system] {
	- header "__algorithm/ranges_reverse_copy.h"
	- export std_private_algorithm_in_out_result
	-}
	-module std_private_algorithm_ranges_rotate [system] { header "__algorithm/ranges_rotate.h" }
	-module std_private_algorithm_ranges_rotate_copy [system] {
	- header "__algorithm/ranges_rotate_copy.h"
	- export std_private_algorithm_in_out_result
	-}
	-module std_private_algorithm_ranges_sample [system] { header "__algorithm/ranges_sample.h" }
	-module std_private_algorithm_ranges_search [system] { header "__algorithm/ranges_search.h" }
	-module std_private_algorithm_ranges_search_n [system] { header "__algorithm/ranges_search_n.h" }
	-module std_private_algorithm_ranges_set_difference [system] {
	- header "__algorithm/ranges_set_difference.h"
	- export std_private_algorithm_in_out_result
	-}
	-module std_private_algorithm_ranges_set_intersection [system] {
	- header "__algorithm/ranges_set_intersection.h"
	- export std_private_algorithm_in_in_out_result
	-}
	-module std_private_algorithm_ranges_set_symmetric_difference [system] {
	- header "__algorithm/ranges_set_symmetric_difference.h"
	- export std_private_algorithm_in_in_out_result
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_set_union [system] {
	- header "__algorithm/ranges_set_union.h"
	- export std_private_algorithm_in_in_out_result
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_shuffle [system] { header "__algorithm/ranges_shuffle.h" }
	-module std_private_algorithm_ranges_sort [system] {
	- header "__algorithm/ranges_sort.h"
	- export std_private_algorithm_make_projected
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_sort_heap [system] {
	- header "__algorithm/ranges_sort_heap.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_stable_partition [system] { header "__algorithm/ranges_stable_partition.h" }
	-module std_private_algorithm_ranges_stable_sort [system] {
	- header "__algorithm/ranges_stable_sort.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_ranges_starts_with [system] { header "__algorithm/ranges_starts_with.h" }
	-module std_private_algorithm_ranges_swap_ranges [system] {
	- header "__algorithm/ranges_swap_ranges.h"
	- export std_private_algorithm_in_in_result
	-}
	-module std_private_algorithm_ranges_transform [system] {
	- header "__algorithm/ranges_transform.h"
	- export std_private_algorithm_in_in_out_result
	- export std_private_algorithm_in_out_result
	-}
	-module std_private_algorithm_ranges_unique [system] { header "__algorithm/ranges_unique.h" }
	-module std_private_algorithm_ranges_unique_copy [system] {
	- header "__algorithm/ranges_unique_copy.h"
	- export std_private_algorithm_in_out_result
	-}
	-module std_private_algorithm_ranges_upper_bound [system] {
	- header "__algorithm/ranges_upper_bound.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_algorithm_remove [system] { header "__algorithm/remove.h" }
	-module std_private_algorithm_remove_copy [system] { header "__algorithm/remove_copy.h" }
	-module std_private_algorithm_remove_copy_if [system] { header "__algorithm/remove_copy_if.h" }
	-module std_private_algorithm_remove_if [system] { header "__algorithm/remove_if.h" }
	-module std_private_algorithm_replace [system] { header "__algorithm/replace.h" }
	-module std_private_algorithm_replace_copy [system] { header "__algorithm/replace_copy.h" }
	-module std_private_algorithm_replace_copy_if [system] { header "__algorithm/replace_copy_if.h" }
	-module std_private_algorithm_replace_if [system] { header "__algorithm/replace_if.h" }
	-module std_private_algorithm_reverse [system] { header "__algorithm/reverse.h" }
	-module std_private_algorithm_reverse_copy [system] { header "__algorithm/reverse_copy.h" }
	-module std_private_algorithm_rotate [system] { header "__algorithm/rotate.h" }
	-module std_private_algorithm_rotate_copy [system] { header "__algorithm/rotate_copy.h" }
	-module std_private_algorithm_sample [system] { header "__algorithm/sample.h" }
	-module std_private_algorithm_search [system] { header "__algorithm/search.h" }
	-module std_private_algorithm_search_n [system] { header "__algorithm/search_n.h" }
	-module std_private_algorithm_set_difference [system] { header "__algorithm/set_difference.h" }
	-module std_private_algorithm_set_intersection [system] { header "__algorithm/set_intersection.h" }
	-module std_private_algorithm_set_symmetric_difference [system] { header "__algorithm/set_symmetric_difference.h" }
	-module std_private_algorithm_set_union [system] { header "__algorithm/set_union.h" }
	-module std_private_algorithm_shift_left [system] { header "__algorithm/shift_left.h" }
	-module std_private_algorithm_shift_right [system] { header "__algorithm/shift_right.h" }
	-module std_private_algorithm_shuffle [system] { header "__algorithm/shuffle.h" }
	-module std_private_algorithm_sift_down [system] { header "__algorithm/sift_down.h" }
	-module std_private_algorithm_sort [system] {
	- header "__algorithm/sort.h"
	- export std_private_debug_utils_strict_weak_ordering_check
	-}
	-module std_private_algorithm_simd_utils [system] { header "__algorithm/simd_utils.h" }
	-module std_private_algorithm_sort_heap [system] { header "__algorithm/sort_heap.h" }
	-module std_private_algorithm_stable_partition [system] { header "__algorithm/stable_partition.h" }
	-module std_private_algorithm_stable_sort [system] { header "__algorithm/stable_sort.h" }
	-module std_private_algorithm_swap_ranges [system] {
	- header "__algorithm/swap_ranges.h"
	- export std_private_algorithm_iterator_operations
	-}
	-module std_private_algorithm_three_way_comp_ref_type [system] { header "__algorithm/three_way_comp_ref_type.h" }
	-module std_private_algorithm_transform [system] { header "__algorithm/transform.h" }
	-module std_private_algorithm_uniform_random_bit_generator_adaptor [system] { header "__algorithm/uniform_random_bit_generator_adaptor.h" }
	-module std_private_algorithm_unique [system] { header "__algorithm/unique.h" }
	-module std_private_algorithm_unique_copy [system] { header "__algorithm/unique_copy.h" }
	-module std_private_algorithm_unwrap_iter [system] {
	- header "__algorithm/unwrap_iter.h"
	- export std_private_iterator_iterator_traits
	-}
	-module std_private_algorithm_unwrap_range [system] {
	- header "__algorithm/unwrap_range.h"
	- export std_private_utility_pair
	-}
	-module std_private_algorithm_upper_bound [system] { header "__algorithm/upper_bound.h" }
	-
	-module std_private_array_array_fwd [system] { header "__fwd/array.h" }
	-
	-module std_private_atomic_aliases [system] {
	- header "__atomic/aliases.h"
	- export std_private_atomic_atomic
	-}
	-module std_private_atomic_atomic [system] {
	- header "__atomic/atomic.h"
	- export std_private_atomic_atomic_base
	-}
	-module std_private_atomic_atomic_base [system] { header "__atomic/atomic_base.h" }
	-module std_private_atomic_atomic_flag [system] {
	- header "__atomic/atomic_flag.h"
	- export *
	-}
	-module std_private_atomic_atomic_init [system] { header "__atomic/atomic_init.h" }
	-module std_private_atomic_atomic_lock_free [system] { header "__atomic/atomic_lock_free.h" }
	-module std_private_atomic_atomic_ref [system] { header "__atomic/atomic_ref.h" }
	-module std_private_atomic_atomic_sync [system] {
	- header "__atomic/atomic_sync.h"
	- export std_private_atomic_to_gcc_order
	-}
	-module std_private_atomic_check_memory_order [system] { header "__atomic/check_memory_order.h" }
	-module std_private_atomic_contention_t [system] { header "__atomic/contention_t.h" }
	-module std_private_atomic_cxx_atomic_impl [system] { header "__atomic/cxx_atomic_impl.h" }
	-module std_private_atomic_fence [system] { header "__atomic/fence.h" }
	-module std_private_atomic_is_always_lock_free [system] { header "__atomic/is_always_lock_free.h" }
	-module std_private_atomic_kill_dependency [system] { header "__atomic/kill_dependency.h" }
	-module std_private_atomic_memory_order [system] { header "__atomic/memory_order.h" }
	-module std_private_atomic_to_gcc_order [system] {
	- header "__atomic/to_gcc_order.h"
	- export std_private_atomic_memory_order
	-}
	-
	-module std_private_bit_bit_cast [system] { header "__bit/bit_cast.h" }
	-module std_private_bit_bit_ceil [system] { header "__bit/bit_ceil.h" }
	-module std_private_bit_bit_floor [system] { header "__bit/bit_floor.h" }
	-module std_private_bit_bit_log2 [system] { header "__bit/bit_log2.h" }
	-module std_private_bit_bit_width [system] { header "__bit/bit_width.h" }
	-module std_private_bit_blsr [system] { header "__bit/blsr.h" }
	-module std_private_bit_byteswap [system] { header "__bit/byteswap.h" }
	-module std_private_bit_countl [system] { header "__bit/countl.h" }
	-module std_private_bit_countr [system] { header "__bit/countr.h" }
	-module std_private_bit_endian [system] { header "__bit/endian.h" }
	-module std_private_bit_has_single_bit [system] { header "__bit/has_single_bit.h" }
	-module std_private_bit_invert_if [system] { header "__bit/invert_if.h" }
	-module std_private_bit_popcount [system] { header "__bit/popcount.h" }
	-module std_private_bit_rotate [system] { header "__bit/rotate.h" }
	-
	-module std_private_charconv_chars_format [system] { header "__charconv/chars_format.h" }
	-module std_private_charconv_from_chars_integral [system] { header "__charconv/from_chars_integral.h" }
	-module std_private_charconv_from_chars_result [system] { header "__charconv/from_chars_result.h" }
	-module std_private_charconv_tables [system] { header "__charconv/tables.h" }
	-module std_private_charconv_to_chars [system] { header "__charconv/to_chars.h" }
	-module std_private_charconv_to_chars_base_10 [system] { header "__charconv/to_chars_base_10.h" }
	-module std_private_charconv_to_chars_floating_point [system] { header "__charconv/to_chars_floating_point.h" }
	-module std_private_charconv_to_chars_integral [system] {
	- header "__charconv/to_chars_integral.h"
	- export std_private_charconv_traits
	-}
	-module std_private_charconv_to_chars_result [system] {
	- header "__charconv/to_chars_result.h"
	- export *
	-}
	-module std_private_charconv_traits [system] { header "__charconv/traits.h" }
	-
	-module std_private_chrono_calendar [system] { header "__chrono/calendar.h" }
	-module std_private_chrono_concepts [system] { header "__chrono/concepts.h" }
	-module std_private_chrono_convert_to_timespec [system] { header "__chrono/convert_to_timespec.h" }
	-module std_private_chrono_convert_to_tm [system] { header "__chrono/convert_to_tm.h" }
	-module std_private_chrono_day [system] { header "__chrono/day.h" }
	-module std_private_chrono_duration [system] {
	- header "__chrono/duration.h"
	- export std_private_type_traits_is_convertible
	-}
	-module std_private_chrono_exception [system] { header "__chrono/exception.h" }
	-module std_private_chrono_file_clock [system] { header "__chrono/file_clock.h" }
	-module std_private_chrono_formatter [system] {
	- header "__chrono/formatter.h"
	-}
	-module std_private_chrono_hh_mm_ss [system] { header "__chrono/hh_mm_ss.h" }
	-module std_private_chrono_high_resolution_clock [system] {
	- header "__chrono/high_resolution_clock.h"
	- export std_private_chrono_steady_clock
	- export std_private_chrono_system_clock
	-}
	-module std_private_chrono_leap_second [system] { header "__chrono/leap_second.h" }
	-module std_private_chrono_literals [system] { header "__chrono/literals.h" }
	-module std_private_chrono_local_info [system] {
	- header "__chrono/local_info.h"
	- export std_private_chrono_sys_info
	-}
	-module std_private_chrono_month [system] { header "__chrono/month.h" }
	-module std_private_chrono_month_weekday [system] { header "__chrono/month_weekday.h" }
	-module std_private_chrono_monthday [system] { header "__chrono/monthday.h" }
	-module std_private_chrono_ostream [system] {
	- header "__chrono/ostream.h"
	-}
	-module std_private_chrono_parser_std_format_spec [system] {
	- header "__chrono/parser_std_format_spec.h"
	-}
	-module std_private_chrono_statically_widen [system] { header "__chrono/statically_widen.h" }
	-module std_private_chrono_steady_clock [system] {
	- header "__chrono/steady_clock.h"
	- export std_private_chrono_time_point
	-}
	-module std_private_chrono_time_zone [system] {
	- header "__chrono/time_zone.h"
	- export std_private_memory_unique_ptr
	-}
	-module std_private_chrono_time_zone_link [system] {
	- header "__chrono/time_zone_link.h"
	-}
	-module std_private_chrono_sys_info [system] {
	- header "__chrono/sys_info.h"
	-}
	-module std_private_chrono_system_clock [system] {
	- header "__chrono/system_clock.h"
	- export std_private_chrono_time_point
	-}
	-module std_private_chrono_tzdb [system] {
	- header "__chrono/tzdb.h"
	- export *
	-}
	-module std_private_chrono_tzdb_list [system] {
	- header "__chrono/tzdb_list.h"
	- export *
	-}
	-module std_private_chrono_time_point [system] { header "__chrono/time_point.h" }
	-module std_private_chrono_weekday [system] { header "__chrono/weekday.h" }
	-module std_private_chrono_year [system] { header "__chrono/year.h" }
	-module std_private_chrono_year_month [system] { header "__chrono/year_month.h" }
	-module std_private_chrono_year_month_day [system] { header "__chrono/year_month_day.h" }
	-module std_private_chrono_year_month_weekday [system] { header "__chrono/year_month_weekday.h" }
	-module std_private_chrono_zoned_time [system] { header "__chrono/zoned_time.h" }
	-
	-module std_private_compare_common_comparison_category [system] { header "__compare/common_comparison_category.h" }
	-module std_private_compare_compare_partial_order_fallback [system] { header "__compare/compare_partial_order_fallback.h" }
	-module std_private_compare_compare_strong_order_fallback [system] { header "__compare/compare_strong_order_fallback.h" }
	-module std_private_compare_compare_three_way [system] { header "__compare/compare_three_way.h" }
	-module std_private_compare_compare_three_way_result [system] { header "__compare/compare_three_way_result.h" }
	-module std_private_compare_compare_weak_order_fallback [system] { header "__compare/compare_weak_order_fallback.h" }
	-module std_private_compare_is_eq [system] { header "__compare/is_eq.h" }
	-module std_private_compare_ordering [system] { header "__compare/ordering.h" }
	-module std_private_compare_partial_order [system] { header "__compare/partial_order.h" }
	-module std_private_compare_strong_order [system] { header "__compare/strong_order.h" }
	-module std_private_compare_synth_three_way [system] { header "__compare/synth_three_way.h" }
	-module std_private_compare_three_way_comparable [system] { header "__compare/three_way_comparable.h" }
	-module std_private_compare_weak_order [system] { header "__compare/weak_order.h" }
	-
	-module std_private_complex_complex_fwd [system] { header "__fwd/complex.h" }
	-
	-module std_private_concepts_arithmetic [system] { header "__concepts/arithmetic.h" }
	-module std_private_concepts_assignable [system] { header "__concepts/assignable.h" }
	-module std_private_concepts_boolean_testable [system] { header "__concepts/boolean_testable.h" }
	-module std_private_concepts_class_or_enum [system] { header "__concepts/class_or_enum.h" }
	-module std_private_concepts_common_reference_with [system] { header "__concepts/common_reference_with.h" }
	-module std_private_concepts_common_with [system] { header "__concepts/common_with.h" }
	-module std_private_concepts_constructible [system] {
	- header "__concepts/constructible.h"
	- export std_private_concepts_destructible
	-}
	-module std_private_concepts_convertible_to [system] { header "__concepts/convertible_to.h" }
	-module std_private_concepts_copyable [system] { header "__concepts/copyable.h" }
	-module std_private_concepts_derived_from [system] { header "__concepts/derived_from.h" }
	-module std_private_concepts_destructible [system] {
	- header "__concepts/destructible.h"
	- export std_private_type_traits_is_nothrow_destructible
	-}
	-module std_private_concepts_different_from [system] { header "__concepts/different_from.h" }
	-module std_private_concepts_equality_comparable [system] {
	- header "__concepts/equality_comparable.h"
	- export std_private_type_traits_common_reference
	-}
	-module std_private_concepts_invocable [system] { header "__concepts/invocable.h" }
	-module std_private_concepts_movable [system] {
	- header "__concepts/movable.h"
	- export std_private_type_traits_is_object
	-}
	-module std_private_concepts_predicate [system] { header "__concepts/predicate.h" }
	-module std_private_concepts_regular [system] { header "__concepts/regular.h" }
	-module std_private_concepts_relation [system] { header "__concepts/relation.h" }
	-module std_private_concepts_same_as [system] {
	- header "__concepts/same_as.h"
	- export std_private_type_traits_is_same
	-}
	-module std_private_concepts_semiregular [system] { header "__concepts/semiregular.h" }
	-module std_private_concepts_swappable [system] { header "__concepts/swappable.h" }
	-module std_private_concepts_totally_ordered [system] { header "__concepts/totally_ordered.h" }
	-
	-module std_private_condition_variable_condition_variable [system] {
	- header "__condition_variable/condition_variable.h"
	- export *
	-}
	-
	-module std_private_coroutine_coroutine_handle [system] { header "__coroutine/coroutine_handle.h" }
	-module std_private_coroutine_coroutine_traits [system] { header "__coroutine/coroutine_traits.h" }
	-module std_private_coroutine_noop_coroutine_handle [system] { header "__coroutine/noop_coroutine_handle.h" }
	-module std_private_coroutine_trivial_awaitables [system] { header "__coroutine/trivial_awaitables.h" }
	-
	-module std_private_debug_utils_randomize_range [system] { header "__debug_utils/randomize_range.h" }
	-module std_private_debug_utils_sanitizers [system] { header "__debug_utils/sanitizers.h" }
	-module std_private_debug_utils_strict_weak_ordering_check [system] {
	- header "__debug_utils/strict_weak_ordering_check.h"
	- export std_private_type_traits_is_constant_evaluated
	-}
	-
	-module std_private_deque_fwd [system] { header "__fwd/deque.h" }
	-
	-module std_private_exception_exception [system] { header "__exception/exception.h" }
	-module std_private_exception_exception_ptr [system] {
	- header "__exception/exception_ptr.h"
	- export std_private_exception_operations
	-}
	-module std_private_exception_nested_exception [system] { header "__exception/nested_exception.h" }
	-module std_private_exception_operations [system] { header "__exception/operations.h" }
	-module std_private_exception_terminate [system] { header "__exception/terminate.h" }
	-
	-module std_private_expected_bad_expected_access [system] { header "__expected/bad_expected_access.h" }
	-module std_private_expected_expected [system] { header "__expected/expected.h" }
	-module std_private_expected_unexpect [system] { header "__expected/unexpect.h" }
	-module std_private_expected_unexpected [system] { header "__expected/unexpected.h" }
	-
	-module std_private_filesystem_copy_options [system] { header "__filesystem/copy_options.h" }
	-module std_private_filesystem_directory_entry [system] {
	- header "__filesystem/directory_entry.h"
	- export *
	-}
	-module std_private_filesystem_directory_iterator [system] {
	- header "__filesystem/directory_iterator.h"
	- export *
	-}
	-module std_private_filesystem_directory_options [system] { header "__filesystem/directory_options.h" }
	-module std_private_filesystem_file_status [system] { header "__filesystem/file_status.h" }
	-module std_private_filesystem_file_time_type [system] { header "__filesystem/file_time_type.h" }
	-module std_private_filesystem_file_type [system] { header "__filesystem/file_type.h" }
	-module std_private_filesystem_filesystem_error [system] {
	- header "__filesystem/filesystem_error.h"
	- export *
	-}
	-module std_private_filesystem_operations [system] { header "__filesystem/operations.h" }
	-module std_private_filesystem_path [system] {
	- header "__filesystem/path.h"
	- export *
	-}
	-module std_private_filesystem_path_iterator [system] { header "__filesystem/path_iterator.h" }
	-module std_private_filesystem_perm_options [system] { header "__filesystem/perm_options.h" }
	-module std_private_filesystem_perms [system] { header "__filesystem/perms.h" }
	-module std_private_filesystem_recursive_directory_iterator [system] {
	- header "__filesystem/recursive_directory_iterator.h"
	- export *
	-}
	-module std_private_filesystem_space_info [system] { header "__filesystem/space_info.h" }
	-module std_private_filesystem_u8path [system] { header "__filesystem/u8path.h" }
	-
	-module std_private_format_buffer [system] { header "__format/buffer.h" }
	-module std_private_format_concepts [system] { header "__format/concepts.h" }
	-module std_private_format_container_adaptor [system] { header "__format/container_adaptor.h" }
	-module std_private_format_enable_insertable [system] { header "__format/enable_insertable.h" }
	-module std_private_format_escaped_output_table [system] { header "__format/escaped_output_table.h" }
	-module std_private_format_extended_grapheme_cluster_table [system] { header "__format/extended_grapheme_cluster_table.h" }
	-module std_private_format_format_arg [system] { header "__format/format_arg.h" }
	-module std_private_format_format_arg_store [system] { header "__format/format_arg_store.h" }
	-module std_private_format_format_args [system] { header "__format/format_args.h" }
	-module std_private_format_format_context [system] {
	- header "__format/format_context.h"
	- export *
	-}
	-module std_private_format_format_error [system] { header "__format/format_error.h" }
	-module std_private_format_format_functions [system] {
	- header "__format/format_functions.h"
	- export std_string
	-}
	-module std_private_format_fwd [system] { header "__fwd/format.h" }
	-module std_private_format_format_parse_context [system] { header "__format/format_parse_context.h" }
	-module std_private_format_format_string [system] { header "__format/format_string.h" }
	-module std_private_format_format_to_n_result [system] {
	- header "__format/format_to_n_result.h"
	- export std_private_iterator_incrementable_traits
	-}
	-module std_private_format_formatter [system] { header "__format/formatter.h" }
	-module std_private_format_formatter_bool [system] { header "__format/formatter_bool.h" }
	-module std_private_format_formatter_char [system] { header "__format/formatter_char.h" }
	-module std_private_format_formatter_floating_point [system] { header "__format/formatter_floating_point.h" }
	-module std_private_format_formatter_integer [system] { header "__format/formatter_integer.h" }
	-module std_private_format_formatter_integral [system] { header "__format/formatter_integral.h" }
	-module std_private_format_formatter_output [system] { header "__format/formatter_output.h" }
	-module std_private_format_formatter_pointer [system] { header "__format/formatter_pointer.h" }
	-module std_private_format_formatter_string [system] { header "__format/formatter_string.h" }
	-module std_private_format_formatter_tuple [system] { header "__format/formatter_tuple.h" }
	-module std_private_format_indic_conjunct_break_table [system] { header "__format/indic_conjunct_break_table.h" }
	-module std_private_format_parser_std_format_spec [system] { header "__format/parser_std_format_spec.h" }
	-module std_private_format_range_default_formatter [system] { header "__format/range_default_formatter.h" }
	-module std_private_format_range_formatter [system] { header "__format/range_formatter.h" }
	-module std_private_format_unicode [system] {
	- header "__format/unicode.h"
	- export std_private_format_extended_grapheme_cluster_table
	- export std_private_format_indic_conjunct_break_table
	-}
	-module std_private_format_width_estimation_table [system] { header "__format/width_estimation_table.h" }
	-module std_private_format_write_escaped [system] { header "__format/write_escaped.h" }
	-
	-module std_private_functional_binary_function [system] { header "__functional/binary_function.h" }
	-module std_private_functional_binary_negate [system] { header "__functional/binary_negate.h" }
	-module std_private_functional_bind [system] { header "__functional/bind.h" }
	-module std_private_functional_bind_back [system] { header "__functional/bind_back.h" }
	-module std_private_functional_bind_front [system] { header "__functional/bind_front.h" }
	-module std_private_functional_binder1st [system] { header "__functional/binder1st.h" }
	-module std_private_functional_binder2nd [system] { header "__functional/binder2nd.h" }
	-module std_private_functional_boyer_moore_searcher [system] {
	- header "__functional/boyer_moore_searcher.h"
	- export std_private_memory_shared_ptr
	-}
	-module std_private_functional_compose [system] {
	- header "__functional/compose.h"
	- export std_private_functional_perfect_forward
	-}
	-module std_private_functional_default_searcher [system] { header "__functional/default_searcher.h" }
	-module std_private_functional_function [system] { header "__functional/function.h" }
	-module std_private_functional_hash [system] {
	- header "__functional/hash.h"
	- export std_cstdint
	- export std_private_type_traits_underlying_type
	- export std_private_utility_pair
	-}
	-module std_private_functional_fwd [system] { header "__fwd/functional.h" }
	-module std_private_functional_identity [system] { header "__functional/identity.h" }
	-module std_private_functional_invoke [system] {
	- header "__functional/invoke.h"
	- export *
	-}
	-module std_private_functional_is_transparent [system] { header "__functional/is_transparent.h" }
	-module std_private_functional_mem_fn [system] { header "__functional/mem_fn.h" }
	-module std_private_functional_mem_fun_ref [system] { header "__functional/mem_fun_ref.h" }
	-module std_private_functional_not_fn [system] {
	- header "__functional/not_fn.h"
	- export std_private_functional_perfect_forward
	-}
	-module std_private_functional_operations [system] { header "__functional/operations.h" }
	-module std_private_functional_perfect_forward [system] {
	- header "__functional/perfect_forward.h"
	- export *
	-}
	-module std_private_functional_pointer_to_binary_function [system] { header "__functional/pointer_to_binary_function.h" }
	-module std_private_functional_pointer_to_unary_function [system] { header "__functional/pointer_to_unary_function.h" }
	-module std_private_functional_ranges_operations [system] { header "__functional/ranges_operations.h" }
	-module std_private_functional_reference_wrapper [system] { header "__functional/reference_wrapper.h" }
	-module std_private_functional_unary_function [system] { header "__functional/unary_function.h" }
	-module std_private_functional_unary_negate [system] { header "__functional/unary_negate.h" }
	-module std_private_functional_weak_result_type [system] { header "__functional/weak_result_type.h" }
	-
	-module std_private_ios_fpos [system] { header "__ios/fpos.h" }
	-
	-module std_private_iosfwd_fstream_fwd [system] { header "__fwd/fstream.h" }
	-module std_private_iosfwd_ios_fwd [system] { header "__fwd/ios.h" }
	-module std_private_iosfwd_istream_fwd [system] { header "__fwd/istream.h" }
	-module std_private_iosfwd_ostream_fwd [system] { header "__fwd/ostream.h" }
	-module std_private_iosfwd_sstream_fwd [system] { header "__fwd/sstream.h" }
	-module std_private_iosfwd_streambuf_fwd [system] { header "__fwd/streambuf.h" }
	-
	-module std_private_iterator_access [system] { header "__iterator/access.h" }
	-module std_private_iterator_advance [system] { header "__iterator/advance.h" }
	-module std_private_iterator_aliasing_iterator [system] { header "__iterator/aliasing_iterator.h" }
	-module std_private_iterator_back_insert_iterator [system] { header "__iterator/back_insert_iterator.h" }
	-module std_private_iterator_bounded_iter [system] { header "__iterator/bounded_iter.h" }
	-module std_private_iterator_common_iterator [system] { header "__iterator/common_iterator.h" }
	-module std_private_iterator_concepts [system] {
	- header "__iterator/concepts.h"
	- export std_private_concepts_constructible
	- export std_private_concepts_equality_comparable
	- export std_private_concepts_movable
	- export std_private_type_traits_common_reference
	- export std_private_type_traits_is_reference
	- export std_private_type_traits_remove_cvref
	-}
	-module std_private_iterator_counted_iterator [system] { header "__iterator/counted_iterator.h" }
	-module std_private_iterator_cpp17_iterator_concepts [system] { header "__iterator/cpp17_iterator_concepts.h" }
	-module std_private_iterator_data [system] { header "__iterator/data.h" }
	-module std_private_iterator_default_sentinel [system] { header "__iterator/default_sentinel.h" }
	-module std_private_iterator_distance [system] {
	- header "__iterator/distance.h"
	- export std_private_ranges_size
	-}
	-module std_private_iterator_empty [system] { header "__iterator/empty.h" }
	-module std_private_iterator_erase_if_container [system] { header "__iterator/erase_if_container.h" }
	-module std_private_iterator_front_insert_iterator [system] { header "__iterator/front_insert_iterator.h" }
	-module std_private_iterator_incrementable_traits [system] { header "__iterator/incrementable_traits.h" }
	-module std_private_iterator_indirectly_comparable [system] { header "__iterator/indirectly_comparable.h" }
	-module std_private_iterator_insert_iterator [system] { header "__iterator/insert_iterator.h" }
	-module std_private_iterator_istream_iterator [system] { header "__iterator/istream_iterator.h" }
	-module std_private_iterator_istreambuf_iterator [system] { header "__iterator/istreambuf_iterator.h" }
	-module std_private_iterator_iter_move [system] { header "__iterator/iter_move.h" }
	-module std_private_iterator_iter_swap [system] { header "__iterator/iter_swap.h" }
	-module std_private_iterator_iterator [system] { header "__iterator/iterator.h" }
	-module std_private_iterator_iterator_traits [system] {
	- header "__iterator/iterator_traits.h"
	- export std_private_type_traits_is_primary_template
	-}
	-module std_private_iterator_iterator_with_data [system] { header "__iterator/iterator_with_data.h" }
	-module std_private_iterator_mergeable [system] {
	- header "__iterator/mergeable.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_iterator_move_iterator [system] { header "__iterator/move_iterator.h" }
	-module std_private_iterator_move_sentinel [system] { header "__iterator/move_sentinel.h" }
	-module std_private_iterator_next [system] { header "__iterator/next.h" }
	-module std_private_iterator_ostream_iterator [system] { header "__iterator/ostream_iterator.h" }
	-module std_private_iterator_ostreambuf_iterator [system] {
	- header "__iterator/ostreambuf_iterator.h"
	- export *
	-}
	-module std_private_iterator_permutable [system] { header "__iterator/permutable.h" }
	-module std_private_iterator_prev [system] { header "__iterator/prev.h" }
	-module std_private_iterator_projected [system] { header "__iterator/projected.h" }
	-module std_private_iterator_ranges_iterator_traits [system] { header "__iterator/ranges_iterator_traits.h" }
	-module std_private_iterator_readable_traits [system] { header "__iterator/readable_traits.h" }
	-module std_private_iterator_reverse_access [system] { header "__iterator/reverse_access.h" }
	-module std_private_iterator_reverse_iterator [system] { header "__iterator/reverse_iterator.h" }
	-module std_private_iterator_segmented_iterator [system] { header "__iterator/segmented_iterator.h" }
	-module std_private_iterator_size [system] { header "__iterator/size.h" }
	-module std_private_iterator_sortable [system] {
	- header "__iterator/sortable.h"
	- export std_private_functional_ranges_operations
	-}
	-module std_private_iterator_unreachable_sentinel [system] { header "__iterator/unreachable_sentinel.h" }
	-module std_private_iterator_wrap_iter [system] { header "__iterator/wrap_iter.h" }
	-
	-module std_private_locale_locale_base_api_android [system] { textual header "__locale_dir/locale_base_api/android.h" }
	-module std_private_locale_locale_base_api_bsd_locale_defaults [system] { textual header "__locale_dir/locale_base_api/bsd_locale_defaults.h" }
	-module std_private_locale_locale_base_api_bsd_locale_fallbacks [system] { textual header "__locale_dir/locale_base_api/bsd_locale_fallbacks.h" }
	-module std_private_locale_locale_base_api_fuchsia [system] { textual header "__locale_dir/locale_base_api/fuchsia.h" }
	-module std_private_locale_locale_base_api_ibm [system] { textual header "__locale_dir/locale_base_api/ibm.h" }
	-module std_private_locale_locale_base_api_locale_guard [system] { header "__locale_dir/locale_base_api/locale_guard.h" }
	-module std_private_locale_locale_base_api_musl [system] { textual header "__locale_dir/locale_base_api/musl.h" }
	-module std_private_locale_locale_base_api_newlib [system] { textual header "__locale_dir/locale_base_api/newlib.h" }
	-module std_private_locale_locale_base_api_openbsd [system] { textual header "__locale_dir/locale_base_api/openbsd.h" }
	-module std_private_locale_locale_base_api_win32 [system] { textual header "__locale_dir/locale_base_api/win32.h" }
	-module std_private_locale_locale_base_api [system] {
	- header "__locale_dir/locale_base_api.h"
	- export *
	-}
	-
	-module std_private_math_abs [system] { header "__math/abs.h" }
	-module std_private_math_copysign [system] { header "__math/copysign.h" }
	-module std_private_math_error_functions [system] { header "__math/error_functions.h" }
	-module std_private_math_exponential_functions [system] { header "__math/exponential_functions.h" }
	-module std_private_math_fdim [system] { header "__math/fdim.h" }
	-module std_private_math_fma [system] { header "__math/fma.h" }
	-module std_private_math_gamma [system] { header "__math/gamma.h" }
	-module std_private_math_hyperbolic_functions [system] { header "__math/hyperbolic_functions.h" }
	-module std_private_math_hypot [system] { header "__math/hypot.h" }
	-module std_private_math_inverse_hyperbolic_functions [system] { header "__math/inverse_hyperbolic_functions.h" }
	-module std_private_math_inverse_trigonometric_functions [system] { header "__math/inverse_trigonometric_functions.h" }
	-module std_private_math_logarithms [system] { header "__math/logarithms.h" }
	-module std_private_math_min_max [system] { header "__math/min_max.h" }
	-module std_private_math_modulo [system] { header "__math/modulo.h" }
	-module std_private_math_remainder [system] { header "__math/remainder.h" }
	-module std_private_math_roots [system] { header "__math/roots.h" }
	-module std_private_math_rounding_functions [system] { header "__math/rounding_functions.h" }
	-module std_private_math_special_functions [system] { header "__math/special_functions.h" }
	-module std_private_math_traits [system] { header "__math/traits.h" }
	-module std_private_math_trigonometric_functions [system] { header "__math/trigonometric_functions.h" }
	-
	-module std_private_mdspan_default_accessor [system] { header "__mdspan/default_accessor.h" }
	-module std_private_mdspan_extents [system] {
	- header "__mdspan/extents.h"
	- export *
	-}
	-module std_private_mdspan_layout_left [system] { header "__mdspan/layout_left.h" }
	-module std_private_mdspan_layout_right [system] { header "__mdspan/layout_right.h" }
	-module std_private_mdspan_layout_stride [system] { header "__mdspan/layout_stride.h" }
	-module std_private_mdspan_mdspan [system] { header "__mdspan/mdspan.h" }
	-module std_private_mdspan_mdspan_fwd [system] { header "__fwd/mdspan.h" }
	-
	-module std_private_memory_addressof [system] { header "__memory/addressof.h" }
	-module std_private_memory_align [system] { header "__memory/align.h" }
	-module std_private_memory_aligned_alloc [system] { header "__memory/aligned_alloc.h" }
	-module std_private_memory_allocate_at_least [system] { header "__memory/allocate_at_least.h" }
	-module std_private_memory_allocation_guard [system] { header "__memory/allocation_guard.h" }
	-module std_private_memory_allocator [system] { header "__memory/allocator.h" }
	-module std_private_memory_allocator_arg_t [system] { header "__memory/allocator_arg_t.h" }
	-module std_private_memory_allocator_destructor [system] { header "__memory/allocator_destructor.h" }
	-module std_private_memory_allocator_traits [system] { header "__memory/allocator_traits.h" }
	-module std_private_memory_assume_aligned [system] { header "__memory/assume_aligned.h" }
	-module std_private_memory_auto_ptr [system] { header "__memory/auto_ptr.h" }
	-module std_private_memory_builtin_new_allocator [system] {
	- header "__memory/builtin_new_allocator.h"
	- export *
	-}
	-module std_private_memory_compressed_pair [system] { header "__memory/compressed_pair.h" }
	-module std_private_memory_concepts [system] {
	- header "__memory/concepts.h"
	- export std_private_type_traits_remove_reference
	-}
	-module std_private_memory_construct_at [system] { header "__memory/construct_at.h" }
	-module std_private_memory_destruct_n [system] { header "__memory/destruct_n.h" }
	-module std_private_memory_fwd [system] { header "__fwd/memory.h" }
	-module std_private_memory_inout_ptr [system] { header "__memory/inout_ptr.h" }
	-module std_private_memory_out_ptr [system] { header "__memory/out_ptr.h" }
	-module std_private_memory_pointer_traits [system] { header "__memory/pointer_traits.h" }
	-module std_private_memory_ranges_construct_at [system] { header "__memory/ranges_construct_at.h" }
	-module std_private_memory_ranges_uninitialized_algorithms [system] {
	- header "__memory/ranges_uninitialized_algorithms.h"
	- export std_private_algorithm_in_out_result
	-}
	-module std_private_memory_raw_storage_iterator [system] { header "__memory/raw_storage_iterator.h" }
	-module std_private_memory_shared_ptr [system] {
	- header "__memory/shared_ptr.h"
	- export std_private_memory_uninitialized_algorithms
	-}
	-module std_private_memory_swap_allocator [system] { header "__memory/swap_allocator.h" }
	-module std_private_memory_temp_value [system] { header "__memory/temp_value.h" }
	-module std_private_memory_temporary_buffer [system] {
	- header "__memory/temporary_buffer.h"
	- export std_private_utility_pair
	-}
	-module std_private_memory_uninitialized_algorithms [system] {
	- header "__memory/uninitialized_algorithms.h"
	- export std_private_algorithm_copy
	-}
	-module std_private_memory_unique_ptr [system] {
	- header "__memory/unique_ptr.h"
	- export std_private_type_traits_add_lvalue_reference
	- export std_private_type_traits_is_pointer
	- export std_private_type_traits_type_identity
	-}
	-module std_private_memory_uses_allocator [system] { header "__memory/uses_allocator.h" }
	-module std_private_memory_uses_allocator_construction [system] { header "__memory/uses_allocator_construction.h" }
	-module std_private_memory_voidify [system] { header "__memory/voidify.h" }
	-
	-module std_private_memory_resource_memory_resource [system] { header "__memory_resource/memory_resource.h" }
	-module std_private_memory_resource_memory_resource_fwd [system] { header "__fwd/memory_resource.h" }
	-module std_private_memory_resource_monotonic_buffer_resource [system] { header "__memory_resource/monotonic_buffer_resource.h" }
	-module std_private_memory_resource_polymorphic_allocator [system] { header "__memory_resource/polymorphic_allocator.h" }
	-module std_private_memory_resource_pool_options [system] { header "__memory_resource/pool_options.h" }
	-module std_private_memory_resource_synchronized_pool_resource [system] {
	- header "__memory_resource/synchronized_pool_resource.h"
	- export *
	-}
	-module std_private_memory_resource_unsynchronized_pool_resource [system] { header "__memory_resource/unsynchronized_pool_resource.h" }
	-
	-module std_private_mutex_lock_guard [system] { header "__mutex/lock_guard.h" }
	-module std_private_mutex_mutex [system] { header "__mutex/mutex.h" }
	-module std_private_mutex_once_flag [system] { header "__mutex/once_flag.h" }
	-module std_private_mutex_tag_types [system] { header "__mutex/tag_types.h" }
	-module std_private_mutex_unique_lock [system] { header "__mutex/unique_lock.h" }
	-
	-module std_private_numeric_accumulate [system] { header "__numeric/accumulate.h" }
	-module std_private_numeric_adjacent_difference [system] { header "__numeric/adjacent_difference.h" }
	-module std_private_numeric_exclusive_scan [system] { header "__numeric/exclusive_scan.h" }
	-module std_private_numeric_gcd_lcm [system] { header "__numeric/gcd_lcm.h" }
	-module std_private_numeric_inclusive_scan [system] { header "__numeric/inclusive_scan.h" }
	-module std_private_numeric_inner_product [system] { header "__numeric/inner_product.h" }
	-module std_private_numeric_iota [system] { header "__numeric/iota.h" }
	-module std_private_numeric_midpoint [system] { header "__numeric/midpoint.h" }
	-module std_private_numeric_partial_sum [system] { header "__numeric/partial_sum.h" }
	-module std_private_numeric_pstl [system] {
	- header "__numeric/pstl.h"
	- export *
	-}
	-module std_private_numeric_reduce [system] { header "__numeric/reduce.h" }
	-module std_private_numeric_saturation_arithmetic [system] { header "__numeric/saturation_arithmetic.h" }
	-module std_private_numeric_transform_exclusive_scan [system] { header "__numeric/transform_exclusive_scan.h" }
	-module std_private_numeric_transform_inclusive_scan [system] { header "__numeric/transform_inclusive_scan.h" }
	-module std_private_numeric_transform_reduce [system] { header "__numeric/transform_reduce.h" }
	-
	-module std_private_pstl_backend [system] {
	- header "__pstl/backend.h"
	- export *
	-}
	-module std_private_pstl_backend_fwd [system] {
	- header "__pstl/backend_fwd.h"
	- export *
	-}
	-module std_private_pstl_backends_default [system] {
	- header "__pstl/backends/default.h"
	- export *
	-}
	-module std_private_pstl_backends_libdispatch [system] {
	- header "__pstl/backends/libdispatch.h"
	- export *
	-}
	-module std_private_pstl_backends_serial [system] {
	- header "__pstl/backends/serial.h"
	- export *
	-}
	-module std_private_pstl_backends_std_thread [system] {
	- header "__pstl/backends/std_thread.h"
	- export *
	-}
	-module std_private_pstl_cpu_algos_any_of [system] { header "__pstl/cpu_algos/any_of.h" }
	-module std_private_pstl_cpu_algos_cpu_traits [system] { header "__pstl/cpu_algos/cpu_traits.h" }
	-module std_private_pstl_cpu_algos_fill [system] { header "__pstl/cpu_algos/fill.h" }
	-module std_private_pstl_cpu_algos_find_if [system] { header "__pstl/cpu_algos/find_if.h" }
	-module std_private_pstl_cpu_algos_for_each [system] { header "__pstl/cpu_algos/for_each.h" }
	-module std_private_pstl_cpu_algos_merge [system] { header "__pstl/cpu_algos/merge.h" }
	-module std_private_pstl_cpu_algos_stable_sort [system] { header "__pstl/cpu_algos/stable_sort.h" }
	-module std_private_pstl_cpu_algos_transform [system] { header "__pstl/cpu_algos/transform.h" }
	-module std_private_pstl_cpu_algos_transform_reduce [system] { header "__pstl/cpu_algos/transform_reduce.h" }
	-module std_private_pstl_dispatch [system] { header "__pstl/dispatch.h" }
	-module std_private_pstl_handle_exception [system] { header "__pstl/handle_exception.h" }
	-
	-module std_private_queue_fwd [system] { header "__fwd/queue.h" }
	-
	-module std_private_ostream_basic_ostream [system] {
	- header "__ostream/basic_ostream.h"
	- export std_streambuf
	-}
	-module std_private_ostream_print [system] {
	- header "__ostream/print.h"
	- export std_print
	-}
	-
	-module std_private_random_bernoulli_distribution [system] { header "__random/bernoulli_distribution.h" }
	-module std_private_random_binomial_distribution [system] { header "__random/binomial_distribution.h" }
	-module std_private_random_cauchy_distribution [system] { header "__random/cauchy_distribution.h" }
	-module std_private_random_chi_squared_distribution [system] { header "__random/chi_squared_distribution.h" }
	-module std_private_random_clamp_to_integral [system] { header "__random/clamp_to_integral.h" }
	-module std_private_random_default_random_engine [system] { header "__random/default_random_engine.h" }
	-module std_private_random_discard_block_engine [system] { header "__random/discard_block_engine.h" }
	-module std_private_random_discrete_distribution [system] {
	- header "__random/discrete_distribution.h"
	- export *
	-}
	-module std_private_random_exponential_distribution [system] { header "__random/exponential_distribution.h" }
	-module std_private_random_extreme_value_distribution [system] { header "__random/extreme_value_distribution.h" }
	-module std_private_random_fisher_f_distribution [system] { header "__random/fisher_f_distribution.h" }
	-module std_private_random_gamma_distribution [system] { header "__random/gamma_distribution.h" }
	-module std_private_random_generate_canonical [system] { header "__random/generate_canonical.h" }
	-module std_private_random_geometric_distribution [system] { header "__random/geometric_distribution.h" }
	-module std_private_random_independent_bits_engine [system] { header "__random/independent_bits_engine.h" }
	-module std_private_random_is_seed_sequence [system] { header "__random/is_seed_sequence.h" }
	-module std_private_random_is_valid [system] { header "__random/is_valid.h" }
	-module std_private_random_knuth_b [system] { header "__random/knuth_b.h" }
	-module std_private_random_linear_congruential_engine [system] { header "__random/linear_congruential_engine.h" }
	-module std_private_random_log2 [system] { header "__random/log2.h" }
	-module std_private_random_lognormal_distribution [system] { header "__random/lognormal_distribution.h" }
	-module std_private_random_mersenne_twister_engine [system] { header "__random/mersenne_twister_engine.h" }
	-module std_private_random_negative_binomial_distribution [system] { header "__random/negative_binomial_distribution.h" }
	-module std_private_random_normal_distribution [system] { header "__random/normal_distribution.h" }
	-module std_private_random_piecewise_constant_distribution [system] {
	- header "__random/piecewise_constant_distribution.h"
	- export *
	-}
	-module std_private_random_piecewise_linear_distribution [system] {
	- header "__random/piecewise_linear_distribution.h"
	- export *
	-}
	-module std_private_random_poisson_distribution [system] { header "__random/poisson_distribution.h" }
	-module std_private_random_random_device [system] {
	- header "__random/random_device.h"
	- export *
	-}
	-module std_private_random_ranlux [system] { header "__random/ranlux.h" }
	-module std_private_random_seed_seq [system] {
	- header "__random/seed_seq.h"
	- export *
	-}
	-module std_private_random_shuffle_order_engine [system] { header "__random/shuffle_order_engine.h" }
	-module std_private_random_student_t_distribution [system] { header "__random/student_t_distribution.h" }
	-module std_private_random_subtract_with_carry_engine [system] { header "__random/subtract_with_carry_engine.h" }
	-module std_private_random_uniform_int_distribution [system] { header "__random/uniform_int_distribution.h" }
	-module std_private_random_uniform_random_bit_generator [system] { header "__random/uniform_random_bit_generator.h" }
	-module std_private_random_uniform_real_distribution [system] { header "__random/uniform_real_distribution.h" }
	-module std_private_random_weibull_distribution [system] { header "__random/weibull_distribution.h" }
	-
	-module std_private_ranges_access [system] { header "__ranges/access.h" }
	-module std_private_ranges_all [system] {
	- header "__ranges/all.h"
	- export std_private_functional_compose
	- export std_private_functional_perfect_forward
	- export std_private_ranges_owning_view
	-}
	-module std_private_ranges_as_rvalue_view [system] { header "__ranges/as_rvalue_view.h" }
	-module std_private_ranges_chunk_by_view [system] { header "__ranges/chunk_by_view.h" }
	-module std_private_ranges_common_view [system] { header "__ranges/common_view.h" }
	-module std_private_ranges_concepts [system] {
	- header "__ranges/concepts.h"
	- export std_private_iterator_concepts
	-}
	-module std_private_ranges_container_compatible_range [system] { header "__ranges/container_compatible_range.h" }
	-module std_private_ranges_counted [system] {
	- header "__ranges/counted.h"
	- export std_span
	-}
	-module std_private_ranges_dangling [system] { header "__ranges/dangling.h" }
	-module std_private_ranges_data [system] { header "__ranges/data.h" }
	-module std_private_ranges_drop_view [system] { header "__ranges/drop_view.h" }
	-module std_private_ranges_drop_while_view [system] { header "__ranges/drop_while_view.h" }
	-module std_private_ranges_elements_view [system] { header "__ranges/elements_view.h" }
	-module std_private_ranges_empty [system] { header "__ranges/empty.h" }
	-module std_private_ranges_empty_view [system] { header "__ranges/empty_view.h" }
	-module std_private_ranges_enable_borrowed_range [system] { header "__ranges/enable_borrowed_range.h" }
	-module std_private_ranges_enable_view [system] { header "__ranges/enable_view.h" }
	-module std_private_ranges_filter_view [system] {
	- header "__ranges/filter_view.h"
	- export std_private_ranges_range_adaptor
	-}
	-module std_private_ranges_from_range [system] { header "__ranges/from_range.h" }
	-module std_private_ranges_iota_view [system] { header "__ranges/iota_view.h" }
	-module std_private_ranges_istream_view [system] {
	- header "__ranges/istream_view.h"
	-}
	-module std_private_ranges_join_view [system] {
	- header "__ranges/join_view.h"
	- export std_private_iterator_iterator_with_data
	- export std_private_iterator_segmented_iterator
	-}
	-module std_private_ranges_lazy_split_view [system] {
	- header "__ranges/lazy_split_view.h"
	- export std_private_ranges_non_propagating_cache
	-}
	-module std_private_ranges_movable_box [system] { header "__ranges/movable_box.h" }
	-module std_private_ranges_non_propagating_cache [system] { header "__ranges/non_propagating_cache.h" }
	-module std_private_ranges_owning_view [system] { header "__ranges/owning_view.h" }
	-module std_private_ranges_range_adaptor [system] { header "__ranges/range_adaptor.h" }
	-module std_private_ranges_rbegin [system] { header "__ranges/rbegin.h" }
	-module std_private_ranges_ref_view [system] { header "__ranges/ref_view.h" }
	-module std_private_ranges_rend [system] { header "__ranges/rend.h" }
	-module std_private_ranges_repeat_view [system] { header "__ranges/repeat_view.h" }
	-module std_private_ranges_reverse_view [system] { header "__ranges/reverse_view.h" }
	-module std_private_ranges_single_view [system] { header "__ranges/single_view.h" }
	-module std_private_ranges_size [system] {
	- header "__ranges/size.h"
	- export std_private_type_traits_make_unsigned
	-}
	-module std_private_ranges_split_view [system] { header "__ranges/split_view.h" }
	-module std_private_ranges_subrange [system] {
	- header "__ranges/subrange.h"
	- export std_private_ranges_subrange_fwd
	-}
	-module std_private_ranges_subrange_fwd [system] {
	- header "__fwd/subrange.h"
	- export std_private_iterator_concepts
	-}
	-module std_private_ranges_take_view [system] { header "__ranges/take_view.h" }
	-module std_private_ranges_take_while_view [system] { header "__ranges/take_while_view.h" }
	-module std_private_ranges_to [system] { header "__ranges/to.h" }
	-module std_private_ranges_transform_view [system] {
	- header "__ranges/transform_view.h"
	- export std_private_functional_bind_back
	- export std_private_functional_perfect_forward
	- export std_private_ranges_movable_box
	-}
	-module std_private_ranges_view_interface [system] { header "__ranges/view_interface.h" }
	-module std_private_ranges_views [system] { header "__ranges/views.h" }
	-module std_private_ranges_zip_view [system] {
	- header "__ranges/zip_view.h"
	- export std_private_utility_pair
	-}
	-
	-module std_private_span_span_fwd [system] { header "__fwd/span.h" }
	-
	-module std_private_stack_fwd [system] { header "__fwd/stack.h" }
	-
	-module std_private_stop_token_atomic_unique_lock [system] { header "__stop_token/atomic_unique_lock.h" }
	-module std_private_stop_token_intrusive_list_view [system] { header "__stop_token/intrusive_list_view.h" }
	-module std_private_stop_token_intrusive_shared_ptr [system] { header "__stop_token/intrusive_shared_ptr.h" }
	-module std_private_stop_token_stop_callback [system] { header "__stop_token/stop_callback.h" }
	-module std_private_stop_token_stop_source [system] {
	- header "__stop_token/stop_source.h"
	- export *
	-}
	-module std_private_stop_token_stop_state [system] {
	- header "__stop_token/stop_state.h"
	- export *
	-}
	-module std_private_stop_token_stop_token [system] {
	- header "__stop_token/stop_token.h"
	- export *
	-}
	-
	-module std_private_string_char_traits [system] {
	- header "__string/char_traits.h"
	- export *
	-}
	-module std_private_string_constexpr_c_functions [system] {
	- header "__string/constexpr_c_functions.h"
	- export std_private_type_traits_is_equality_comparable
	-}
	-module std_private_string_extern_template_lists [system] { header "__string/extern_template_lists.h" }
	-module std_private_string_string_fwd [system] { header "__fwd/string.h" }
	-
	-module std_private_string_view_string_view_fwd [system] { header "__fwd/string_view.h" }
	-
	-module std_private_system_error_errc [system] { header "__system_error/errc.h" }
	-module std_private_system_error_error_category [system] { header "__system_error/error_category.h" }
	-module std_private_system_error_error_code [system] {
	- header "__system_error/error_code.h"
	- export std_private_functional_hash
	- export std_private_functional_unary_function
	-}
	-module std_private_system_error_error_condition [system] {
	- header "__system_error/error_condition.h"
	- export std_private_functional_hash
	- export std_private_functional_unary_function
	-}
	-module std_private_system_error_system_error [system] { header "__system_error/system_error.h" }
	-
	-module std_private_thread_formatter [system] { header "__thread/formatter.h" }
	-module std_private_thread_id [system] { header "__thread/id.h" }
	-module std_private_thread_jthread [system] {
	- header "__thread/jthread.h"
	- export *
	-}
	-module std_private_thread_poll_with_backoff [system] { header "__thread/poll_with_backoff.h" }
	-module std_private_thread_support [system] {
	- header "__thread/support.h"
	- export *
	-}
	-module std_private_thread_support_c11 [system] { textual header "__thread/support/c11.h" }
	-module std_private_thread_support_external [system] { textual header "__thread/support/external.h" }
	-module std_private_thread_support_pthread [system] { textual header "__thread/support/pthread.h" }
	-module std_private_thread_support_windows [system] { textual header "__thread/support/windows.h" }
	-module std_private_thread_this_thread [system] { header "__thread/this_thread.h" }
	-module std_private_thread_thread [system] {
	- header "__thread/thread.h"
	- export *
	-}
	-module std_private_thread_timed_backoff_policy [system] { header "__thread/timed_backoff_policy.h" }
	-
	-module std_private_tuple_find_index [system] { header "__tuple/find_index.h" }
	-module std_private_tuple_ignore [system] { header "__tuple/ignore.h" }
	-module std_private_tuple_make_tuple_types [system] { header "__tuple/make_tuple_types.h" }
	-module std_private_tuple_tuple_like_no_subrange [system] {
	- header "__tuple/tuple_like_no_subrange.h"
	-}
	-module std_private_tuple_sfinae_helpers [system] { header "__tuple/sfinae_helpers.h" }
	-module std_private_tuple_tuple_element [system] { header "__tuple/tuple_element.h" }
	-module std_private_tuple_tuple_fwd [system] { header "__fwd/tuple.h" }
	-module std_private_tuple_tuple_indices [system] { header "__tuple/tuple_indices.h" }
	-module std_private_tuple_tuple_like [system] {
	- header "__tuple/tuple_like.h"
	- export *
	-}
	-module std_private_tuple_tuple_like_ext [system] { header "__tuple/tuple_like_ext.h" }
	-module std_private_tuple_tuple_size [system] { header "__tuple/tuple_size.h" }
	-module std_private_tuple_tuple_types [system] { header "__tuple/tuple_types.h" }
	-
	-module std_private_type_traits_add_const [system] { header "__type_traits/add_const.h" }
	-module std_private_type_traits_add_cv [system] { header "__type_traits/add_cv.h" }
	-module std_private_type_traits_add_lvalue_reference [system] {
	- header "__type_traits/add_lvalue_reference.h"
	- export std_private_type_traits_is_referenceable
	-}
	-module std_private_type_traits_add_pointer [system] { header "__type_traits/add_pointer.h" }
	-module std_private_type_traits_add_rvalue_reference [system] { header "__type_traits/add_rvalue_reference.h" }
	-module std_private_type_traits_add_volatile [system] { header "__type_traits/add_volatile.h" }
	-module std_private_type_traits_aligned_storage [system] { header "__type_traits/aligned_storage.h" }
	-module std_private_type_traits_aligned_union [system] { header "__type_traits/aligned_union.h" }
	-module std_private_type_traits_alignment_of [system] { header "__type_traits/alignment_of.h" }
	-module std_private_type_traits_can_extract_key [system] { header "__type_traits/can_extract_key.h" }
	-module std_private_type_traits_common_reference [system] {
	- header "__type_traits/common_reference.h"
	- export std_private_type_traits_remove_cvref
	-}
	-module std_private_type_traits_common_type [system] {
	- header "__type_traits/common_type.h"
	- export std_private_utility_declval
	-}
	-module std_private_type_traits_conditional [system] { header "__type_traits/conditional.h" }
	-module std_private_type_traits_conjunction [system] { header "__type_traits/conjunction.h" }
	-module std_private_type_traits_copy_cv [system] { header "__type_traits/copy_cv.h" }
	-module std_private_type_traits_copy_cvref [system] { header "__type_traits/copy_cvref.h" }
	-module std_private_type_traits_datasizeof [system] { header "__type_traits/datasizeof.h" }
	-module std_private_type_traits_decay [system] {
	- header "__type_traits/decay.h"
	- export std_private_type_traits_add_pointer
	-}
	-module std_private_type_traits_dependent_type [system] { header "__type_traits/dependent_type.h" }
	-module std_private_type_traits_desugars_to [system] { header "__type_traits/desugars_to.h" }
	-module std_private_type_traits_disjunction [system] { header "__type_traits/disjunction.h" }
	-module std_private_type_traits_enable_if [system] { header "__type_traits/enable_if.h" }
	-module std_private_type_traits_extent [system] { header "__type_traits/extent.h" }
	-module std_private_type_traits_has_unique_object_representation [system] { header "__type_traits/has_unique_object_representation.h" }
	-module std_private_type_traits_has_virtual_destructor [system] { header "__type_traits/has_virtual_destructor.h" }
	-module std_private_type_traits_integral_constant [system] { header "__type_traits/integral_constant.h" }
	-module std_private_type_traits_invoke [system] {
	- header "__type_traits/invoke.h"
	- export std_private_type_traits_conditional
	- export std_private_type_traits_decay
	- export std_private_type_traits_decay
	- export std_private_type_traits_enable_if
	- export std_private_type_traits_is_base_of
	- export std_private_type_traits_is_core_convertible
	- export std_private_type_traits_is_reference_wrapper
	- export std_private_type_traits_is_same
	- export std_private_type_traits_is_void
	- export std_private_type_traits_nat
	- export std_private_type_traits_remove_cv
	-}
	-module std_private_type_traits_is_abstract [system] { header "__type_traits/is_abstract.h" }
	-module std_private_type_traits_is_aggregate [system] { header "__type_traits/is_aggregate.h" }
	-module std_private_type_traits_is_allocator [system] { header "__type_traits/is_allocator.h" }
	-module std_private_type_traits_is_always_bitcastable [system] { header "__type_traits/is_always_bitcastable.h" }
	-module std_private_type_traits_is_arithmetic [system] {
	- header "__type_traits/is_arithmetic.h"
	- export std_private_type_traits_integral_constant
	-}
	-module std_private_type_traits_is_array [system] {
	- header "__type_traits/is_array.h"
	- export std_private_type_traits_integral_constant
	-}
	-module std_private_type_traits_is_assignable [system] { header "__type_traits/is_assignable.h" }
	-module std_private_type_traits_is_base_of [system] { header "__type_traits/is_base_of.h" }
	-module std_private_type_traits_is_bounded_array [system] { header "__type_traits/is_bounded_array.h" }
	-module std_private_type_traits_is_callable [system] {
	- header "__type_traits/is_callable.h"
	- export std_private_type_traits_integral_constant
	-}
	-module std_private_type_traits_is_char_like_type [system] { header "__type_traits/is_char_like_type.h" }
	-module std_private_type_traits_is_class [system] { header "__type_traits/is_class.h" }
	-module std_private_type_traits_is_compound [system] { header "__type_traits/is_compound.h" }
	-module std_private_type_traits_is_const [system] { header "__type_traits/is_const.h" }
	-module std_private_type_traits_is_constant_evaluated [system] { header "__type_traits/is_constant_evaluated.h" }
	-module std_private_type_traits_is_constructible [system] { header "__type_traits/is_constructible.h" }
	-module std_private_type_traits_is_convertible [system] {
	- header "__type_traits/is_convertible.h"
	- export std_private_type_traits_is_array
	-}
	-module std_private_type_traits_is_copy_assignable [system] { header "__type_traits/is_copy_assignable.h" }
	-module std_private_type_traits_is_copy_constructible [system] { header "__type_traits/is_copy_constructible.h" }
	-module std_private_type_traits_is_core_convertible [system] {
	- header "__type_traits/is_core_convertible.h"
	- export std_private_type_traits_integral_constant
	-}
	-module std_private_type_traits_is_destructible [system] { header "__type_traits/is_destructible.h" }
	-module std_private_type_traits_is_empty [system] { header "__type_traits/is_empty.h" }
	-module std_private_type_traits_is_enum [system] {
	- header "__type_traits/is_enum.h"
	- export std_private_type_traits_integral_constant
	-}
	-module std_private_type_traits_is_equality_comparable [system] {
	- header "__type_traits/is_equality_comparable.h"
	- export std_private_type_traits_integral_constant
	-}
	-module std_private_type_traits_is_execution_policy [system] {
	- header "__type_traits/is_execution_policy.h"
	- export std_private_type_traits_remove_cvref
	-}
	-module std_private_type_traits_is_final [system] { header "__type_traits/is_final.h" }
	-module std_private_type_traits_is_floating_point [system] { header "__type_traits/is_floating_point.h" }
	-module std_private_type_traits_is_function [system] { header "__type_traits/is_function.h" }
	-module std_private_type_traits_is_fundamental [system] { header "__type_traits/is_fundamental.h" }
	-module std_private_type_traits_is_implicitly_default_constructible [system] {
	- header "__type_traits/is_implicitly_default_constructible.h"
	- export std_private_type_traits_integral_constant
	-}
	-module std_private_type_traits_is_integral [system] { header "__type_traits/is_integral.h" }
	-module std_private_type_traits_is_literal_type [system] { header "__type_traits/is_literal_type.h" }
	-module std_private_type_traits_is_member_pointer [system] { header "__type_traits/is_member_pointer.h" }
	-module std_private_type_traits_is_nothrow_assignable [system] { header "__type_traits/is_nothrow_assignable.h" }
	-module std_private_type_traits_is_nothrow_constructible [system] {
	- header "__type_traits/is_nothrow_constructible.h"
	- export std_private_type_traits_integral_constant
	-}
	-module std_private_type_traits_is_nothrow_convertible [system] { header "__type_traits/is_nothrow_convertible.h" }
	-module std_private_type_traits_is_nothrow_destructible [system] {
	- header "__type_traits/is_nothrow_destructible.h"
	- export std_private_type_traits_is_destructible
	-}
	-module std_private_type_traits_is_null_pointer [system] {
	- header "__type_traits/is_null_pointer.h"
	- export std_cstddef
	-}
	-module std_private_type_traits_is_object [system] {
	- header "__type_traits/is_object.h"
	- export std_private_type_traits_is_scalar
	-}
	-module std_private_type_traits_is_pod [system] { header "__type_traits/is_pod.h" }
	-module std_private_type_traits_is_pointer [system] { header "__type_traits/is_pointer.h" }
	-module std_private_type_traits_is_polymorphic [system] { header "__type_traits/is_polymorphic.h" }
	-module std_private_type_traits_is_primary_template [system] {
	- header "__type_traits/is_primary_template.h"
	- export std_private_type_traits_enable_if
	-}
	-module std_private_type_traits_is_reference [system] { header "__type_traits/is_reference.h" }
	-module std_private_type_traits_is_reference_wrapper [system] { header "__type_traits/is_reference_wrapper.h" }
	-module std_private_type_traits_is_referenceable [system] { header "__type_traits/is_referenceable.h" }
	-module std_private_type_traits_is_same [system] {
	- header "__type_traits/is_same.h"
	- export std_private_type_traits_integral_constant
	-}
	-module std_private_type_traits_is_scalar [system] {
	- header "__type_traits/is_scalar.h"
	- export std_private_type_traits_is_null_pointer
	-}
	-module std_private_type_traits_is_signed [system] { header "__type_traits/is_signed.h" }
	-module std_private_type_traits_is_signed_integer [system] { header "__type_traits/is_signed_integer.h" }
	-module std_private_type_traits_is_specialization [system] { header "__type_traits/is_specialization.h" }
	-module std_private_type_traits_is_standard_layout [system] { header "__type_traits/is_standard_layout.h" }
	-module std_private_type_traits_is_swappable [system] {
	- header "__type_traits/is_swappable.h"
	- export std_private_type_traits_is_move_constructible
	-}
	-module std_private_type_traits_is_trivial [system] { header "__type_traits/is_trivial.h" }
	-module std_private_type_traits_is_trivially_assignable [system] { header "__type_traits/is_trivially_assignable.h" }
	-module std_private_type_traits_is_trivially_constructible [system] { header "__type_traits/is_trivially_constructible.h" }
	-module std_private_type_traits_is_trivially_copyable [system] { header "__type_traits/is_trivially_copyable.h" }
	-module std_private_type_traits_is_trivially_destructible [system] { header "__type_traits/is_trivially_destructible.h" }
	-module std_private_type_traits_is_trivially_lexicographically_comparable [system] { header "__type_traits/is_trivially_lexicographically_comparable.h" }
	-module std_private_type_traits_is_trivially_relocatable [system] { header "__type_traits/is_trivially_relocatable.h" }
	-module std_private_type_traits_is_unbounded_array [system] { header "__type_traits/is_unbounded_array.h" }
	-module std_private_type_traits_is_union [system] { header "__type_traits/is_union.h" }
	-module std_private_type_traits_is_unsigned [system] { header "__type_traits/is_unsigned.h" }
	-module std_private_type_traits_is_unsigned_integer [system] { header "__type_traits/is_unsigned_integer.h" }
	-module std_private_type_traits_is_valid_expansion [system] { header "__type_traits/is_valid_expansion.h" }
	-module std_private_type_traits_is_void [system] {
	- header "__type_traits/is_void.h"
	- export std_private_type_traits_integral_constant
	-}
	-module std_private_type_traits_is_volatile [system] { header "__type_traits/is_volatile.h" }
	-module std_private_type_traits_lazy [system] { header "__type_traits/lazy.h" }
	-module std_private_type_traits_make_32_64_or_128_bit [system] { header "__type_traits/make_32_64_or_128_bit.h" }
	-module std_private_type_traits_make_const_lvalue_ref [system] { header "__type_traits/make_const_lvalue_ref.h" }
	-module std_private_type_traits_make_signed [system] { header "__type_traits/make_signed.h" }
	-module std_private_type_traits_make_unsigned [system] {
	- header "__type_traits/make_unsigned.h"
	- export std_private_type_traits_is_unsigned
	-}
	-module std_private_type_traits_maybe_const [system] { header "__type_traits/maybe_const.h" }
	-module std_private_type_traits_nat [system] { header "__type_traits/nat.h" }
	-module std_private_type_traits_negation [system] { header "__type_traits/negation.h" }
	-module std_private_type_traits_noexcept_move_assign_container [system] { header "__type_traits/noexcept_move_assign_container.h" }
	-module std_private_type_traits_promote [system] { header "__type_traits/promote.h" }
	-module std_private_type_traits_rank [system] { header "__type_traits/rank.h" }
	-module std_private_type_traits_remove_all_extents [system] { header "__type_traits/remove_all_extents.h" }
	-module std_private_type_traits_remove_const [system] { header "__type_traits/remove_const.h" }
	-module std_private_type_traits_remove_const_ref [system] { header "__type_traits/remove_const_ref.h" }
	-module std_private_type_traits_remove_cv [system] {
	- header "__type_traits/remove_cv.h"
	- export std_private_type_traits_remove_const
	- export std_private_type_traits_remove_volatile
	-}
	-module std_private_type_traits_remove_cvref [system] { header "__type_traits/remove_cvref.h" }
	-module std_private_type_traits_remove_extent [system] { header "__type_traits/remove_extent.h" }
	-module std_private_type_traits_remove_pointer [system] { header "__type_traits/remove_pointer.h" }
	-module std_private_type_traits_remove_reference [system] { header "__type_traits/remove_reference.h" }
	-module std_private_type_traits_remove_volatile [system] { header "__type_traits/remove_volatile.h" }
	-module std_private_type_traits_result_of [system] { header "__type_traits/result_of.h" }
	-module std_private_type_traits_strip_signature [system] { header "__type_traits/strip_signature.h" }
	-module std_private_type_traits_type_identity [system] { header "__type_traits/type_identity.h" }
	-module std_private_type_traits_type_list [system] { header "__type_traits/type_list.h" }
	-module std_private_type_traits_underlying_type [system] {
	- header "__type_traits/underlying_type.h"
	- export std_private_type_traits_is_enum
	-}
	-module std_private_type_traits_unwrap_ref [system] { header "__type_traits/unwrap_ref.h" }
	-module std_private_type_traits_void_t [system] { header "__type_traits/void_t.h" }
	-
	-module std_private_utility_as_const [system] { header "__utility/as_const.h" }
	-module std_private_utility_as_lvalue [system] { header "__utility/as_lvalue.h" }
	-module std_private_utility_auto_cast [system] {
	- header "__utility/auto_cast.h"
	- export std_private_type_traits_decay
	-}
	-module std_private_utility_cmp [system] {
	- header "__utility/cmp.h"
	- export std_private_type_traits_make_unsigned
	-}
	-module std_private_utility_convert_to_integral [system] { header "__utility/convert_to_integral.h" }
	-module std_private_utility_declval [system] { header "__utility/declval.h" }
	-module std_private_utility_empty [system] { header "__utility/empty.h" }
	-module std_private_utility_exception_guard [system] { header "__utility/exception_guard.h" }
	-module std_private_utility_exchange [system] { header "__utility/exchange.h" }
	-module std_private_utility_forward [system] { header "__utility/forward.h" }
	-module std_private_utility_forward_like [system] { header "__utility/forward_like.h" }
	-module std_private_utility_in_place [system] { header "__utility/in_place.h" }
	-module std_private_utility_integer_sequence [system] { header "__utility/integer_sequence.h" }
	-module std_private_utility_is_pointer_in_range [system] { header "__utility/is_pointer_in_range.h" }
	-module std_private_utility_is_valid_range [system] { header "__utility/is_valid_range.h" }
	-module std_private_utility_move [system] {
	- header "__utility/move.h"
	- export std_private_type_traits_is_copy_constructible
	- export std_private_type_traits_is_nothrow_move_constructible
	- export std_private_type_traits_remove_reference
	-}
	-module std_private_utility_no_destroy [system] { header "__utility/no_destroy.h" }
	-module std_private_utility_pair [system] {
	- header "__utility/pair.h"
	- export std_private_ranges_subrange_fwd
	- export std_private_tuple_pair_like
	- export std_private_type_traits_is_assignable
	- export std_private_type_traits_is_constructible
	- export std_private_type_traits_is_convertible
	- export std_private_type_traits_is_copy_assignable
	- export std_private_type_traits_is_move_assignable
	- export std_private_type_traits_is_nothrow_copy_constructible
	- export std_private_type_traits_is_nothrow_default_constructible
	- export std_private_type_traits_is_nothrow_move_assignable
	- export std_private_utility_pair_fwd
	-}
	-module std_private_utility_pair_fwd [system] { header "__fwd/pair.h" }
	-module std_private_utility_piecewise_construct [system] { header "__utility/piecewise_construct.h" }
	-module std_private_utility_priority_tag [system] { header "__utility/priority_tag.h" }
	-module std_private_utility_private_constructor_tag [system] { header "__utility/private_constructor_tag.h" }
	-module std_private_utility_rel_ops [system] { header "__utility/rel_ops.h" }
	-module std_private_utility_small_buffer [system] { header "__utility/small_buffer.h" }
	-module std_private_utility_swap [system] {
	- header "__utility/swap.h"
	- export std_private_type_traits_is_swappable
	-}
	-module std_private_utility_to_underlying [system] { header "__utility/to_underlying.h" }
	-module std_private_utility_unreachable [system] { header "__utility/unreachable.h" }
	-
	-module std_private_variant_monostate [system] { header "__variant/monostate.h" }
	-
	-module std_private_vector_fwd [system] { header "__fwd/vector.h" }