diff --git a/cl/_testc/struct/out.go b/cl/_testc/struct/out.go
index 33b2217e..cf1af50c 100644
--- a/cl/_testc/struct/out.go
+++ b/cl/_testc/struct/out.go
@@ -3,21 +3,21 @@ package foo
 import "github.com/goplus/lib/c"
 
 type Foo struct {
-	U      _llcppg_struct_0
+	U      _llcppg_anon_0
 	Shorts FooShorts
 }
 type FooShorts struct {
 	S  int16
 	Us uint16
 }
-type _llcppg_struct_0 struct {
+type _llcppg_anon_0 struct {
 	X c.Float
 	Y c.Float
 }
 type Bar struct {
-	_llcppg_struct_1
+	_llcppg_anon_1
 }
-type _llcppg_struct_1 struct {
+type _llcppg_anon_1 struct {
 	S  int16
 	Us uint16
 }
diff --git a/cl/_testc/union_struct/out.go b/cl/_testc/union_struct/out.go
index 3b9e54fb..677a5bf8 100644
--- a/cl/_testc/union_struct/out.go
+++ b/cl/_testc/union_struct/out.go
@@ -8,19 +8,19 @@ import (
 const XGoPackage = true
 
 type Foo struct {
-	U      _llcppg_union_0
+	U      _llcppg_anon_0
 	Shorts FooShorts
 }
 type FooShorts struct {
 	_xgo_union [1]uint16
 }
-type _llcppg_union_0 struct {
+type _llcppg_anon_0 struct {
 	_xgo_union [1]float32
 }
 type Bar struct {
-	_llcppg_union_1
+	_llcppg_anon_1
 }
-type _llcppg_union_1 struct {
+type _llcppg_anon_1 struct {
 	_xgo_union [1]uint16
 }
 
@@ -30,15 +30,15 @@ func (p *FooShorts) XGof_ref_s() *int16 {
 func (p *FooShorts) XGof_ref_us() *uint16 {
 	return (*uint16)(unsafe.Pointer(p))
 }
-func (p *_llcppg_union_0) XGof_ref_x() *c.Float {
+func (p *_llcppg_anon_0) XGof_ref_x() *c.Float {
 	return (*c.Float)(unsafe.Pointer(p))
 }
-func (p *_llcppg_union_0) XGof_ref_y() *c.Float {
+func (p *_llcppg_anon_0) XGof_ref_y() *c.Float {
 	return (*c.Float)(unsafe.Pointer(p))
 }
-func (p *_llcppg_union_1) XGof_ref_s() *int16 {
+func (p *_llcppg_anon_1) XGof_ref_s() *int16 {
 	return (*int16)(unsafe.Pointer(p))
 }
-func (p *_llcppg_union_1) XGof_ref_us() *uint16 {
+func (p *_llcppg_anon_1) XGof_ref_us() *uint16 {
 	return (*uint16)(unsafe.Pointer(p))
 }
diff --git a/cl/_testcpp/class_struct/out.go b/cl/_testcpp/class_struct/out.go
index 02e8aa42..edf58ea0 100644
--- a/cl/_testcpp/class_struct/out.go
+++ b/cl/_testcpp/class_struct/out.go
@@ -3,31 +3,31 @@ package foo
 import "github.com/goplus/lib/c"
 
 type Foo struct {
-	u      _llcppg_struct_0
+	u      _llcppg_anon_0
 	shorts FooShorts
 }
 type FooShorts struct {
 	S  int16
 	Us uint16
 }
-type _llcppg_struct_0 struct {
+type _llcppg_anon_0 struct {
 	X c.Float
 	Y c.Float
 }
 type Bar struct {
-	_llcppg_struct_1
-	_llcppg_struct_2
-	_llcppg_struct_3
+	_llcppg_anon_1
+	_llcppg_anon_2
+	_llcppg_anon_3
 }
-type _llcppg_struct_1 struct {
+type _llcppg_anon_1 struct {
 	S  int16
 	Us uint16
 }
-type _llcppg_struct_2 struct {
+type _llcppg_anon_2 struct {
 	C  c.Char
 	Uc uint8
 }
-type _llcppg_struct_3 struct {
+type _llcppg_anon_3 struct {
 	X c.Float
 	Y c.Float
 }
diff --git a/cl/class.go b/cl/class.go
index 8624f5ab..7d767e7a 100644
--- a/cl/class.go
+++ b/cl/class.go
@@ -78,36 +78,55 @@ func compileClass(ctx *pkgCtx, scope *classCtx) {
 }
 
 func loadClass(ctx *pkgCtx, cls clang.Cursor, ns string, kind typeTag) {
+	if cls.NumTemplateArguments() > 0 {
+		// TODO(xsw): ignore for now
+		return
+	}
 	origName := nameWithNS(clang.String(cls), ns)
 	if debugCompileDecl {
 		log.Println(tagStrvals[kind] + origName)
 	}
-	clsName := ctx.typeName(origName, true)
-	emitClass(ctx, cls, clsName, kind)
+
+	var clsName string
+	var typDecl, ok = ctx.typdecls[origName]
+	if !ok {
+		clsName = ctx.typeName(origName, true)
+		typDecl = newType(ctx, cls, clsName, kind)
+		ctx.typdecls[origName] = typDecl
+	}
+	if cls.IsCursorDefinition() == 0 {
+		return // declaration only, no definition
+	}
+
+	if clsName == "" {
+		clsName = ctx.typeName(origName, true)
+	}
+	initClassType(ctx, &typDecl, cls, clsName, kind)
 }
 
-func emitClass(ctx *pkgCtx, cls clang.Cursor, clsName string, kind typeTag) *types.Named {
-	pkg := ctx.pkg
-	pkgTypes := pkg.Types
-	typDefs := pkg.NewTypeDefs()
+func newType(ctx *pkgCtx, cls clang.Cursor, clsName string, kind typeTag) (ret typDecl) {
+	ret.defs = ctx.pkg.NewTypeDefs()
+	ret.TypeDecl = ret.defs.NewType(clsName, goNode(ctx, cls))
+	ctx.addType(kind, cls, ret.Type())
+	return
+}
 
+func initClassType(ctx *pkgCtx, typDecl *typDecl, cls clang.Cursor, clsName string, kind typeTag) {
 	// Attach the doc at the TypeDefs (GenDecl) level rather than on the
 	// TypeSpec; see the note in loadTypedef for why a spec-level doc renders as
 	// "type// doc" here.
 	if doc := ctx.docCommentGroup(cls); doc != nil {
-		typDefs.SetComments(doc)
+		typDecl.defs.SetComments(doc)
 	}
 
-	typDecl := typDefs.NewType(clsName, goNode(ctx, cls))
-	typNamed := typDecl.Type()
-	ctx.addType(kind, cls, typNamed)
-
 	scope := &classCtx{
 		decl:      cls,
-		typNamed:  typNamed,
+		typNamed:  typDecl.Type(),
 		overloads: make(map[string]*overloads),
 		inPublic:  kind == tagStruct,
 	}
+	pkg := ctx.pkg
+	pkgTypes := pkg.Types
 	clang.VisitChildren(cls, func(decl, parent clang.Cursor) clang.ChildVisitResult {
 		loadClassMember(ctx, pkgTypes, scope, clsName, decl)
 		return clang.Continue
@@ -133,7 +152,12 @@ func emitClass(ctx *pkgCtx, cls clang.Cursor, clsName string, kind typeTag) *typ
 	ctx.addCompileUnit(func(ctx *pkgCtx) {
 		compileClass(ctx, scope)
 	})
-	return typNamed
+}
+
+func emitClass(ctx *pkgCtx, cls clang.Cursor, clsName string, kind typeTag) *types.Named {
+	typDecl := newType(ctx, cls, clsName, kind)
+	initClassType(ctx, &typDecl, cls, clsName, kind)
+	return typDecl.Type()
 }
 
 func loadClassMember(ctx *pkgCtx, pkg *types.Package, cls *classCtx, clsName string, decl clang.Cursor) {
@@ -168,9 +192,9 @@ func loadClassMember(ctx *pkgCtx, pkg *types.Package, cls *classCtx, clsName str
 		if ft.Kind == lc.Type_Record {
 			if ftd := ft.Declaration(); ftd.IsAnonymous() != 0 {
 				if ftd.Kind == lc.Cursor_UnionDecl {
-					fldType = emitUnion(ctx, ftd, ctx.nextAnonUnionName())
+					fldType = emitUnion(ctx, ftd, ctx.nextAnonName())
 				} else {
-					fldType = emitClass(ctx, ftd, ctx.nextAnonStructName(), ftd.Kind)
+					fldType = emitClass(ctx, ftd, ctx.nextAnonName(), ftd.Kind)
 				}
 				anonymous = true
 			}
@@ -203,7 +227,7 @@ func loadClassMember(ctx *pkgCtx, pkg *types.Package, cls *classCtx, clsName str
 			loadEnum(ctx, decl, clsName)
 		}
 
-	case lc.Cursor_TypedefDecl:
+	case lc.Cursor_TypedefDecl, lc.Cursor_TypeAliasDecl:
 		// A typedef nested in a class acts like one nested in a namespace: it
 		// only affects naming, so it is emitted as a package-level type alias
 		// prefixed by the enclosing class name (the class name acts like a
@@ -225,7 +249,7 @@ func loadClassMember(ctx *pkgCtx, pkg *types.Package, cls *classCtx, clsName str
 	case lc.Cursor_ClassDecl, lc.Cursor_StructDecl:
 		switch {
 		case decl.IsAnonymousRecordDecl() != 0:
-			hoisted := emitClass(ctx, decl, ctx.nextAnonStructName(), decl.Kind)
+			hoisted := emitClass(ctx, decl, ctx.nextAnonName(), decl.Kind)
 			fld := types.NewField(goNodePos(ctx, decl), pkg, hoisted.Obj().Name(), hoisted, true)
 			cls.fields = append(cls.fields, fld)
 		case decl.IsAnonymous() != 0:
@@ -244,7 +268,7 @@ func loadClassMember(ctx *pkgCtx, pkg *types.Package, cls *classCtx, clsName str
 	case lc.Cursor_UnionDecl:
 		switch {
 		case decl.IsAnonymousRecordDecl() != 0:
-			hoisted := emitUnion(ctx, decl, ctx.nextAnonUnionName())
+			hoisted := emitUnion(ctx, decl, ctx.nextAnonName())
 			fld := types.NewField(goNodePos(ctx, decl), pkg, hoisted.Obj().Name(), hoisted, true)
 			cls.fields = append(cls.fields, fld)
 		case decl.IsAnonymous() != 0:
@@ -256,6 +280,9 @@ func loadClassMember(ctx *pkgCtx, pkg *types.Package, cls *classCtx, clsName str
 			loadUnion(ctx, decl, clsName)
 		}
 
+	case lc.Cursor_UnexposedAttr:
+		// noop
+
 	default:
 		log.Panicln("loadClassMember: unknown kind =", decl.Kind)
 	}
diff --git a/cl/compile.go b/cl/compile.go
index ddea8426..fcd5f44e 100644
--- a/cl/compile.go
+++ b/cl/compile.go
@@ -211,6 +211,7 @@ func NewPackage(pkgPath, pkgName string, files []Source, conf *Config) (ret Pack
 	if rename == nil {
 		rename = make(map[string]string)
 	}
+	typdecls := make(map[string]typDecl)
 	ctx := &pkgCtx{
 		overloads: make(map[string]*overloads), pkg: pkg, cb: pkg.CB(),
 		llgo: llgo, fset: pkg.Fset, c: c, lang: conf.Language,
@@ -219,7 +220,7 @@ func NewPackage(pkgPath, pkgName string, files []Source, conf *Config) (ret Pack
 		typeAbbr: conf.TypeAbbr, typePrefix: conf.TypePrefix, fnPrefix: conf.FuncPrefix,
 		enumPrefix: conf.EnumPrefix, macroPrefix: conf.MacroPrefix, varPrefix: conf.VarPrefix,
 		nsIgnores: conf.NSIgnore, typeIgnores: conf.TypeIgnore, rename: rename,
-		classes: conf.Class, nonClasses: conf.NonClass,
+		classes: conf.Class, nonClasses: conf.NonClass, typdecls: typdecls,
 		pkgOf: conf.PackageOf, nameLookup: nameLookup, pubLookup: conf.PubFileLookup,
 		fileBases: make(map[clang.File]int), funcs: make(map[string]*funcObj),
 		macroVals: make(map[string]any), types: make(map[string]typeObj),
@@ -227,6 +228,11 @@ func NewPackage(pkgPath, pkgName string, files []Source, conf *Config) (ret Pack
 	}
 	loadFiles(ctx, files, pkgPath, conf.SourceHeaderFilePrefix, conf.GenMultiGoFiles)
 	ctx.compile()
+	for _, typDecl := range typdecls {
+		if !typDecl.Inited() {
+			typDecl.InitType(pkg, types.NewStruct(nil, nil))
+		}
+	}
 	ret.Package = pkg
 	ret.Wrap = ctx.wrap
 	ret.Public = ctx.pubs
@@ -305,6 +311,8 @@ func loadDecl(ctx *pkgCtx, scope *scopeCtx, decl clang.Cursor, ns string) {
 		// noop
 	case lc.Cursor_FunctionTemplate:
 		// TODO(xsw): ignore for now
+	case lc.Cursor_ClassTemplate, lc.Cursor_ClassTemplatePartialSpecialization:
+		// TODO(xsw): ignore for now
 	default:
 		log.Panicln("compileDecl: unknown kind =", decl.Kind)
 	}
diff --git a/cl/ctx.go b/cl/ctx.go
index b4248287..23455c94 100644
--- a/cl/ctx.go
+++ b/cl/ctx.go
@@ -94,6 +94,11 @@ type typeObj struct {
 	feats int
 }
 
+type typDecl struct {
+	*gogen.TypeDecl
+	defs *gogen.TypeDefs
+}
+
 type pkgCtx struct {
 	scopeCtx
 	pkg  *gogen.Package
@@ -134,39 +139,24 @@ type pkgCtx struct {
 	impPkgs   map[string]none     // imported package path set
 	lastSeen  map[string]none     // last seen include file set (loaded include files)
 	thisSeen  map[string]none     // include file set seen in this translation unit
+	typdecls  map[string]typDecl
 
 	compiles []compileUnit
 	pubs     []Entry
 
-	// anonUnionSeq is the per-package counter that names tagless inline unions
-	// hoisted to a Go type "_llcppg_union_<n>", starting at 0 in source order.
-	// See issue goplus/llcppg#775 (the union proposal's D-series).
-	anonUnionSeq  int
-	anonStructSeq int
+	anonSeq int
 
 	stdRecvName bool
-
-	keepDoc bool
+	keepDoc     bool
 }
 
 const (
-	anonUnionPrefix  = "_llcppg_union_"
-	anonStructPrefix = "_llcppg_struct_"
+	anonPrefix = "_llcppg_anon_"
 )
 
-// nextAnonUnionName returns the next hoisted-union type name
-// "_llcppg_union_<n>", incrementing the per-package counter. A tagless inline
-// union (with or without a field name) is hoisted to such a type; a tagged or
-// named union consumes no number. See issue goplus/llcppg#775.
-func (p *pkgCtx) nextAnonUnionName() string {
-	name := anonUnionPrefix + strconv.Itoa(p.anonUnionSeq)
-	p.anonUnionSeq++
-	return name
-}
-
-func (p *pkgCtx) nextAnonStructName() string {
-	name := anonStructPrefix + strconv.Itoa(p.anonStructSeq)
-	p.anonStructSeq++
+func (p *pkgCtx) nextAnonName() string {
+	name := anonPrefix + strconv.Itoa(p.anonSeq)
+	p.anonSeq++
 	return name
 }
 
diff --git a/cl/type.go b/cl/type.go
index bcafd06f..3fcf01d9 100644
--- a/cl/type.go
+++ b/cl/type.go
@@ -109,6 +109,10 @@ func toTypeEx(ctx *pkgCtx, pkg *types.Package, typ lc.Type, flags int, feats *in
 		// it before recursing so inner arrays are not wrongly decayed.
 		pointee := toTypeEx(ctx, pkg, elem, flagIsTypeDef, feats)
 		return newPointer(pointee)
+	case lc.Type_LValueReference:
+		elem := typ.NonReference()
+		pointee := toTypeEx(ctx, pkg, elem, flagIsTypeDef, feats)
+		return newPointer(pointee)
 	case lc.Type_FunctionProto:
 		*feats |= featHasCallback
 		return toFuncType(ctx, pkg, typ, feats)
diff --git a/cl/typedef.go b/cl/typedef.go
index cefe477d..09d639df 100644
--- a/cl/typedef.go
+++ b/cl/typedef.go
@@ -31,7 +31,7 @@ func loadTypedef(ctx *pkgCtx, decl clang.Cursor, ns string) {
 		if debugCompileDecl {
 			log.Println("typedef", cName, "- ignored")
 		}
-		ctx.types[cName] = typeObj{nil, featIgnored}
+		ctx.types[cName] = typeObj{nil, featIgnored} // ignored
 		return
 	}
 
@@ -46,6 +46,14 @@ func loadTypedef(ctx *pkgCtx, decl clang.Cursor, ns string) {
 
 	feats := 0
 	tunder := toTypeEx(ctx, pkgTypes, underlying, flagIsTypeDef, &feats)
+	if feats&featIgnored != 0 {
+		if debugCompileDecl {
+			log.Println("typedef", cName, "- ignored")
+		}
+		ctx.types[cName] = typeObj{nil, featIgnored} // ignored
+		return
+	}
+
 	name := ctx.typeName(origName, true)
 	if tn, ok := tunder.(*types.Named); ok {
 		if o := tn.Obj(); o.Pkg() == pkgTypes && o.Name() == name {
diff --git a/go.mod b/go.mod
index 80f42ca3..448dca1a 100644
--- a/go.mod
+++ b/go.mod
@@ -3,7 +3,7 @@ module github.com/goplus/llcppg
 go 1.27.0 // llgo 1.0
 
 require (
-	github.com/goplus/gogen v1.24.9
+	github.com/goplus/gogen v1.25.1
 	github.com/goplus/lib v0.5.4
 	github.com/goplus/mod v0.22.1
 	github.com/llarhub/clang-c v0.6.1
diff --git a/go.sum b/go.sum
index 098a74fb..73d3ef6c 100644
--- a/go.sum
+++ b/go.sum
@@ -1,5 +1,5 @@
-github.com/goplus/gogen v1.24.9 h1:IZnQ/ROLE/uqK5Mm4KW/orvAqcsUSKJZ7AtkqPSQJR4=
-github.com/goplus/gogen v1.24.9/go.mod h1:Y7ulYW3wonQ3d9er00b0uGFEV/IUZa6okWJZh892ACQ=
+github.com/goplus/gogen v1.25.1 h1:nxNcYVsEy1aNLtXpG1vq8ZGD9qWMK1roUNMkfQ6H9gs=
+github.com/goplus/gogen v1.25.1/go.mod h1:Y7ulYW3wonQ3d9er00b0uGFEV/IUZa6okWJZh892ACQ=
 github.com/goplus/lib v0.5.4 h1:Ltrj+lY844/jx0nJqCRQEq3YzBkHb3jBjCQZWFUdlTc=
 github.com/goplus/lib v0.5.4/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0=
 github.com/goplus/mod v0.22.1 h1:3GQZqKlcQAiMpRUDAHvFryGYie+mT0JMjguEqOtIjkE=
diff --git a/tool/_testcpp/llvm-22.1.8-support/Atomic/out.go b/tool/_testcpp/llvm-22.1.8-support/Atomic/out.go
index fed987b2..16bc8e53 100644
--- a/tool/_testcpp/llvm-22.1.8-support/Atomic/out.go
+++ b/tool/_testcpp/llvm-22.1.8-support/Atomic/out.go
@@ -9,8 +9,8 @@ const LLGoPackage = "link: -L$(llvm-config --libdir) -lLLVM; -lLLVM"
 
 type SysCasFlag = c.Uint32T
 
-//go:linkname LlvmSysMemoryFence C._ZN4llvm3sys11MemoryFenceEv
-func LlvmSysMemoryFence()
+//go:linkname SysMemoryFence C._ZN4llvm3sys11MemoryFenceEv
+func SysMemoryFence()
 
-//go:linkname LlvmSysCompareAndSwap C._ZN4llvm3sys14CompareAndSwapEPVjjj
-func LlvmSysCompareAndSwap(ptr *SysCasFlag, new_value SysCasFlag, old_value SysCasFlag) SysCasFlag
+//go:linkname SysCompareAndSwap C._ZN4llvm3sys14CompareAndSwapEPVjjj
+func SysCompareAndSwap(ptr *SysCasFlag, new_value SysCasFlag, old_value SysCasFlag) SysCasFlag
diff --git a/tool/_testcpp/llvm-22.1.8-support/Compiler/out.go b/tool/_testcpp/llvm-22.1.8-support/Compiler/out.go
index 2fe39af7..33ce8014 100644
--- a/tool/_testcpp/llvm-22.1.8-support/Compiler/out.go
+++ b/tool/_testcpp/llvm-22.1.8-support/Compiler/out.go
@@ -1,8 +1,8 @@
 package Compiler
 
 const LLGoPackage = "link: -L$(llvm-config --libdir) -lLLVM; -lLLVM"
-const LLVM_MEMORY_SANITIZER_BUILD = 0
-const LLVM_ADDRESS_SANITIZER_BUILD = 0
-const LLVM_HWADDRESS_SANITIZER_BUILD = 0
-const LLVM_THREAD_SANITIZER_BUILD = 0
-const LLVM_ENABLE_EXCEPTIONS = 1
+const MEMORY_SANITIZER_BUILD = 0
+const ADDRESS_SANITIZER_BUILD = 0
+const HWADDRESS_SANITIZER_BUILD = 0
+const THREAD_SANITIZER_BUILD = 0
+const ENABLE_EXCEPTIONS = 1
diff --git a/tool/_testcpp/llvm-22.1.8-support/DenseMapInfo/out.go b/tool/_testcpp/llvm-22.1.8-support/DenseMapInfo/out.go
new file mode 100644
index 00000000..dc04d80c
--- /dev/null
+++ b/tool/_testcpp/llvm-22.1.8-support/DenseMapInfo/out.go
@@ -0,0 +1,3 @@
+package DenseMapInfo
+
+const LLGoPackage = "link: -L$(llvm-config --libdir) -lLLVM; -lLLVM"
diff --git a/tool/_testcpp/llvm-22.1.8-support/STLFunctionalExtras/out.go b/tool/_testcpp/llvm-22.1.8-support/STLFunctionalExtras/out.go
new file mode 100644
index 00000000..9c9d3138
--- /dev/null
+++ b/tool/_testcpp/llvm-22.1.8-support/STLFunctionalExtras/out.go
@@ -0,0 +1,3 @@
+package STLFunctionalExtras
+
+const LLGoPackage = "link: -L$(llvm-config --libdir) -lLLVM; -lLLVM"
diff --git a/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/ADL.h b/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/ADL.h
new file mode 100644
index 00000000..812d9a4b
--- /dev/null
+++ b/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/ADL.h
@@ -0,0 +1,135 @@
+//===- llvm/ADT/ADL.h - Argument dependent lookup utilities -----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_ADL_H
+#define LLVM_ADT_ADL_H
+
+#include <type_traits>
+#include <iterator>
+#include <utility>
+
+namespace llvm {
+
+// Only used by compiler if both template types are the same.  Useful when
+// using SFINAE to test for the existence of member functions.
+template <typename T, T> struct SameType;
+
+namespace adl_detail {
+
+using std::begin;
+
+template <typename RangeT>
+constexpr auto begin_impl(RangeT &&range)
+    -> decltype(begin(std::forward<RangeT>(range))) {
+  return begin(std::forward<RangeT>(range));
+}
+
+using std::end;
+
+template <typename RangeT>
+constexpr auto end_impl(RangeT &&range)
+    -> decltype(end(std::forward<RangeT>(range))) {
+  return end(std::forward<RangeT>(range));
+}
+
+using std::rbegin;
+
+template <typename RangeT>
+constexpr auto rbegin_impl(RangeT &&range)
+    -> decltype(rbegin(std::forward<RangeT>(range))) {
+  return rbegin(std::forward<RangeT>(range));
+}
+
+using std::rend;
+
+template <typename RangeT>
+constexpr auto rend_impl(RangeT &&range)
+    -> decltype(rend(std::forward<RangeT>(range))) {
+  return rend(std::forward<RangeT>(range));
+}
+
+using std::swap;
+
+template <typename T>
+constexpr void swap_impl(T &&lhs,
+                         T &&rhs) noexcept(noexcept(swap(std::declval<T>(),
+                                                         std::declval<T>()))) {
+  swap(std::forward<T>(lhs), std::forward<T>(rhs));
+}
+
+using std::size;
+
+template <typename RangeT>
+constexpr auto size_impl(RangeT &&range)
+    -> decltype(size(std::forward<RangeT>(range))) {
+  return size(std::forward<RangeT>(range));
+}
+
+} // end namespace adl_detail
+
+/// Returns the begin iterator to \p range using `std::begin` and
+/// function found through Argument-Dependent Lookup (ADL).
+template <typename RangeT>
+constexpr auto adl_begin(RangeT &&range)
+    -> decltype(adl_detail::begin_impl(std::forward<RangeT>(range))) {
+  return adl_detail::begin_impl(std::forward<RangeT>(range));
+}
+
+/// Returns the end iterator to \p range using `std::end` and
+/// functions found through Argument-Dependent Lookup (ADL).
+template <typename RangeT>
+constexpr auto adl_end(RangeT &&range)
+    -> decltype(adl_detail::end_impl(std::forward<RangeT>(range))) {
+  return adl_detail::end_impl(std::forward<RangeT>(range));
+}
+
+/// Returns the reverse-begin iterator to \p range using `std::rbegin` and
+/// function found through Argument-Dependent Lookup (ADL).
+template <typename RangeT>
+constexpr auto adl_rbegin(RangeT &&range)
+    -> decltype(adl_detail::rbegin_impl(std::forward<RangeT>(range))) {
+  return adl_detail::rbegin_impl(std::forward<RangeT>(range));
+}
+
+/// Returns the reverse-end iterator to \p range using `std::rend` and
+/// functions found through Argument-Dependent Lookup (ADL).
+template <typename RangeT>
+constexpr auto adl_rend(RangeT &&range)
+    -> decltype(adl_detail::rend_impl(std::forward<RangeT>(range))) {
+  return adl_detail::rend_impl(std::forward<RangeT>(range));
+}
+
+/// Swaps \p lhs with \p rhs using `std::swap` and functions found through
+/// Argument-Dependent Lookup (ADL).
+template <typename T>
+constexpr void adl_swap(T &&lhs, T &&rhs) noexcept(
+    noexcept(adl_detail::swap_impl(std::declval<T>(), std::declval<T>()))) {
+  adl_detail::swap_impl(std::forward<T>(lhs), std::forward<T>(rhs));
+}
+
+/// Returns the size of \p range using `std::size` and functions found through
+/// Argument-Dependent Lookup (ADL).
+template <typename RangeT>
+constexpr auto adl_size(RangeT &&range)
+    -> decltype(adl_detail::size_impl(std::forward<RangeT>(range))) {
+  return adl_detail::size_impl(std::forward<RangeT>(range));
+}
+
+namespace detail {
+
+template <typename RangeT>
+using IterOfRange = decltype(adl_begin(std::declval<RangeT &>()));
+
+template <typename RangeT>
+using ValueOfRange =
+    std::remove_reference_t<decltype(*adl_begin(std::declval<RangeT &>()))>;
+
+} // namespace detail
+} // namespace llvm
+
+#endif // LLVM_ADT_ADL_H
diff --git a/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/DenseMapInfo.h b/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/DenseMapInfo.h
new file mode 100644
index 00000000..f24aeb43
--- /dev/null
+++ b/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/DenseMapInfo.h
@@ -0,0 +1,264 @@
+//===- llvm/ADT/DenseMapInfo.h - Type traits for DenseMap -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines DenseMapInfo traits for DenseMap.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_DENSEMAPINFO_H
+#define LLVM_ADT_DENSEMAPINFO_H
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <optional>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+namespace llvm {
+
+namespace densemap::detail {
+// A bit mixer with very low latency using one multiplications and one
+// xor-shift. The constant is from splitmix64.
+inline uint64_t mix(uint64_t x) {
+  x *= 0xbf58476d1ce4e5b9u;
+  x ^= x >> 31;
+  return x;
+}
+} // namespace densemap::detail
+
+namespace detail {
+
+/// Simplistic combination of 32-bit hash values into 32-bit hash values.
+inline unsigned combineHashValue(unsigned a, unsigned b) {
+  uint64_t x = (uint64_t)a << 32 | (uint64_t)b;
+  return (unsigned)densemap::detail::mix(x);
+}
+
+} // end namespace detail
+
+/// An information struct used to provide DenseMap with the various necessary
+/// components for a given value type `T`. `Enable` is an optional additional
+/// parameter that is used to support SFINAE (generally using std::enable_if_t)
+/// in derived DenseMapInfo specializations; in non-SFINAE use cases this should
+/// just be `void`.
+template<typename T, typename Enable = void>
+struct DenseMapInfo {
+  // static constexpr T getEmptyKey();
+  // static constexpr T getTombstoneKey();
+  // static unsigned getHashValue(const T &Val);
+  // static bool isEqual(const T &LHS, const T &RHS);
+};
+
+// Provide DenseMapInfo for all pointers. Come up with sentinel pointer values
+// that are aligned to alignof(T) bytes, but try to avoid requiring T to be
+// complete. This allows clients to instantiate DenseMap<T*, ...> with forward
+// declared key types. Assume that no pointer key type requires more than 4096
+// bytes of alignment.
+template<typename T>
+struct DenseMapInfo<T*> {
+  // The following should hold, but it would require T to be complete:
+  // static_assert(alignof(T) <= (1 << Log2MaxAlign),
+  //               "DenseMap does not support pointer keys requiring more than "
+  //               "Log2MaxAlign bits of alignment");
+  static constexpr uintptr_t Log2MaxAlign = 12;
+
+  static constexpr T *getEmptyKey() {
+    uintptr_t Val = static_cast<uintptr_t>(-1);
+    Val <<= Log2MaxAlign;
+    return reinterpret_cast<T*>(Val);
+  }
+
+  static constexpr T *getTombstoneKey() {
+    uintptr_t Val = static_cast<uintptr_t>(-2);
+    Val <<= Log2MaxAlign;
+    return reinterpret_cast<T*>(Val);
+  }
+
+  static unsigned getHashValue(const T *PtrVal) {
+    return (unsigned((uintptr_t)PtrVal) >> 4) ^
+           (unsigned((uintptr_t)PtrVal) >> 9);
+  }
+
+  static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
+};
+
+// Provide DenseMapInfo for chars.
+template<> struct DenseMapInfo<char> {
+  static constexpr char getEmptyKey() { return ~0; }
+  static constexpr char getTombstoneKey() { return ~0 - 1; }
+  static unsigned getHashValue(const char& Val) { return Val * 37U; }
+
+  static bool isEqual(const char &LHS, const char &RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for all integral types except char.
+//
+// The "char" case is excluded because it uses ~0 as the empty key despite
+// "char" being a signed type.  "std::is_same_v<T, char>" is included below
+// for clarity; technically, we do not need it because the explicit
+// specialization above "wins",
+template <typename T>
+struct DenseMapInfo<
+    T, std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<T, char>>> {
+  static constexpr T getEmptyKey() { return std::numeric_limits<T>::max(); }
+
+  static constexpr T getTombstoneKey() {
+    if constexpr (std::is_unsigned_v<T> || std::is_same_v<T, long>)
+      return std::numeric_limits<T>::max() - 1;
+    else
+      return std::numeric_limits<T>::min();
+  }
+
+  static unsigned getHashValue(const T &Val) {
+    if constexpr (std::is_unsigned_v<T> && sizeof(T) > sizeof(unsigned))
+      return densemap::detail::mix(Val);
+    else
+      return static_cast<unsigned>(Val *
+                                   static_cast<std::make_unsigned_t<T>>(37U));
+  }
+
+  static bool isEqual(const T &LHS, const T &RHS) { return LHS == RHS; }
+};
+
+// Provide DenseMapInfo for all pairs whose members have info.
+template<typename T, typename U>
+struct DenseMapInfo<std::pair<T, U>> {
+  using Pair = std::pair<T, U>;
+  using FirstInfo = DenseMapInfo<T>;
+  using SecondInfo = DenseMapInfo<U>;
+
+  static constexpr Pair getEmptyKey() {
+    return {FirstInfo::getEmptyKey(), SecondInfo::getEmptyKey()};
+  }
+
+  static constexpr Pair getTombstoneKey() {
+    return {FirstInfo::getTombstoneKey(), SecondInfo::getTombstoneKey()};
+  }
+
+  static unsigned getHashValue(const Pair& PairVal) {
+    return detail::combineHashValue(FirstInfo::getHashValue(PairVal.first),
+                                    SecondInfo::getHashValue(PairVal.second));
+  }
+
+  // Expose an additional function intended to be used by other
+  // specializations of DenseMapInfo without needing to know how
+  // to combine hash values manually
+  static unsigned getHashValuePiecewise(const T &First, const U &Second) {
+    return detail::combineHashValue(FirstInfo::getHashValue(First),
+                                    SecondInfo::getHashValue(Second));
+  }
+
+  static bool isEqual(const Pair &LHS, const Pair &RHS) {
+    return FirstInfo::isEqual(LHS.first, RHS.first) &&
+           SecondInfo::isEqual(LHS.second, RHS.second);
+  }
+};
+
+// Provide DenseMapInfo for all tuples whose members have info.
+template <typename... Ts> struct DenseMapInfo<std::tuple<Ts...>> {
+  using Tuple = std::tuple<Ts...>;
+
+  static constexpr Tuple getEmptyKey() {
+    return Tuple(DenseMapInfo<Ts>::getEmptyKey()...);
+  }
+
+  static constexpr Tuple getTombstoneKey() {
+    return Tuple(DenseMapInfo<Ts>::getTombstoneKey()...);
+  }
+
+  template <unsigned I> static unsigned getHashValueImpl(const Tuple &values) {
+    if constexpr (I == sizeof...(Ts)) {
+      return 0;
+    } else {
+      using EltType = std::tuple_element_t<I, Tuple>;
+      return detail::combineHashValue(
+          DenseMapInfo<EltType>::getHashValue(std::get<I>(values)),
+          getHashValueImpl<I + 1>(values));
+    }
+  }
+
+  static unsigned getHashValue(const std::tuple<Ts...> &values) {
+    return getHashValueImpl<0>(values);
+  }
+
+  template <std::size_t... Is>
+  static bool isEqualImpl(const Tuple &lhs, const Tuple &rhs,
+                          std::index_sequence<Is...>) {
+    return (DenseMapInfo<std::tuple_element_t<Is, Tuple>>::isEqual(
+                std::get<Is>(lhs), std::get<Is>(rhs)) &&
+            ...);
+  }
+
+  static bool isEqual(const Tuple &lhs, const Tuple &rhs) {
+    return isEqualImpl(lhs, rhs, std::index_sequence_for<Ts...>{});
+  }
+};
+
+// Provide DenseMapInfo for enum classes.
+template <typename Enum>
+struct DenseMapInfo<Enum, std::enable_if_t<std::is_enum_v<Enum>>> {
+  using UnderlyingType = std::underlying_type_t<Enum>;
+  using Info = DenseMapInfo<UnderlyingType>;
+
+  // If an enum does not have a "fixed" underlying type, it may be UB to cast
+  // some values of the underlying type to the enum. We use an "extra" constexpr
+  // local to ensure that such UB would trigger "static assertion expression is
+  // not an integral constant expression", rather than runtime UB.
+  //
+  // If you hit this error, you can fix by switching to `enum class`, or adding
+  // an explicit underlying type (e.g. `enum X : int`) to the enum's definition.
+
+  static constexpr Enum getEmptyKey() {
+    constexpr Enum V = static_cast<Enum>(Info::getEmptyKey());
+    return V;
+  }
+
+  static constexpr Enum getTombstoneKey() {
+    constexpr Enum V = static_cast<Enum>(Info::getTombstoneKey());
+    return V;
+  }
+
+  static unsigned getHashValue(const Enum &Val) {
+    return Info::getHashValue(static_cast<UnderlyingType>(Val));
+  }
+
+  static bool isEqual(const Enum &LHS, const Enum &RHS) { return LHS == RHS; }
+};
+
+template <typename T> struct DenseMapInfo<std::optional<T>> {
+  using Optional = std::optional<T>;
+  using Info = DenseMapInfo<T>;
+
+  static constexpr Optional getEmptyKey() { return {Info::getEmptyKey()}; }
+
+  static constexpr Optional getTombstoneKey() {
+    return {Info::getTombstoneKey()};
+  }
+
+  static unsigned getHashValue(const Optional &OptionalVal) {
+    return detail::combineHashValue(
+        OptionalVal.has_value(),
+        Info::getHashValue(OptionalVal.value_or(Info::getEmptyKey())));
+  }
+
+  static bool isEqual(const Optional &LHS, const Optional &RHS) {
+    if (LHS && RHS) {
+      return Info::isEqual(LHS.value(), RHS.value());
+    }
+    return !LHS && !RHS;
+  }
+};
+} // end namespace llvm
+
+#endif // LLVM_ADT_DENSEMAPINFO_H
diff --git a/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/STLForwardCompat.h b/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/STLForwardCompat.h
new file mode 100644
index 00000000..b975a403
--- /dev/null
+++ b/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/STLForwardCompat.h
@@ -0,0 +1,180 @@
+//===- STLForwardCompat.h - Library features from future STLs ------C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains library features backported from future STL versions.
+///
+/// These should be replaced with their STL counterparts as the C++ version LLVM
+/// is compiled with is updated.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_STLFORWARDCOMPAT_H
+#define LLVM_ADT_STLFORWARDCOMPAT_H
+
+#include <optional>
+#include <type_traits>
+#include <utility>
+
+namespace llvm {
+
+//===----------------------------------------------------------------------===//
+//     Features from C++20
+//===----------------------------------------------------------------------===//
+
+namespace numbers {
+// clang-format off
+template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
+inline constexpr T e_v          = T(0x1.5bf0a8b145769P+1); // (2.7182818284590452354) https://oeis.org/A001113
+template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
+inline constexpr T egamma_v     = T(0x1.2788cfc6fb619P-1); // (.57721566490153286061) https://oeis.org/A001620
+template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
+inline constexpr T ln2_v        = T(0x1.62e42fefa39efP-1); // (.69314718055994530942) https://oeis.org/A002162
+template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
+inline constexpr T ln10_v       = T(0x1.26bb1bbb55516P+1); // (2.3025850929940456840) https://oeis.org/A002392
+template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
+inline constexpr T log2e_v      = T(0x1.71547652b82feP+0); // (1.4426950408889634074)
+template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
+inline constexpr T log10e_v     = T(0x1.bcb7b1526e50eP-2); // (.43429448190325182765)
+template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
+inline constexpr T pi_v         = T(0x1.921fb54442d18P+1); // (3.1415926535897932385) https://oeis.org/A000796
+template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
+inline constexpr T inv_pi_v     = T(0x1.45f306dc9c883P-2); // (.31830988618379067154) https://oeis.org/A049541
+template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
+inline constexpr T inv_sqrtpi_v = T(0x1.20dd750429b6dP-1); // (.56418958354775628695) https://oeis.org/A087197
+template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
+inline constexpr T sqrt2_v      = T(0x1.6a09e667f3bcdP+0); // (1.4142135623730950488) https://oeis.org/A00219
+template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
+inline constexpr T inv_sqrt2_v  = T(0x1.6a09e667f3bcdP-1); // (.70710678118654752440)
+template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
+inline constexpr T sqrt3_v      = T(0x1.bb67ae8584caaP+0); // (1.7320508075688772935) https://oeis.org/A002194
+template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
+inline constexpr T inv_sqrt3_v  = T(0x1.279a74590331cP-1); // (.57735026918962576451)
+template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
+inline constexpr T phi_v        = T(0x1.9e3779b97f4a8P+0); // (1.6180339887498948482) https://oeis.org/A001622
+
+inline constexpr double e          = e_v<double>;
+inline constexpr double egamma     = egamma_v<double>;
+inline constexpr double ln2        = ln2_v<double>;
+inline constexpr double ln10       = ln10_v<double>;
+inline constexpr double log2e      = log2e_v<double>;
+inline constexpr double log10e     = log10e_v<double>;
+inline constexpr double pi         = pi_v<double>;
+inline constexpr double inv_pi     = inv_pi_v<double>;
+inline constexpr double inv_sqrtpi = inv_sqrtpi_v<double>;
+inline constexpr double sqrt2      = sqrt2_v<double>;
+inline constexpr double inv_sqrt2  = inv_sqrt2_v<double>;
+inline constexpr double sqrt3      = sqrt3_v<double>;
+inline constexpr double inv_sqrt3  = inv_sqrt3_v<double>;
+inline constexpr double phi        = phi_v<double>;
+// clang-format on
+} // namespace numbers
+
+template <typename T>
+struct remove_cvref // NOLINT(readability-identifier-naming)
+{
+  using type = std::remove_cv_t<std::remove_reference_t<T>>;
+};
+
+template <typename T>
+using remove_cvref_t // NOLINT(readability-identifier-naming)
+    = typename llvm::remove_cvref<T>::type;
+
+// TODO: Remove this in favor of std::type_identity<T> once we switch to C++20.
+template <typename T>
+struct type_identity // NOLINT(readability-identifier-naming)
+{
+  using type = T;
+};
+
+// TODO: Remove this in favor of std::type_identity_t<T> once we switch to
+// C++20.
+template <typename T>
+using type_identity_t // NOLINT(readability-identifier-naming)
+    = typename llvm::type_identity<T>::type;
+
+namespace detail {
+template <class, template <class...> class Op, class... Args> struct detector {
+  using value_t = std::false_type;
+};
+template <template <class...> class Op, class... Args>
+struct detector<std::void_t<Op<Args...>>, Op, Args...> {
+  using value_t = std::true_type;
+};
+} // end namespace detail
+
+/// Detects if a given trait holds for some set of arguments 'Args'.
+/// For example, the given trait could be used to detect if a given type
+/// has a copy assignment operator:
+///   template<class T>
+///   using has_copy_assign_t = decltype(std::declval<T&>()
+///                                                 = std::declval<const T&>());
+///   bool fooHasCopyAssign = is_detected<has_copy_assign_t, FooClass>::value;
+///
+/// NOTE: The C++20 standard has adopted concepts and requires clauses as a
+/// superior alternative to std::is_detected.
+///
+/// This utility is placed in STLForwardCompat.h as a reminder
+/// to migrate usages of llvm::is_detected to concepts and 'requires'
+/// clauses when the codebase adopts C++20.
+template <template <class...> class Op, class... Args>
+using is_detected = typename detail::detector<void, Op, Args...>::value_t;
+
+struct identity // NOLINT(readability-identifier-naming)
+{
+  using is_transparent = void;
+
+  template <typename T> constexpr T &&operator()(T &&self) const noexcept {
+    return std::forward<T>(self);
+  }
+};
+
+/// Returns a raw pointer that represents the same address as the argument.
+///
+/// This implementation can be removed once we move to C++20 where it's defined
+/// as std::to_address().
+///
+/// The std::pointer_traits<>::to_address(p) variations of these overloads has
+/// not been implemented.
+template <class Ptr> auto to_address(const Ptr &P) { return P.operator->(); }
+template <class T> constexpr T *to_address(T *P) {
+  static_assert(!std::is_function_v<T>);
+  return P;
+}
+
+//===----------------------------------------------------------------------===//
+//     Features from C++23
+//===----------------------------------------------------------------------===//
+
+// TODO: Remove this in favor of std::optional<T>::transform once we switch to
+// C++23.
+template <typename Optional, typename Function,
+          typename Value = typename llvm::remove_cvref_t<Optional>::value_type>
+std::optional<std::invoke_result_t<Function, Value>>
+transformOptional(Optional &&O, Function &&F) {
+  if (O) {
+    return F(*std::forward<Optional>(O));
+  }
+  return std::nullopt;
+}
+
+/// Returns underlying integer value of an enum. Backport of C++23
+/// std::to_underlying.
+template <typename Enum>
+[[nodiscard]] constexpr std::underlying_type_t<Enum> to_underlying(Enum E) {
+  return static_cast<std::underlying_type_t<Enum>>(E);
+}
+
+// A tag for constructors accepting ranges.
+struct from_range_t {
+  explicit from_range_t() = default;
+};
+inline constexpr from_range_t from_range{};
+} // namespace llvm
+
+#endif // LLVM_ADT_STLFORWARDCOMPAT_H
diff --git a/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/STLFunctionalExtras.h b/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/STLFunctionalExtras.h
new file mode 100644
index 00000000..a4d50dc3
--- /dev/null
+++ b/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/STLFunctionalExtras.h
@@ -0,0 +1,81 @@
+//===- llvm/ADT/STLFunctionalExtras.h - Extras for <functional> -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains some extension to <functional>.
+//
+// No library is required when using these functions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_STLFUNCTIONALEXTRAS_H
+#define LLVM_ADT_STLFUNCTIONALEXTRAS_H
+
+#include "llvm/ADT/STLForwardCompat.h"
+#include "llvm/Support/Compiler.h"
+
+#include <cstdint>
+#include <type_traits>
+#include <utility>
+
+namespace llvm {
+
+//===----------------------------------------------------------------------===//
+//     Extra additions to <functional>
+//===----------------------------------------------------------------------===//
+
+/// An efficient, type-erasing, non-owning reference to a callable. This is
+/// intended for use as the type of a function parameter that is not used
+/// after the function in question returns.
+///
+/// This class does not own the callable, so it is not in general safe to store
+/// a function_ref.
+template<typename Fn> class function_ref;
+
+template <typename Ret, typename... Params>
+class LLVM_GSL_POINTER function_ref<Ret(Params...)> {
+  Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
+  intptr_t callable;
+
+  template<typename Callable>
+  static Ret callback_fn(intptr_t callable, Params ...params) {
+    return (*reinterpret_cast<Callable*>(callable))(
+        std::forward<Params>(params)...);
+  }
+
+public:
+  function_ref() = default;
+  function_ref(std::nullptr_t) {}
+
+  template <typename Callable>
+  function_ref(
+      Callable &&callable LLVM_LIFETIME_BOUND,
+      // This is not the copy-constructor.
+      std::enable_if_t<!std::is_same<remove_cvref_t<Callable>,
+                                     function_ref>::value> * = nullptr,
+      // Functor must be callable and return a suitable type.
+      std::enable_if_t<std::is_void<Ret>::value ||
+                       std::is_convertible<decltype(std::declval<Callable>()(
+                                               std::declval<Params>()...)),
+                                           Ret>::value> * = nullptr)
+      : callback(callback_fn<std::remove_reference_t<Callable>>),
+        callable(reinterpret_cast<intptr_t>(&callable)) {}
+
+  Ret operator()(Params ...params) const {
+    return callback(callable, std::forward<Params>(params)...);
+  }
+
+  explicit operator bool() const { return callback; }
+
+  bool operator==(const function_ref<Ret(Params...)> &Other) const {
+    return callable == Other.callable;
+  }
+};
+
+} // end namespace llvm
+
+#endif // LLVM_ADT_STLFUNCTIONALEXTRAS_H
diff --git a/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/StringRef.h b/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/StringRef.h
new file mode 100644
index 00000000..09c6d6d6
--- /dev/null
+++ b/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/StringRef.h
@@ -0,0 +1,952 @@
+//===- StringRef.h - Constant String Reference Wrapper ----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_STRINGREF_H
+#define LLVM_ADT_STRINGREF_H
+
+#include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/ADT/STLFunctionalExtras.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/Support/Compiler.h"
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstring>
+#include <iterator>
+#include <limits>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+namespace llvm {
+
+  class APInt;
+  class hash_code;
+  template <typename T> class SmallVectorImpl;
+  class StringRef;
+
+  /// Helper functions for StringRef::getAsInteger.
+  LLVM_ABI bool getAsUnsignedInteger(StringRef Str, unsigned Radix,
+                                     unsigned long long &Result);
+
+  LLVM_ABI bool getAsSignedInteger(StringRef Str, unsigned Radix,
+                                   long long &Result);
+
+  LLVM_ABI unsigned getAutoSenseRadix(StringRef &Str);
+
+  LLVM_ABI bool consumeUnsignedInteger(StringRef &Str, unsigned Radix,
+                                       unsigned long long &Result);
+  LLVM_ABI bool consumeSignedInteger(StringRef &Str, unsigned Radix,
+                                     long long &Result);
+
+  /// StringRef - Represent a constant reference to a string, i.e. a character
+  /// array and a length, which need not be null terminated.
+  ///
+  /// This class does not own the string data, it is expected to be used in
+  /// situations where the character data resides in some other buffer, whose
+  /// lifetime extends past that of the StringRef. For this reason, it is not in
+  /// general safe to store a StringRef.
+  class LLVM_GSL_POINTER StringRef {
+  public:
+    static constexpr size_t npos = ~size_t(0);
+
+    using iterator = const char *;
+    using const_iterator = const char *;
+    using size_type = size_t;
+    using value_type = char;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+  private:
+    /// The start of the string, in an external buffer.
+    const char *Data = nullptr;
+
+    /// The length of the string.
+    size_t Length = 0;
+
+    // Workaround memcmp issue with null pointers (undefined behavior)
+    // by providing a specialized version
+    static int compareMemory(const char *Lhs, const char *Rhs, size_t Length) {
+      if (Length == 0) { return 0; }
+      return ::memcmp(Lhs,Rhs,Length);
+    }
+
+  public:
+    /// @name Constructors
+    /// @{
+
+    /// Construct an empty string ref.
+    /*implicit*/ StringRef() = default;
+
+    /// Disable conversion from nullptr.  This prevents things like
+    /// if (S == nullptr)
+    StringRef(std::nullptr_t) = delete;
+
+    /// Construct a string ref from a cstring.
+    /*implicit*/ constexpr StringRef(const char *Str LLVM_LIFETIME_BOUND)
+        : StringRef(Str ? std::string_view(Str) : std::string_view()) {}
+
+    /// Construct a string ref from a pointer and length.
+    /*implicit*/ constexpr StringRef(const char *data LLVM_LIFETIME_BOUND,
+                                     size_t length)
+        : Data(data), Length(length) {}
+
+    /// Construct a string ref from an std::string.
+    /*implicit*/ StringRef(const std::string &Str)
+        : Data(Str.data()), Length(Str.length()) {}
+
+    /// Construct a string ref from an std::string_view.
+    /*implicit*/ constexpr StringRef(std::string_view Str)
+        : Data(Str.data()), Length(Str.size()) {}
+
+    /// @}
+    /// @name Iterators
+    /// @{
+
+    iterator begin() const { return data(); }
+
+    iterator end() const { return data() + size(); }
+
+    reverse_iterator rbegin() const {
+      return std::make_reverse_iterator(end());
+    }
+
+    reverse_iterator rend() const {
+      return std::make_reverse_iterator(begin());
+    }
+
+    const unsigned char *bytes_begin() const {
+      return reinterpret_cast<const unsigned char *>(begin());
+    }
+    const unsigned char *bytes_end() const {
+      return reinterpret_cast<const unsigned char *>(end());
+    }
+    iterator_range<const unsigned char *> bytes() const {
+      return make_range(bytes_begin(), bytes_end());
+    }
+
+    /// @}
+    /// @name String Operations
+    /// @{
+
+    /// data - Get a pointer to the start of the string (which may not be null
+    /// terminated).
+    [[nodiscard]] constexpr const char *data() const { return Data; }
+
+    /// empty - Check if the string is empty.
+    [[nodiscard]] constexpr bool empty() const { return size() == 0; }
+
+    /// size - Get the string size.
+    [[nodiscard]] constexpr size_t size() const { return Length; }
+
+    /// front - Get the first character in the string.
+    [[nodiscard]] char front() const {
+      assert(!empty());
+      return data()[0];
+    }
+
+    /// back - Get the last character in the string.
+    [[nodiscard]] char back() const {
+      assert(!empty());
+      return data()[size() - 1];
+    }
+
+    // copy - Allocate copy in Allocator and return StringRef to it.
+    template <typename Allocator>
+    [[nodiscard]] StringRef copy(Allocator &A) const {
+      // Don't request a length 0 copy from the allocator.
+      if (empty())
+        return StringRef();
+      char *S = A.template Allocate<char>(size());
+      std::copy(begin(), end(), S);
+      return StringRef(S, size());
+    }
+
+    /// Check for string equality, ignoring case.
+    [[nodiscard]] bool equals_insensitive(StringRef RHS) const {
+      return size() == RHS.size() && compare_insensitive(RHS) == 0;
+    }
+
+    /// compare - Compare two strings; the result is negative, zero, or positive
+    /// if this string is lexicographically less than, equal to, or greater than
+    /// the \p RHS.
+    [[nodiscard]] int compare(StringRef RHS) const {
+      // Check the prefix for a mismatch.
+      if (int Res =
+              compareMemory(data(), RHS.data(), std::min(size(), RHS.size())))
+        return Res < 0 ? -1 : 1;
+
+      // Otherwise the prefixes match, so we only need to check the lengths.
+      if (size() == RHS.size())
+        return 0;
+      return size() < RHS.size() ? -1 : 1;
+    }
+
+    /// Compare two strings, ignoring case.
+    [[nodiscard]] LLVM_ABI int compare_insensitive(StringRef RHS) const;
+
+    /// compare_numeric - Compare two strings, treating sequences of digits as
+    /// numbers.
+    [[nodiscard]] LLVM_ABI int compare_numeric(StringRef RHS) const;
+
+    /// Determine the edit distance between this string and another
+    /// string.
+    ///
+    /// \param Other the string to compare this string against.
+    ///
+    /// \param AllowReplacements whether to allow character
+    /// replacements (change one character into another) as a single
+    /// operation, rather than as two operations (an insertion and a
+    /// removal).
+    ///
+    /// \param MaxEditDistance If non-zero, the maximum edit distance that
+    /// this routine is allowed to compute. If the edit distance will exceed
+    /// that maximum, returns \c MaxEditDistance+1.
+    ///
+    /// \returns the minimum number of character insertions, removals,
+    /// or (if \p AllowReplacements is \c true) replacements needed to
+    /// transform one of the given strings into the other. If zero,
+    /// the strings are identical.
+    [[nodiscard]] LLVM_ABI unsigned
+    edit_distance(StringRef Other, bool AllowReplacements = true,
+                  unsigned MaxEditDistance = 0) const;
+
+    [[nodiscard]] LLVM_ABI unsigned
+    edit_distance_insensitive(StringRef Other, bool AllowReplacements = true,
+                              unsigned MaxEditDistance = 0) const;
+
+    /// str - Get the contents as an std::string.
+    [[nodiscard]] std::string str() const {
+      if (!data())
+        return std::string();
+      return std::string(data(), size());
+    }
+
+    /// @}
+    /// @name Operator Overloads
+    /// @{
+
+    [[nodiscard]] char operator[](size_t Index) const {
+      assert(Index < size() && "Invalid index!");
+      return data()[Index];
+    }
+
+    /// Disallow accidental assignment from a temporary std::string.
+    ///
+    /// The declaration here is extra complicated so that `stringRef = {}`
+    /// and `stringRef = "abc"` continue to select the move assignment operator.
+    template <typename T>
+    std::enable_if_t<std::is_same<T, std::string>::value, StringRef> &
+    operator=(T &&Str) = delete;
+
+    /// @}
+    /// @name Type Conversions
+    /// @{
+
+    constexpr operator std::string_view() const {
+      return std::string_view(data(), size());
+    }
+
+    /// @}
+    /// @name String Predicates
+    /// @{
+
+    /// Check if this string starts with the given \p Prefix.
+    [[nodiscard]] bool starts_with(StringRef Prefix) const {
+      return size() >= Prefix.size() &&
+             compareMemory(data(), Prefix.data(), Prefix.size()) == 0;
+    }
+    [[nodiscard]] bool starts_with(char Prefix) const {
+      return !empty() && front() == Prefix;
+    }
+
+    /// Check if this string starts with the given \p Prefix, ignoring case.
+    [[nodiscard]] LLVM_ABI bool starts_with_insensitive(StringRef Prefix) const;
+
+    /// Check if this string ends with the given \p Suffix.
+    [[nodiscard]] bool ends_with(StringRef Suffix) const {
+      return size() >= Suffix.size() &&
+             compareMemory(end() - Suffix.size(), Suffix.data(),
+                           Suffix.size()) == 0;
+    }
+    [[nodiscard]] bool ends_with(char Suffix) const {
+      return !empty() && back() == Suffix;
+    }
+
+    /// Check if this string ends with the given \p Suffix, ignoring case.
+    [[nodiscard]] LLVM_ABI bool ends_with_insensitive(StringRef Suffix) const;
+
+    /// @}
+    /// @name String Searching
+    /// @{
+
+    /// Search for the first character \p C in the string.
+    ///
+    /// \returns The index of the first occurrence of \p C, or npos if not
+    /// found.
+    [[nodiscard]] size_t find(char C, size_t From = 0) const {
+      return std::string_view(*this).find(C, From);
+    }
+
+    /// Search for the first character \p C in the string, ignoring case.
+    ///
+    /// \returns The index of the first occurrence of \p C, or npos if not
+    /// found.
+    [[nodiscard]] LLVM_ABI size_t find_insensitive(char C,
+                                                   size_t From = 0) const;
+
+    /// Search for the first character satisfying the predicate \p F
+    ///
+    /// \returns The index of the first character satisfying \p F starting from
+    /// \p From, or npos if not found.
+    [[nodiscard]] size_t find_if(function_ref<bool(char)> F,
+                                 size_t From = 0) const {
+      StringRef S = drop_front(From);
+      while (!S.empty()) {
+        if (F(S.front()))
+          return size() - S.size();
+        S = S.drop_front();
+      }
+      return npos;
+    }
+
+    /// Search for the first character not satisfying the predicate \p F
+    ///
+    /// \returns The index of the first character not satisfying \p F starting
+    /// from \p From, or npos if not found.
+    [[nodiscard]] size_t find_if_not(function_ref<bool(char)> F,
+                                     size_t From = 0) const {
+      return find_if([F](char c) { return !F(c); }, From);
+    }
+
+    /// Search for the first string \p Str in the string.
+    ///
+    /// \returns The index of the first occurrence of \p Str, or npos if not
+    /// found.
+    [[nodiscard]] LLVM_ABI size_t find(StringRef Str, size_t From = 0) const;
+
+    /// Search for the first string \p Str in the string, ignoring case.
+    ///
+    /// \returns The index of the first occurrence of \p Str, or npos if not
+    /// found.
+    [[nodiscard]] LLVM_ABI size_t find_insensitive(StringRef Str,
+                                                   size_t From = 0) const;
+
+    /// Search for the last character \p C in the string.
+    ///
+    /// \returns The index of the last occurrence of \p C, or npos if not
+    /// found.
+    [[nodiscard]] size_t rfind(char C, size_t From = npos) const {
+      size_t I = std::min(From, size());
+      while (I) {
+        --I;
+        if (data()[I] == C)
+          return I;
+      }
+      return npos;
+    }
+
+    /// Search for the last character \p C in the string, ignoring case.
+    ///
+    /// \returns The index of the last occurrence of \p C, or npos if not
+    /// found.
+    [[nodiscard]] LLVM_ABI size_t rfind_insensitive(char C,
+                                                    size_t From = npos) const;
+
+    /// Search for the last string \p Str in the string.
+    ///
+    /// \returns The index of the last occurrence of \p Str, or npos if not
+    /// found.
+    [[nodiscard]] LLVM_ABI size_t rfind(StringRef Str) const;
+
+    /// Search for the last string \p Str in the string, ignoring case.
+    ///
+    /// \returns The index of the last occurrence of \p Str, or npos if not
+    /// found.
+    [[nodiscard]] LLVM_ABI size_t rfind_insensitive(StringRef Str) const;
+
+    /// Find the first character in the string that is \p C, or npos if not
+    /// found. Same as find.
+    [[nodiscard]] size_t find_first_of(char C, size_t From = 0) const {
+      return find(C, From);
+    }
+
+    /// Find the first character in the string that is in \p Chars, or npos if
+    /// not found.
+    ///
+    /// Complexity: O(size() + Chars.size())
+    [[nodiscard]] LLVM_ABI size_t find_first_of(StringRef Chars,
+                                                size_t From = 0) const;
+
+    /// Find the first character in the string that is not \p C or npos if not
+    /// found.
+    [[nodiscard]] LLVM_ABI size_t find_first_not_of(char C,
+                                                    size_t From = 0) const;
+
+    /// Find the first character in the string that is not in the string
+    /// \p Chars, or npos if not found.
+    ///
+    /// Complexity: O(size() + Chars.size())
+    [[nodiscard]] LLVM_ABI size_t find_first_not_of(StringRef Chars,
+                                                    size_t From = 0) const;
+
+    /// Find the last character in the string that is \p C, or npos if not
+    /// found.
+    [[nodiscard]] size_t find_last_of(char C, size_t From = npos) const {
+      return rfind(C, From);
+    }
+
+    /// Find the last character in the string that is in \p C, or npos if not
+    /// found.
+    ///
+    /// Complexity: O(size() + Chars.size())
+    [[nodiscard]] LLVM_ABI size_t find_last_of(StringRef Chars,
+                                               size_t From = npos) const;
+
+    /// Find the last character in the string that is not \p C, or npos if not
+    /// found.
+    [[nodiscard]] LLVM_ABI size_t find_last_not_of(char C,
+                                                   size_t From = npos) const;
+
+    /// Find the last character in the string that is not in \p Chars, or
+    /// npos if not found.
+    ///
+    /// Complexity: O(size() + Chars.size())
+    [[nodiscard]] LLVM_ABI size_t find_last_not_of(StringRef Chars,
+                                                   size_t From = npos) const;
+
+    /// Return true if the given string is a substring of *this, and false
+    /// otherwise.
+    [[nodiscard]] bool contains(StringRef Other) const {
+      return find(Other) != npos;
+    }
+
+    /// Return true if the given character is contained in *this, and false
+    /// otherwise.
+    [[nodiscard]] bool contains(char C) const {
+      return find_first_of(C) != npos;
+    }
+
+    /// Return true if the given string is a substring of *this, and false
+    /// otherwise.
+    [[nodiscard]] bool contains_insensitive(StringRef Other) const {
+      return find_insensitive(Other) != npos;
+    }
+
+    /// Return true if the given character is contained in *this, and false
+    /// otherwise.
+    [[nodiscard]] bool contains_insensitive(char C) const {
+      return find_insensitive(C) != npos;
+    }
+
+    /// @}
+    /// @name Helpful Algorithms
+    /// @{
+
+    /// Return the number of occurrences of \p C in the string.
+    [[nodiscard]] size_t count(char C) const {
+      size_t Count = 0;
+      for (size_t I = 0; I != size(); ++I)
+        if (data()[I] == C)
+          ++Count;
+      return Count;
+    }
+
+    /// Return the number of non-overlapped occurrences of \p Str in
+    /// the string.
+    LLVM_ABI size_t count(StringRef Str) const;
+
+    /// Parse the current string as an integer of the specified radix.  If
+    /// \p Radix is specified as zero, this does radix autosensing using
+    /// extended C rules: 0 is octal, 0x is hex, 0b is binary.
+    ///
+    /// If the string is invalid or if only a subset of the string is valid,
+    /// this returns true to signify the error.  The string is considered
+    /// erroneous if empty or if it overflows T.
+    template <typename T> bool getAsInteger(unsigned Radix, T &Result) const {
+      if constexpr (std::numeric_limits<T>::is_signed) {
+        long long LLVal;
+        if (getAsSignedInteger(*this, Radix, LLVal) ||
+            static_cast<T>(LLVal) != LLVal)
+          return true;
+        Result = LLVal;
+      } else {
+        unsigned long long ULLVal;
+        // The additional cast to unsigned long long is required to avoid the
+        // Visual C++ warning C4805: '!=' : unsafe mix of type 'bool' and type
+        // 'unsigned __int64' when instantiating getAsInteger with T = bool.
+        if (getAsUnsignedInteger(*this, Radix, ULLVal) ||
+            static_cast<unsigned long long>(static_cast<T>(ULLVal)) != ULLVal)
+          return true;
+        Result = ULLVal;
+      }
+      return false;
+    }
+
+    /// Parse the current string as an integer of the specified radix.  If
+    /// \p Radix is specified as zero, this does radix autosensing using
+    /// extended C rules: 0 is octal, 0x is hex, 0b is binary.
+    ///
+    /// If the string does not begin with a number of the specified radix,
+    /// this returns true to signify the error. The string is considered
+    /// erroneous if empty or if it overflows T.
+    /// The portion of the string representing the discovered numeric value
+    /// is removed from the beginning of the string.
+    template <typename T> bool consumeInteger(unsigned Radix, T &Result) {
+      if constexpr (std::numeric_limits<T>::is_signed) {
+        long long LLVal;
+        if (consumeSignedInteger(*this, Radix, LLVal) ||
+            static_cast<long long>(static_cast<T>(LLVal)) != LLVal)
+          return true;
+        Result = LLVal;
+      } else {
+        unsigned long long ULLVal;
+        if (consumeUnsignedInteger(*this, Radix, ULLVal) ||
+            static_cast<unsigned long long>(static_cast<T>(ULLVal)) != ULLVal)
+          return true;
+        Result = ULLVal;
+      }
+      return false;
+    }
+
+    /// Parse the current string as an integer of the specified \p Radix, or of
+    /// an autosensed radix if the \p Radix given is 0.  The current value in
+    /// \p Result is discarded, and the storage is changed to be wide enough to
+    /// store the parsed integer.
+    ///
+    /// \returns true if the string does not solely consist of a valid
+    /// non-empty number in the appropriate base.
+    ///
+    /// APInt::fromString is superficially similar but assumes the
+    /// string is well-formed in the given radix.
+    LLVM_ABI bool getAsInteger(unsigned Radix, APInt &Result) const;
+
+    /// Parse the current string as an integer of the specified \p Radix.  If
+    /// \p Radix is specified as zero, this does radix autosensing using
+    /// extended C rules: 0 is octal, 0x is hex, 0b is binary.
+    ///
+    /// If the string does not begin with a number of the specified radix,
+    /// this returns true to signify the error. The string is considered
+    /// erroneous if empty.
+    /// The portion of the string representing the discovered numeric value
+    /// is removed from the beginning of the string.
+    LLVM_ABI bool consumeInteger(unsigned Radix, APInt &Result);
+
+    /// Parse the current string as an IEEE double-precision floating
+    /// point value.  The string must be a well-formed double.
+    ///
+    /// If \p AllowInexact is false, the function will fail if the string
+    /// cannot be represented exactly.  Otherwise, the function only fails
+    /// in case of an overflow or underflow, or an invalid floating point
+    /// representation.
+    LLVM_ABI bool getAsDouble(double &Result, bool AllowInexact = true) const;
+
+    /// @}
+    /// @name String Operations
+    /// @{
+
+    // Convert the given ASCII string to lowercase.
+    [[nodiscard]] LLVM_ABI std::string lower() const;
+
+    /// Convert the given ASCII string to uppercase.
+    [[nodiscard]] LLVM_ABI std::string upper() const;
+
+    /// @}
+    /// @name Substring Operations
+    /// @{
+
+    /// Return a reference to the substring from [Start, Start + N).
+    ///
+    /// \param Start The index of the starting character in the substring; if
+    /// the index is npos or greater than the length of the string then the
+    /// empty substring will be returned.
+    ///
+    /// \param N The number of characters to included in the substring. If N
+    /// exceeds the number of characters remaining in the string, the string
+    /// suffix (starting with \p Start) will be returned.
+    [[nodiscard]] constexpr StringRef substr(size_t Start,
+                                             size_t N = npos) const {
+      Start = std::min(Start, size());
+      return StringRef(data() + Start, std::min(N, size() - Start));
+    }
+
+    /// Return a StringRef equal to 'this' but with only the first \p N
+    /// elements remaining.  If \p N is greater than the length of the
+    /// string, the entire string is returned.
+    [[nodiscard]] StringRef take_front(size_t N = 1) const {
+      if (N >= size())
+        return *this;
+      return drop_back(size() - N);
+    }
+
+    /// Return a StringRef equal to 'this' but with only the last \p N
+    /// elements remaining.  If \p N is greater than the length of the
+    /// string, the entire string is returned.
+    [[nodiscard]] StringRef take_back(size_t N = 1) const {
+      if (N >= size())
+        return *this;
+      return drop_front(size() - N);
+    }
+
+    /// Return the longest prefix of 'this' such that every character
+    /// in the prefix satisfies the given predicate.
+    [[nodiscard]] StringRef take_while(function_ref<bool(char)> F) const {
+      return substr(0, find_if_not(F));
+    }
+
+    /// Return the longest prefix of 'this' such that no character in
+    /// the prefix satisfies the given predicate.
+    [[nodiscard]] StringRef take_until(function_ref<bool(char)> F) const {
+      return substr(0, find_if(F));
+    }
+
+    /// Return a StringRef equal to 'this' but with the first \p N elements
+    /// dropped.
+    [[nodiscard]] StringRef drop_front(size_t N = 1) const {
+      assert(size() >= N && "Dropping more elements than exist");
+      return substr(N);
+    }
+
+    /// Return a StringRef equal to 'this' but with the last \p N elements
+    /// dropped.
+    [[nodiscard]] StringRef drop_back(size_t N = 1) const {
+      assert(size() >= N && "Dropping more elements than exist");
+      return substr(0, size()-N);
+    }
+
+    /// Return a StringRef equal to 'this', but with all characters satisfying
+    /// the given predicate dropped from the beginning of the string.
+    [[nodiscard]] StringRef drop_while(function_ref<bool(char)> F) const {
+      return substr(find_if_not(F));
+    }
+
+    /// Return a StringRef equal to 'this', but with all characters not
+    /// satisfying the given predicate dropped from the beginning of the string.
+    [[nodiscard]] StringRef drop_until(function_ref<bool(char)> F) const {
+      return substr(find_if(F));
+    }
+
+    /// Returns true if this StringRef has the given prefix and removes that
+    /// prefix.
+    bool consume_front(char Prefix) {
+      if (!starts_with(Prefix))
+        return false;
+
+      *this = drop_front();
+      return true;
+    }
+
+    /// Returns true if this StringRef has the given prefix and removes that
+    /// prefix.
+    bool consume_front(StringRef Prefix) {
+      if (!starts_with(Prefix))
+        return false;
+
+      *this = substr(Prefix.size());
+      return true;
+    }
+
+    /// Returns true if this StringRef has the given prefix, ignoring case,
+    /// and removes that prefix.
+    bool consume_front_insensitive(StringRef Prefix) {
+      if (!starts_with_insensitive(Prefix))
+        return false;
+
+      *this = substr(Prefix.size());
+      return true;
+    }
+
+    /// Returns true if this StringRef has the given suffix and removes that
+    /// suffix.
+    bool consume_back(StringRef Suffix) {
+      if (!ends_with(Suffix))
+        return false;
+
+      *this = substr(0, size() - Suffix.size());
+      return true;
+    }
+
+    /// Returns true if this StringRef has the given suffix, ignoring case,
+    /// and removes that suffix.
+    bool consume_back_insensitive(StringRef Suffix) {
+      if (!ends_with_insensitive(Suffix))
+        return false;
+
+      *this = substr(0, size() - Suffix.size());
+      return true;
+    }
+
+    /// Return a reference to the substring from [Start, End).
+    ///
+    /// \param Start The index of the starting character in the substring; if
+    /// the index is npos or greater than the length of the string then the
+    /// empty substring will be returned.
+    ///
+    /// \param End The index following the last character to include in the
+    /// substring. If this is npos or exceeds the number of characters
+    /// remaining in the string, the string suffix (starting with \p Start)
+    /// will be returned. If this is less than \p Start, an empty string will
+    /// be returned.
+    [[nodiscard]] StringRef slice(size_t Start, size_t End) const {
+      Start = std::min(Start, size());
+      End = std::clamp(End, Start, size());
+      return StringRef(data() + Start, End - Start);
+    }
+
+    /// Split into two substrings around the first occurrence of a separator
+    /// character.
+    ///
+    /// If \p Separator is in the string, then the result is a pair (LHS, RHS)
+    /// such that (*this == LHS + Separator + RHS) is true and RHS is
+    /// maximal. If \p Separator is not in the string, then the result is a
+    /// pair (LHS, RHS) where (*this == LHS) and (RHS == "").
+    ///
+    /// \param Separator The character to split on.
+    /// \returns The split substrings.
+    [[nodiscard]] std::pair<StringRef, StringRef> split(char Separator) const {
+      return split(StringRef(&Separator, 1));
+    }
+
+    /// Split into two substrings around the first occurrence of a separator
+    /// string.
+    ///
+    /// If \p Separator is in the string, then the result is a pair (LHS, RHS)
+    /// such that (*this == LHS + Separator + RHS) is true and RHS is
+    /// maximal. If \p Separator is not in the string, then the result is a
+    /// pair (LHS, RHS) where (*this == LHS) and (RHS == "").
+    ///
+    /// \param Separator - The string to split on.
+    /// \return - The split substrings.
+    [[nodiscard]] std::pair<StringRef, StringRef>
+    split(StringRef Separator) const {
+      size_t Idx = find(Separator);
+      if (Idx == npos)
+        return {*this, StringRef()};
+      return {slice(0, Idx), substr(Idx + Separator.size())};
+    }
+
+    /// Split into two substrings around the last occurrence of a separator
+    /// string.
+    ///
+    /// If \p Separator is in the string, then the result is a pair (LHS, RHS)
+    /// such that (*this == LHS + Separator + RHS) is true and RHS is
+    /// minimal. If \p Separator is not in the string, then the result is a
+    /// pair (LHS, RHS) where (*this == LHS) and (RHS == "").
+    ///
+    /// \param Separator - The string to split on.
+    /// \return - The split substrings.
+    [[nodiscard]] std::pair<StringRef, StringRef>
+    rsplit(StringRef Separator) const {
+      size_t Idx = rfind(Separator);
+      if (Idx == npos)
+        return {*this, StringRef()};
+      return {slice(0, Idx), substr(Idx + Separator.size())};
+    }
+
+    /// Split into substrings around the occurrences of a separator string.
+    ///
+    /// Each substring is stored in \p A. If \p MaxSplit is >= 0, at most
+    /// \p MaxSplit splits are done and consequently <= \p MaxSplit + 1
+    /// elements are added to A.
+    /// If \p KeepEmpty is false, empty strings are not added to \p A. They
+    /// still count when considering \p MaxSplit
+    /// An useful invariant is that
+    /// Separator.join(A) == *this if MaxSplit == -1 and KeepEmpty == true
+    ///
+    /// \param A - Where to put the substrings.
+    /// \param Separator - The string to split on.
+    /// \param MaxSplit - The maximum number of times the string is split.
+    /// \param KeepEmpty - True if empty substring should be added.
+    LLVM_ABI void split(SmallVectorImpl<StringRef> &A, StringRef Separator,
+                        int MaxSplit = -1, bool KeepEmpty = true) const;
+
+    /// Split into substrings around the occurrences of a separator character.
+    ///
+    /// Each substring is stored in \p A. If \p MaxSplit is >= 0, at most
+    /// \p MaxSplit splits are done and consequently <= \p MaxSplit + 1
+    /// elements are added to A.
+    /// If \p KeepEmpty is false, empty strings are not added to \p A. They
+    /// still count when considering \p MaxSplit
+    /// An useful invariant is that
+    /// Separator.join(A) == *this if MaxSplit == -1 and KeepEmpty == true
+    ///
+    /// \param A - Where to put the substrings.
+    /// \param Separator - The string to split on.
+    /// \param MaxSplit - The maximum number of times the string is split.
+    /// \param KeepEmpty - True if empty substring should be added.
+    LLVM_ABI void split(SmallVectorImpl<StringRef> &A, char Separator,
+                        int MaxSplit = -1, bool KeepEmpty = true) const;
+
+    /// Split into two substrings around the last occurrence of a separator
+    /// character.
+    ///
+    /// If \p Separator is in the string, then the result is a pair (LHS, RHS)
+    /// such that (*this == LHS + Separator + RHS) is true and RHS is
+    /// minimal. If \p Separator is not in the string, then the result is a
+    /// pair (LHS, RHS) where (*this == LHS) and (RHS == "").
+    ///
+    /// \param Separator - The character to split on.
+    /// \return - The split substrings.
+    [[nodiscard]] std::pair<StringRef, StringRef> rsplit(char Separator) const {
+      return rsplit(StringRef(&Separator, 1));
+    }
+
+    /// Return string with consecutive \p Char characters starting from the
+    /// the left removed.
+    [[nodiscard]] StringRef ltrim(char Char) const {
+      return drop_front(std::min(size(), find_first_not_of(Char)));
+    }
+
+    /// Return string with consecutive characters in \p Chars starting from
+    /// the left removed.
+    [[nodiscard]] StringRef ltrim(StringRef Chars = " \t\n\v\f\r") const {
+      return drop_front(std::min(size(), find_first_not_of(Chars)));
+    }
+
+    /// Return string with consecutive \p Char characters starting from the
+    /// right removed.
+    [[nodiscard]] StringRef rtrim(char Char) const {
+      return drop_back(size() - std::min(size(), find_last_not_of(Char) + 1));
+    }
+
+    /// Return string with consecutive characters in \p Chars starting from
+    /// the right removed.
+    [[nodiscard]] StringRef rtrim(StringRef Chars = " \t\n\v\f\r") const {
+      return drop_back(size() - std::min(size(), find_last_not_of(Chars) + 1));
+    }
+
+    /// Return string with consecutive \p Char characters starting from the
+    /// left and right removed.
+    [[nodiscard]] StringRef trim(char Char) const {
+      return ltrim(Char).rtrim(Char);
+    }
+
+    /// Return string with consecutive characters in \p Chars starting from
+    /// the left and right removed.
+    [[nodiscard]] StringRef trim(StringRef Chars = " \t\n\v\f\r") const {
+      return ltrim(Chars).rtrim(Chars);
+    }
+
+    /// Detect the line ending style of the string.
+    ///
+    /// If the string contains a line ending, return the line ending character
+    /// sequence that is detected. Otherwise return '\n' for unix line endings.
+    ///
+    /// \return - The line ending character sequence.
+    [[nodiscard]] StringRef detectEOL() const {
+      size_t Pos = find('\r');
+      if (Pos == npos) {
+        // If there is no carriage return, assume unix
+        return "\n";
+      }
+      if (Pos + 1 < size() && data()[Pos + 1] == '\n')
+        return "\r\n"; // Windows
+      if (Pos > 0 && data()[Pos - 1] == '\n')
+        return "\n\r"; // You monster!
+      return "\r";     // Classic Mac
+    }
+    /// @}
+  };
+
+  /// A wrapper around a string literal that serves as a proxy for constructing
+  /// global tables of StringRefs with the length computed at compile time.
+  /// In order to avoid the invocation of a global constructor, StringLiteral
+  /// should *only* be used in a constexpr context, as such:
+  ///
+  /// constexpr StringLiteral S("test");
+  ///
+  class StringLiteral : public StringRef {
+  private:
+    constexpr StringLiteral(const char *Str, size_t N) : StringRef(Str, N) {
+    }
+
+  public:
+    template <size_t N>
+    constexpr StringLiteral(const char (&Str)[N])
+#if defined(__clang__) && __has_attribute(enable_if)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wgcc-compat"
+        __attribute((enable_if(__builtin_strlen(Str) == N - 1,
+                               "invalid string literal")))
+#pragma clang diagnostic pop
+#endif
+        : StringRef(Str, N - 1) {
+    }
+
+    // Explicit construction for strings like "foo\0bar".
+    template <size_t N>
+    static constexpr StringLiteral withInnerNUL(const char (&Str)[N]) {
+      return StringLiteral(Str, N - 1);
+    }
+  };
+
+  /// @name StringRef Comparison Operators
+  /// @{
+
+  inline bool operator==(StringRef LHS, StringRef RHS) {
+    if (LHS.size() != RHS.size())
+      return false;
+    if (LHS.empty())
+      return true;
+    return ::memcmp(LHS.data(), RHS.data(), LHS.size()) == 0;
+  }
+
+  inline bool operator!=(StringRef LHS, StringRef RHS) { return !(LHS == RHS); }
+
+  inline bool operator<(StringRef LHS, StringRef RHS) {
+    return LHS.compare(RHS) < 0;
+  }
+
+  inline bool operator<=(StringRef LHS, StringRef RHS) {
+    return LHS.compare(RHS) <= 0;
+  }
+
+  inline bool operator>(StringRef LHS, StringRef RHS) {
+    return LHS.compare(RHS) > 0;
+  }
+
+  inline bool operator>=(StringRef LHS, StringRef RHS) {
+    return LHS.compare(RHS) >= 0;
+  }
+
+  inline std::string &operator+=(std::string &buffer, StringRef string) {
+    return buffer.append(string.data(), string.size());
+  }
+
+  /// @}
+
+  /// Compute a hash_code for a StringRef.
+  [[nodiscard]] LLVM_ABI hash_code hash_value(StringRef S);
+
+  // Provide DenseMapInfo for StringRefs.
+  template <> struct DenseMapInfo<StringRef, void> {
+    static inline StringRef getEmptyKey() {
+      return StringRef(
+          reinterpret_cast<const char *>(~static_cast<uintptr_t>(0)), 0);
+    }
+
+    static inline StringRef getTombstoneKey() {
+      return StringRef(
+          reinterpret_cast<const char *>(~static_cast<uintptr_t>(1)), 0);
+    }
+
+    LLVM_ABI static unsigned getHashValue(StringRef Val);
+
+    static bool isEqual(StringRef LHS, StringRef RHS) {
+      if (RHS.data() == getEmptyKey().data())
+        return LHS.data() == getEmptyKey().data();
+      if (RHS.data() == getTombstoneKey().data())
+        return LHS.data() == getTombstoneKey().data();
+      return LHS == RHS;
+    }
+  };
+
+} // end namespace llvm
+
+#endif // LLVM_ADT_STRINGREF_H
diff --git a/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/iterator_range.h b/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/iterator_range.h
new file mode 100644
index 00000000..cc8070eb
--- /dev/null
+++ b/tool/_testcpp/llvm-22.1.8-support/include/llvm/ADT/iterator_range.h
@@ -0,0 +1,80 @@
+//===- iterator_range.h - A range adaptor for iterators ---------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+/// This provides a very simple, boring adaptor for a begin and end iterator
+/// into a range type. This should be used to build range views that work well
+/// with range based for loops and range based constructors.
+///
+/// Note that code here follows more standards-based coding conventions as it
+/// is mirroring proposed interfaces for standardization.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_ITERATOR_RANGE_H
+#define LLVM_ADT_ITERATOR_RANGE_H
+
+#include "llvm/ADT/ADL.h"
+#include <type_traits>
+#include <utility>
+
+namespace llvm {
+
+/// A range adaptor for a pair of iterators.
+///
+/// This just wraps two iterators into a range-compatible interface. Nothing
+/// fancy at all.
+template <typename IteratorT>
+class iterator_range {
+  IteratorT begin_iterator, end_iterator;
+
+  template <typename From, typename To>
+  using explicitly_converted_t = decltype(static_cast<To>(
+      std::declval<std::add_rvalue_reference_t<From>>()));
+
+public:
+#if defined(__GNUC__) &&                                                       \
+    (__GNUC__ == 7 || (__GNUC__ == 8 && __GNUC_MINOR__ < 4))
+  // Be careful no to break gcc-7 and gcc-8 < 8.4 on the mlir target.
+  // See https://github.com/llvm/llvm-project/issues/63843
+  template <typename Container>
+#else
+  template <typename Container,
+            std::void_t<explicitly_converted_t<
+                llvm::detail::IterOfRange<Container>, IteratorT>> * = nullptr>
+#endif
+  iterator_range(Container &&c)
+      : begin_iterator(adl_begin(c)), end_iterator(adl_end(c)) {
+  }
+  iterator_range(IteratorT begin_iterator, IteratorT end_iterator)
+      : begin_iterator(std::move(begin_iterator)),
+        end_iterator(std::move(end_iterator)) {}
+
+  IteratorT begin() const { return begin_iterator; }
+  IteratorT end() const { return end_iterator; }
+  bool empty() const { return begin_iterator == end_iterator; }
+};
+
+template <typename Container>
+iterator_range(Container &&)
+    -> iterator_range<llvm::detail::IterOfRange<Container>>;
+
+/// Convenience function for iterating over sub-ranges.
+///
+/// This provides a bit of syntactic sugar to make using sub-ranges
+/// in for loops a bit easier. Analogous to std::make_pair().
+template <class T> iterator_range<T> make_range(T x, T y) {
+  return iterator_range<T>(std::move(x), std::move(y));
+}
+
+template <typename T> iterator_range<T> make_range(std::pair<T, T> p) {
+  return iterator_range<T>(std::move(p.first), std::move(p.second));
+}
+
+}
+
+#endif
diff --git a/tool/_testcpp/llvm-22.1.8-support/include/llvm/Support/AArch64AttributeParser.h b/tool/_testcpp/llvm-22.1.8-support/include/llvm/Support/AArch64AttributeParser.h
deleted file mode 100644
index f4552ef2..00000000
--- a/tool/_testcpp/llvm-22.1.8-support/include/llvm/Support/AArch64AttributeParser.h
+++ /dev/null
@@ -1,41 +0,0 @@
-//=== - AArch64AttributeParser.h-AArch64 Attribute Information Printer - ===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===--------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_AARCH64ATTRIBUTEPARSER_H
-#define LLVM_SUPPORT_AARCH64ATTRIBUTEPARSER_H
-
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/ELFAttrParserExtended.h"
-#include "llvm/Support/ELFAttributes.h"
-
-namespace llvm {
-
-class AArch64AttributeParser : public ELFExtendedAttrParser {
-  LLVM_ABI static std::vector<SubsectionAndTagToTagName> &returnTagsNamesMap();
-
-public:
-  AArch64AttributeParser(ScopedPrinter *Sw)
-      : ELFExtendedAttrParser(Sw, returnTagsNamesMap()) {}
-  AArch64AttributeParser()
-      : ELFExtendedAttrParser(nullptr, returnTagsNamesMap()) {}
-};
-
-// Used for extracting AArch64 Build Attributes
-struct AArch64BuildAttrSubsections {
-  struct PauthSubSection {
-    uint64_t TagPlatform = 0;
-    uint64_t TagSchema = 0;
-  } Pauth;
-  uint32_t AndFeatures = 0;
-};
-
-LLVM_ABI AArch64BuildAttrSubsections
-extractBuildAttributesSubsections(const llvm::AArch64AttributeParser &);
-} // namespace llvm
-
-#endif // LLVM_SUPPORT_AARCH64ATTRIBUTEPARSER_H
diff --git a/tool/_testcpp/llvm-22.1.8-support/include/llvm/Support/ARMAttributeParser.h b/tool/_testcpp/llvm-22.1.8-support/include/llvm/Support/ARMAttributeParser.h
deleted file mode 100644
index 0fd8a1ed..00000000
--- a/tool/_testcpp/llvm-22.1.8-support/include/llvm/Support/ARMAttributeParser.h
+++ /dev/null
@@ -1,85 +0,0 @@
-//===- ARMAttributeParser.h - ARM Attribute Information Printer -*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_ARMATTRIBUTEPARSER_H
-#define LLVM_SUPPORT_ARMATTRIBUTEPARSER_H
-
-#include "ARMBuildAttributes.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/ELFAttrParserCompact.h"
-#include "llvm/Support/Error.h"
-
-namespace llvm {
-
-class ScopedPrinter;
-
-class LLVM_ABI ARMAttributeParser : public ELFCompactAttrParser {
-  struct DisplayHandler {
-    ARMBuildAttrs::AttrType attribute;
-    Error (ARMAttributeParser::*routine)(ARMBuildAttrs::AttrType);
-  };
-  static const DisplayHandler displayRoutines[];
-
-  Error handler(uint64_t tag, bool &handled) override;
-
-  Error stringAttribute(ARMBuildAttrs::AttrType tag);
-
-  Error CPU_arch(ARMBuildAttrs::AttrType tag);
-  Error CPU_arch_profile(ARMBuildAttrs::AttrType tag);
-  Error ARM_ISA_use(ARMBuildAttrs::AttrType tag);
-  Error THUMB_ISA_use(ARMBuildAttrs::AttrType tag);
-  Error FP_arch(ARMBuildAttrs::AttrType tag);
-  Error WMMX_arch(ARMBuildAttrs::AttrType tag);
-  Error Advanced_SIMD_arch(ARMBuildAttrs::AttrType tag);
-  Error MVE_arch(ARMBuildAttrs::AttrType tag);
-  Error PCS_config(ARMBuildAttrs::AttrType tag);
-  Error ABI_PCS_R9_use(ARMBuildAttrs::AttrType tag);
-  Error ABI_PCS_RW_data(ARMBuildAttrs::AttrType tag);
-  Error ABI_PCS_RO_data(ARMBuildAttrs::AttrType tag);
-  Error ABI_PCS_GOT_use(ARMBuildAttrs::AttrType tag);
-  Error ABI_PCS_wchar_t(ARMBuildAttrs::AttrType tag);
-  Error ABI_FP_rounding(ARMBuildAttrs::AttrType tag);
-  Error ABI_FP_denormal(ARMBuildAttrs::AttrType tag);
-  Error ABI_FP_exceptions(ARMBuildAttrs::AttrType tag);
-  Error ABI_FP_user_exceptions(ARMBuildAttrs::AttrType tag);
-  Error ABI_FP_number_model(ARMBuildAttrs::AttrType tag);
-  Error ABI_align_needed(ARMBuildAttrs::AttrType tag);
-  Error ABI_align_preserved(ARMBuildAttrs::AttrType tag);
-  Error ABI_enum_size(ARMBuildAttrs::AttrType tag);
-  Error ABI_HardFP_use(ARMBuildAttrs::AttrType tag);
-  Error ABI_VFP_args(ARMBuildAttrs::AttrType tag);
-  Error ABI_WMMX_args(ARMBuildAttrs::AttrType tag);
-  Error ABI_optimization_goals(ARMBuildAttrs::AttrType tag);
-  Error ABI_FP_optimization_goals(ARMBuildAttrs::AttrType tag);
-  Error compatibility(ARMBuildAttrs::AttrType tag);
-  Error CPU_unaligned_access(ARMBuildAttrs::AttrType tag);
-  Error FP_HP_extension(ARMBuildAttrs::AttrType tag);
-  Error ABI_FP_16bit_format(ARMBuildAttrs::AttrType tag);
-  Error MPextension_use(ARMBuildAttrs::AttrType tag);
-  Error DIV_use(ARMBuildAttrs::AttrType tag);
-  Error DSP_extension(ARMBuildAttrs::AttrType tag);
-  Error T2EE_use(ARMBuildAttrs::AttrType tag);
-  Error Virtualization_use(ARMBuildAttrs::AttrType tag);
-  Error PAC_extension(ARMBuildAttrs::AttrType tag);
-  Error BTI_extension(ARMBuildAttrs::AttrType tag);
-  Error PACRET_use(ARMBuildAttrs::AttrType tag);
-  Error BTI_use(ARMBuildAttrs::AttrType tag);
-  Error nodefaults(ARMBuildAttrs::AttrType tag);
-  Error also_compatible_with(ARMBuildAttrs::AttrType tag);
-
-public:
-  ARMAttributeParser(ScopedPrinter *sw)
-      : ELFCompactAttrParser(sw, ARMBuildAttrs::getARMAttributeTags(),
-                             "aeabi") {}
-  ARMAttributeParser()
-      : ELFCompactAttrParser(ARMBuildAttrs::getARMAttributeTags(), "aeabi") {}
-};
-}
-
-#endif
diff --git a/tool/_testcpp/llvm-22.1.8-support/include/llvm/Support/ARMBuildAttributes.h b/tool/_testcpp/llvm-22.1.8-support/include/llvm/Support/ARMBuildAttributes.h
deleted file mode 100644
index 68acf30e..00000000
--- a/tool/_testcpp/llvm-22.1.8-support/include/llvm/Support/ARMBuildAttributes.h
+++ /dev/null
@@ -1,270 +0,0 @@
-//===-- ARMBuildAttributes.h - ARM Build Attributes -------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains enumerations and support routines for ARM build attributes
-// as defined in ARM ABI addenda document (ABI release 2.08).
-//
-// ELF for the ARM Architecture r2.09 - November 30, 2012
-//
-// http://infocenter.arm.com/help/topic/com.arm.doc.ihi0044e/IHI0044E_aaelf.pdf
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_ARMBUILDATTRIBUTES_H
-#define LLVM_SUPPORT_ARMBUILDATTRIBUTES_H
-
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/ELFAttributes.h"
-
-namespace llvm {
-namespace ARMBuildAttrs {
-
-LLVM_ABI const TagNameMap &getARMAttributeTags();
-
-enum SpecialAttr {
-  // This is for the .cpu asm attr. It translates into one or more
-  // AttrType (below) entries in the .ARM.attributes section in the ELF.
-  SEL_CPU
-};
-
-enum AttrType : unsigned {
-  // Rest correspond to ELF/.ARM.attributes
-  File = 1,
-  CPU_raw_name = 4,
-  CPU_name = 5,
-  CPU_arch = 6,
-  CPU_arch_profile = 7,
-  ARM_ISA_use = 8,
-  THUMB_ISA_use = 9,
-  FP_arch = 10,
-  WMMX_arch = 11,
-  Advanced_SIMD_arch = 12,
-  PCS_config = 13,
-  ABI_PCS_R9_use = 14,
-  ABI_PCS_RW_data = 15,
-  ABI_PCS_RO_data = 16,
-  ABI_PCS_GOT_use = 17,
-  ABI_PCS_wchar_t = 18,
-  ABI_FP_rounding = 19,
-  ABI_FP_denormal = 20,
-  ABI_FP_exceptions = 21,
-  ABI_FP_user_exceptions = 22,
-  ABI_FP_number_model = 23,
-  ABI_align_needed = 24,
-  ABI_align_preserved = 25,
-  ABI_enum_size = 26,
-  ABI_HardFP_use = 27,
-  ABI_VFP_args = 28,
-  ABI_WMMX_args = 29,
-  ABI_optimization_goals = 30,
-  ABI_FP_optimization_goals = 31,
-  compatibility = 32,
-  CPU_unaligned_access = 34,
-  FP_HP_extension = 36,
-  ABI_FP_16bit_format = 38,
-  MPextension_use = 42, // recoded from 70 (ABI r2.08)
-  DIV_use = 44,
-  DSP_extension = 46,
-  MVE_arch = 48,
-  PAC_extension = 50,
-  BTI_extension = 52,
-  also_compatible_with = 65,
-  conformance = 67,
-  Virtualization_use = 68,
-  BTI_use = 74,
-  PACRET_use = 76,
-
-  /// Legacy Tags
-  Section = 2,               // deprecated (ABI r2.09)
-  Symbol = 3,                // deprecated (ABI r2.09)
-  ABI_align8_needed = 24,    // renamed to ABI_align_needed (ABI r2.09)
-  ABI_align8_preserved = 25, // renamed to ABI_align_preserved (ABI r2.09)
-  nodefaults = 64,           // deprecated (ABI r2.09)
-  T2EE_use = 66,             // deprecated (ABI r2.09)
-  MPextension_use_old = 70   // recoded to MPextension_use (ABI r2.08)
-};
-
-// Legal Values for CPU_arch, (=6), uleb128
-enum CPUArch {
-  Pre_v4 = 0,
-  v4 = 1,           // e.g. SA110
-  v4T = 2,          // e.g. ARM7TDMI
-  v5T = 3,          // e.g. ARM9TDMI
-  v5TE = 4,         // e.g. ARM946E_S
-  v5TEJ = 5,        // e.g. ARM926EJ_S
-  v6 = 6,           // e.g. ARM1136J_S
-  v6KZ = 7,         // e.g. ARM1176JZ_S
-  v6T2 = 8,         // e.g. ARM1156T2_S
-  v6K = 9,          // e.g. ARM1176JZ_S
-  v7 = 10,          // e.g. Cortex A8, Cortex M3
-  v6_M = 11,        // e.g. Cortex M1
-  v6S_M = 12,       // v6_M with the System extensions
-  v7E_M = 13,       // v7_M with DSP extensions
-  v8_A = 14,        // v8_A AArch32
-  v8_R = 15,        // e.g. Cortex R52
-  v8_M_Base = 16,   // v8_M_Base AArch32
-  v8_M_Main = 17,   // v8_M_Main AArch32
-  v8_1_M_Main = 21, // v8_1_M_Main AArch32
-  v9_A = 22,        // v9_A AArch32
-};
-
-enum CPUArchProfile {               // (=7), uleb128
-  Not_Applicable          = 0,      // pre v7, or cross-profile code
-  ApplicationProfile      = (0x41), // 'A' (e.g. for Cortex A8)
-  RealTimeProfile         = (0x52), // 'R' (e.g. for Cortex R4)
-  MicroControllerProfile  = (0x4D), // 'M' (e.g. for Cortex M3)
-  SystemProfile           = (0x53)  // 'S' Application or real-time profile
-};
-
-// The following have a lot of common use cases
-enum {
-  Not_Allowed = 0,
-  Allowed = 1,
-
-  // Tag_ARM_ISA_use (=8), uleb128
-
-  // Tag_THUMB_ISA_use, (=9), uleb128
-  AllowThumb32 = 2, // 32-bit Thumb (implies 16-bit instructions)
-  AllowThumbDerived = 3, // Thumb allowed, derived from arch/profile
-
-  // Tag_FP_arch (=10), uleb128 (formerly Tag_VFP_arch = 10)
-  AllowFPv2  = 2,     // v2 FP ISA permitted (implies use of the v1 FP ISA)
-  AllowFPv3A = 3,     // v3 FP ISA permitted (implies use of the v2 FP ISA)
-  AllowFPv3B = 4,     // v3 FP ISA permitted, but only D0-D15, S0-S31
-  AllowFPv4A = 5,     // v4 FP ISA permitted (implies use of v3 FP ISA)
-  AllowFPv4B = 6,     // v4 FP ISA was permitted, but only D0-D15, S0-S31
-  AllowFPARMv8A = 7,  // Use of the ARM v8-A FP ISA was permitted
-  AllowFPARMv8B = 8,  // Use of the ARM v8-A FP ISA was permitted, but only
-                      // D0-D15, S0-S31
-
-  // Tag_WMMX_arch, (=11), uleb128
-  AllowWMMXv1 = 1,  // The user permitted this entity to use WMMX v1
-  AllowWMMXv2 = 2,  // The user permitted this entity to use WMMX v2
-
-  // Tag_Advanced_SIMD_arch, (=12), uleb128
-  AllowNeon = 1,      // SIMDv1 was permitted
-  AllowNeon2 = 2,     // SIMDv2 was permitted (Half-precision FP, MAC operations)
-  AllowNeonARMv8 = 3, // ARM v8-A SIMD was permitted
-  AllowNeonARMv8_1a = 4,// ARM v8.1-A SIMD was permitted (RDMA)
-
-  // Tag_MVE_arch, (=48), uleb128
-  AllowMVEInteger = 1, // integer-only MVE was permitted
-  AllowMVEIntegerAndFloat = 2, // both integer and floating point MVE were permitted
-
-  // Tag_ABI_PCS_R9_use, (=14), uleb128
-  R9IsGPR = 0,        // R9 used as v6 (just another callee-saved register)
-  R9IsSB = 1,         // R9 used as a global static base rgister
-  R9IsTLSPointer = 2, // R9 used as a thread local storage pointer
-  R9Reserved = 3,     // R9 not used by code associated with attributed entity
-
-  // Tag_ABI_PCS_RW_data, (=15), uleb128
-  AddressRWPCRel = 1, // Address RW static data PC-relative
-  AddressRWSBRel = 2, // Address RW static data SB-relative
-  AddressRWNone = 3, // No RW static data permitted
-
-  // Tag_ABI_PCS_RO_data, (=14), uleb128
-  AddressROPCRel = 1, // Address RO static data PC-relative
-  AddressRONone = 2, // No RO static data permitted
-
-  // Tag_ABI_PCS_GOT_use, (=17), uleb128
-  AddressDirect = 1, // Address imported data directly
-  AddressGOT = 2, // Address imported data indirectly (via GOT)
-
-  // Tag_ABI_PCS_wchar_t, (=18), uleb128
-  WCharProhibited = 0,  // wchar_t is not used
-  WCharWidth2Bytes = 2, // sizeof(wchar_t) == 2
-  WCharWidth4Bytes = 4, // sizeof(wchar_t) == 4
-
-  // Tag_ABI_align_needed, (=24), uleb128
-  Align8Byte = 1,
-  Align4Byte = 2,
-  AlignReserved = 3,
-
-  // Tag_ABI_align_needed, (=25), uleb128
-  AlignNotPreserved = 0,
-  AlignPreserve8Byte = 1,
-  AlignPreserveAll = 2,
-
-  // Tag_ABI_FP_denormal, (=20), uleb128
-  PositiveZero = 0,
-  IEEEDenormals = 1,
-  PreserveFPSign = 2, // sign when flushed-to-zero is preserved
-
-  // Tag_ABI_FP_number_model, (=23), uleb128
-  AllowIEEENormal = 1,
-  AllowRTABI = 2,  // numbers, infinities, and one quiet NaN (see [RTABI])
-  AllowIEEE754 = 3, // this code to use all the IEEE 754-defined FP encodings
-
-  // Tag_ABI_enum_size, (=26), uleb128
-  EnumProhibited = 0, // The user prohibited the use of enums when building
-                      // this entity.
-  EnumSmallest = 1,   // Enum is smallest container big enough to hold all
-                      // values.
-  Enum32Bit = 2,      // Enum is at least 32 bits.
-  Enum32BitABI = 3,   // Every enumeration visible across an ABI-complying
-                      // interface contains a value needing 32 bits to encode
-                      // it; other enums can be containerized.
-
-  // Tag_ABI_HardFP_use, (=27), uleb128
-  HardFPImplied = 0,          // FP use should be implied by Tag_FP_arch
-  HardFPSinglePrecision = 1,  // Single-precision only
-
-  // Tag_ABI_VFP_args, (=28), uleb128
-  BaseAAPCS = 0,
-  HardFPAAPCS = 1,
-  ToolChainFPPCS = 2,
-  CompatibleFPAAPCS = 3,
-
-  // Tag_FP_HP_extension, (=36), uleb128
-  AllowHPFP = 1, // Allow use of Half Precision FP
-
-  // Tag_FP_16bit_format, (=38), uleb128
-  FP16FormatIEEE = 1,
-  FP16VFP3 = 2,
-
-  // Tag_MPextension_use, (=42), uleb128
-  AllowMP = 1, // Allow use of MP extensions
-
-  // Tag_DIV_use, (=44), uleb128
-  // Note: AllowDIVExt must be emitted if and only if the permission to use
-  // hardware divide cannot be conveyed using AllowDIVIfExists or DisallowDIV
-  AllowDIVIfExists = 0, // Allow hardware divide if available in arch, or no
-                        // info exists.
-  DisallowDIV = 1,      // Hardware divide explicitly disallowed.
-  AllowDIVExt = 2,      // Allow hardware divide as optional architecture
-                        // extension above the base arch specified by
-                        // Tag_CPU_arch and Tag_CPU_arch_profile.
-
-  // Tag_Virtualization_use, (=68), uleb128
-  AllowTZ = 1,
-  AllowVirtualization = 2,
-  AllowTZVirtualization = 3,
-
-  // Tag_PAC_extension, (=50), uleb128
-  DisallowPAC = 0,
-  AllowPACInNOPSpace = 1,
-  AllowPAC = 2,
-
-  // Tag_BTI_extension, (=52), uleb128
-  DisallowBTI = 0,
-  AllowBTIInNOPSpace = 1,
-  AllowBTI = 2,
-
-  // Tag_BTI_use, (=74), uleb128
-  BTINotUsed = 0,
-  BTIUsed = 1,
-
-  // Tag_PACRET_use, (=76), uleb128
-  PACRETNotUsed = 0,
-  PACRETUsed = 1
-};
-
-} // namespace ARMBuildAttrs
-} // namespace llvm
-
-#endif
diff --git a/tool/_testcpp/llvm-22.1.8-support/include/llvm/Support/ARMWinEH.h b/tool/_testcpp/llvm-22.1.8-support/include/llvm/Support/ARMWinEH.h
deleted file mode 100644
index 083bbf40..00000000
--- a/tool/_testcpp/llvm-22.1.8-support/include/llvm/Support/ARMWinEH.h
+++ /dev/null
@@ -1,522 +0,0 @@
-//===-- llvm/Support/ARMWinEH.h - Windows on ARM EH Constants ---*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_ARMWINEH_H
-#define LLVM_SUPPORT_ARMWINEH_H
-
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/Endian.h"
-
-namespace llvm {
-namespace ARM {
-namespace WinEH {
-enum class RuntimeFunctionFlag {
-  RFF_Unpacked,       /// unpacked entry
-  RFF_Packed,         /// packed entry
-  RFF_PackedFragment, /// packed entry representing a fragment
-  RFF_Reserved,       /// reserved
-};
-
-enum class ReturnType {
-  RT_POP,             /// return via pop {pc} (L flag must be set)
-  RT_B,               /// 16-bit branch
-  RT_BW,              /// 32-bit branch
-  RT_NoEpilogue,      /// no epilogue (fragment)
-};
-
-/// RuntimeFunction - An entry in the table of procedure data (.pdata)
-///
-/// This is ARM specific, but the Function Start RVA, Flag and
-/// ExceptionInformationRVA fields work identically for ARM64.
-///
-///  3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
-///  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
-/// +---------------------------------------------------------------+
-/// |                     Function Start RVA                        |
-/// +-------------------+-+-+-+-----+-+---+---------------------+---+
-/// |    Stack Adjust   |C|L|R| Reg |H|Ret|   Function Length   |Flg|
-/// +-------------------+-+-+-+-----+-+---+---------------------+---+
-///
-/// Flag : 2-bit field with the following meanings:
-///   - 00 = packed unwind data not used; reamining bits point to .xdata record
-///   - 01 = packed unwind data
-///   - 10 = packed unwind data, function assumed to have no prologue; useful
-///          for function fragments that are discontiguous with the start of the
-///          function
-///   - 11 = reserved
-/// Function Length : 11-bit field providing the length of the entire function
-///                   in bytes, divided by 2; if the function is greater than
-///                   4KB, a full .xdata record must be used instead
-/// Ret : 2-bit field indicating how the function returns
-///   - 00 = return via pop {pc} (the L bit must be set)
-///   - 01 = return via 16-bit branch
-///   - 10 = return via 32-bit branch
-///   - 11 = no epilogue; useful for function fragments that may only contain a
-///          prologue but the epilogue is elsewhere
-/// H : 1-bit flag indicating whether the function "homes" the integer parameter
-///     registers (r0-r3), allocating 16-bytes on the stack
-/// Reg : 3-bit field indicating the index of the last saved non-volatile
-///       register.  If the R bit is set to 0, then only integer registers are
-///       saved (r4-rN, where N is 4 + Reg).  If the R bit is set to 1, then
-///       only floating-point registers are being saved (d8-dN, where N is
-///       8 + Reg).  The special case of the R bit being set to 1 and Reg equal
-///       to 7 indicates that no registers are saved.
-/// R : 1-bit flag indicating whether the non-volatile registers are integer or
-///     floating-point.  0 indicates integer, 1 indicates floating-point.  The
-///     special case of the R-flag being set and Reg being set to 7 indicates
-///     that no non-volatile registers are saved.
-/// L : 1-bit flag indicating whether the function saves/restores the link
-///     register (LR)
-/// C : 1-bit flag indicating whether the function includes extra instructions
-///     to setup a frame chain for fast walking.  If this flag is set, r11 is
-///     implicitly added to the list of saved non-volatile integer registers.
-/// Stack Adjust : 10-bit field indicating the number of bytes of stack that are
-///                allocated for this function.  Only values between 0x000 and
-///                0x3f3 can be directly encoded.  If the value is 0x3f4 or
-///                greater, then the low 4 bits have special meaning as follows:
-///                - Bit 0-1
-///                  indicate the number of words' of adjustment (1-4), minus 1
-///                - Bit 2
-///                  indicates if the prologue combined adjustment into push
-///                - Bit 3
-///                  indicates if the epilogue combined adjustment into pop
-///
-/// RESTRICTIONS:
-///   - IF C is SET:
-///     + L flag must be set since frame chaining requires r11 and lr
-///     + r11 must NOT be included in the set of registers described by Reg
-///   - IF Ret is 0:
-///     + L flag must be set
-
-// NOTE: RuntimeFunction is meant to be a simple class that provides raw access
-// to all fields in the structure.  The accessor methods reflect the names of
-// the bitfields that they correspond to.  Although some obvious simplifications
-// are possible via merging of methods, it would prevent the use of this class
-// to fully inspect the contents of the data structure which is particularly
-// useful for scenarios such as llvm-readobj to aid in testing.
-
-class RuntimeFunction {
-public:
-  const support::ulittle32_t BeginAddress;
-  const support::ulittle32_t UnwindData;
-
-  RuntimeFunction(const support::ulittle32_t *Data)
-    : BeginAddress(Data[0]), UnwindData(Data[1]) {}
-
-  RuntimeFunction(const support::ulittle32_t BeginAddress,
-                  const support::ulittle32_t UnwindData)
-    : BeginAddress(BeginAddress), UnwindData(UnwindData) {}
-
-  RuntimeFunctionFlag Flag() const {
-    return RuntimeFunctionFlag(UnwindData & 0x3);
-  }
-
-  uint32_t ExceptionInformationRVA() const {
-    assert(Flag() == RuntimeFunctionFlag::RFF_Unpacked &&
-           "unpacked form required for this operation");
-    return (UnwindData & ~0x3);
-  }
-
-  uint32_t PackedUnwindData() const {
-    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
-            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
-           "packed form required for this operation");
-    return (UnwindData & ~0x3);
-  }
-  uint32_t FunctionLength() const {
-    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
-            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
-           "packed form required for this operation");
-    return (((UnwindData & 0x00001ffc) >> 2) << 1);
-  }
-  ReturnType Ret() const {
-    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
-            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
-           "packed form required for this operation");
-    assert(((UnwindData & 0x00006000) || L()) && "L must be set to 1");
-    return ReturnType((UnwindData & 0x00006000) >> 13);
-  }
-  bool H() const {
-    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
-            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
-           "packed form required for this operation");
-    return ((UnwindData & 0x00008000) >> 15);
-  }
-  uint8_t Reg() const {
-    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
-            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
-           "packed form required for this operation");
-    return ((UnwindData & 0x00070000) >> 16);
-  }
-  bool R() const {
-    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
-            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
-           "packed form required for this operation");
-    return ((UnwindData & 0x00080000) >> 19);
-  }
-  bool L() const {
-    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
-            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
-           "packed form required for this operation");
-    return ((UnwindData & 0x00100000) >> 20);
-  }
-  bool C() const {
-    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
-            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
-           "packed form required for this operation");
-    assert(((~UnwindData & 0x00200000) || L()) &&
-           "L flag must be set, chaining requires r11 and LR");
-    assert(((~UnwindData & 0x00200000) || (Reg() < 7) || R()) &&
-           "r11 must not be included in Reg; C implies r11");
-    return ((UnwindData & 0x00200000) >> 21);
-  }
-  uint16_t StackAdjust() const {
-    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
-            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
-           "packed form required for this operation");
-    return ((UnwindData & 0xffc00000) >> 22);
-  }
-};
-
-/// PrologueFolding - pseudo-flag derived from Stack Adjust indicating that the
-/// prologue has stack adjustment combined into the push
-inline bool PrologueFolding(const RuntimeFunction &RF) {
-  return RF.StackAdjust() >= 0x3f4 && (RF.StackAdjust() & 0x4);
-}
-/// Epilogue - pseudo-flag derived from Stack Adjust indicating that the
-/// epilogue has stack adjustment combined into the pop
-inline bool EpilogueFolding(const RuntimeFunction &RF) {
-  return RF.StackAdjust() >= 0x3f4 && (RF.StackAdjust() & 0x8);
-}
-/// StackAdjustment - calculated stack adjustment in words.  The stack
-/// adjustment should be determined via this function to account for the special
-/// handling the special encoding when the value is >= 0x3f4.
-inline uint16_t StackAdjustment(const RuntimeFunction &RF) {
-  uint16_t Adjustment = RF.StackAdjust();
-  if (Adjustment >= 0x3f4)
-    return (Adjustment & 0x3) + 1;
-  return Adjustment;
-}
-
-/// SavedRegisterMask - Utility function to calculate the set of saved general
-/// purpose (r0-r15) and VFP (d0-d31) registers.
-LLVM_ABI std::pair<uint16_t, uint32_t>
-SavedRegisterMask(const RuntimeFunction &RF, bool Prologue = true);
-
-/// RuntimeFunctionARM64 - An entry in the table of procedure data (.pdata)
-///
-///  3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
-///  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
-/// +---------------------------------------------------------------+
-/// |                     Function Start RVA                        |
-/// +-----------------+---+-+-------+-----+---------------------+---+
-/// |    Frame Size   |CR |H| RegI  |RegF |   Function Length   |Flg|
-/// +-----------------+---+-+-------+-----+---------------------+---+
-///
-/// See https://docs.microsoft.com/en-us/cpp/build/arm64-exception-handling
-/// for the full reference for this struct.
-
-class RuntimeFunctionARM64 {
-public:
-  const support::ulittle32_t BeginAddress;
-  const support::ulittle32_t UnwindData;
-
-  RuntimeFunctionARM64(const support::ulittle32_t *Data)
-      : BeginAddress(Data[0]), UnwindData(Data[1]) {}
-
-  RuntimeFunctionARM64(const support::ulittle32_t BeginAddress,
-                       const support::ulittle32_t UnwindData)
-      : BeginAddress(BeginAddress), UnwindData(UnwindData) {}
-
-  RuntimeFunctionFlag Flag() const {
-    return RuntimeFunctionFlag(UnwindData & 0x3);
-  }
-
-  uint32_t ExceptionInformationRVA() const {
-    assert(Flag() == RuntimeFunctionFlag::RFF_Unpacked &&
-           "unpacked form required for this operation");
-    return (UnwindData & ~0x3);
-  }
-
-  uint32_t PackedUnwindData() const {
-    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
-            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
-           "packed form required for this operation");
-    return (UnwindData & ~0x3);
-  }
-  uint32_t FunctionLength() const {
-    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
-            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
-           "packed form required for this operation");
-    return (((UnwindData & 0x00001ffc) >> 2) << 2);
-  }
-  uint8_t RegF() const {
-    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
-            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
-           "packed form required for this operation");
-    return ((UnwindData & 0x0000e000) >> 13);
-  }
-  uint8_t RegI() const {
-    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
-            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
-           "packed form required for this operation");
-    return ((UnwindData & 0x000f0000) >> 16);
-  }
-  bool H() const {
-    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
-            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
-           "packed form required for this operation");
-    return ((UnwindData & 0x00100000) >> 20);
-  }
-  uint8_t CR() const {
-    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
-            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
-           "packed form required for this operation");
-    return ((UnwindData & 0x600000) >> 21);
-  }
-  uint16_t FrameSize() const {
-    assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
-            Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
-           "packed form required for this operation");
-    return ((UnwindData & 0xff800000) >> 23);
-  }
-};
-
-/// ExceptionDataRecord - An entry in the table of exception data (.xdata)
-///
-/// The format on ARM is:
-///
-///  3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
-///  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
-/// +-------+---------+-+-+-+---+-----------------------------------+
-/// | C Wrd | Epi Cnt |F|E|X|Ver|         Function Length           |
-/// +-------+--------+'-'-'-'---'---+-------------------------------+
-/// |    Reserved    |Ex. Code Words|   (Extended Epilogue Count)   |
-/// +-------+--------+--------------+-------------------------------+
-///
-/// The format on ARM64 is:
-///
-///  3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
-///  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
-/// +---------+---------+-+-+---+-----------------------------------+
-/// |  C Wrd  | Epi Cnt |E|X|Ver|         Function Length           |
-/// +---------+------+--'-'-'---'---+-------------------------------+
-/// |    Reserved    |Ex. Code Words|   (Extended Epilogue Count)   |
-/// +-------+--------+--------------+-------------------------------+
-///
-/// Function Length : 18-bit field indicating the total length of the function
-///                   in bytes divided by 2.  If a function is larger than
-///                   512KB, then multiple pdata and xdata records must be used.
-/// Vers : 2-bit field describing the version of the remaining structure.  Only
-///        version 0 is currently defined (values 1-3 are not permitted).
-/// X : 1-bit field indicating the presence of exception data
-/// E : 1-bit field indicating that the single epilogue is packed into the
-///     header
-/// F : 1-bit field indicating that the record describes a function fragment
-///     (implies that no prologue is present, and prologue processing should be
-///     skipped) (ARM only)
-/// Epilogue Count : 5-bit field that differs in meaning based on the E field.
-///
-///                  If E is set, then this field specifies the index of the
-///                  first unwind code describing the (only) epilogue.
-///
-///                  Otherwise, this field indicates the number of exception
-///                  scopes.  If more than 31 scopes exist, then this field and
-///                  the Code Words field must both be set to 0 to indicate that
-///                  an extension word is required.
-/// Code Words : 4-bit (5-bit on ARM64) field that specifies the number of
-///              32-bit words needed to contain all the unwind codes.  If more
-///              than 15 words (31 words on ARM64) are required, then this field
-///              and the Epilogue Count field must both be set to 0 to indicate
-///              that an extension word is required.
-/// Extended Epilogue Count, Extended Code Words :
-///                          Valid only if Epilog Count and Code Words are both
-///                          set to 0.  Provides an 8-bit extended code word
-///                          count and 16-bits for epilogue count
-///
-/// The epilogue scope format on ARM is:
-///
-///  3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
-///  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
-/// +----------------+------+---+---+-------------------------------+
-/// |  Ep Start Idx  | Cond |Res|       Epilogue Start Offset       |
-/// +----------------+------+---+-----------------------------------+
-///
-/// The epilogue scope format on ARM64 is:
-///
-///  3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
-///  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
-/// +-------------------+-------+---+-------------------------------+
-/// |  Ep Start Idx     |  Res  |   Epilogue Start Offset           |
-/// +-------------------+-------+-----------------------------------+
-///
-/// If the E bit is unset in the header, the header is followed by a series of
-/// epilogue scopes, which are sorted by their offset.
-///
-/// Epilogue Start Offset: 18-bit field encoding the offset of epilogue relative
-///                        to the start of the function in bytes divided by two
-/// Res : 2-bit field reserved for future expansion (must be set to 0)
-/// Condition : (ARM only) 4-bit field providing the condition under which the
-///             epilogue is executed.  Unconditional epilogues should set this
-///             field to 0xe. Epilogues must be entirely conditional or
-///             unconditional, and in Thumb-2 mode.  The epilogue begins with
-///             the first instruction after the IT opcode.
-/// Epilogue Start Index : 8-bit field indicating the byte index of the first
-///                        unwind code describing the epilogue
-///
-///  3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
-///  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
-/// +---------------+---------------+---------------+---------------+
-/// | Unwind Code 3 | Unwind Code 2 | Unwind Code 1 | Unwind Code 0 |
-/// +---------------+---------------+---------------+---------------+
-///
-/// Following the epilogue scopes, the byte code describing the unwinding
-/// follows.  This is padded to align up to word alignment.  Bytes are stored in
-/// little endian.
-///
-///  3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
-///  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
-/// +---------------------------------------------------------------+
-/// |           Exception Handler RVA (requires X = 1)              |
-/// +---------------------------------------------------------------+
-/// |  (possibly followed by data required for exception handler)   |
-/// +---------------------------------------------------------------+
-///
-/// If the X bit is set in the header, the unwind byte code is followed by the
-/// exception handler information.  This constants of one Exception Handler RVA
-/// which is the address to the exception handler, followed immediately by the
-/// variable length data associated with the exception handler.
-///
-
-struct EpilogueScope {
-  const support::ulittle32_t ES;
-
-  EpilogueScope(const support::ulittle32_t Data) : ES(Data) {}
-  // Same for both ARM and AArch64.
-  uint32_t EpilogueStartOffset() const {
-    return (ES & 0x0003ffff);
-  }
-
-  // Different implementations for ARM and AArch64.
-  uint8_t ResARM() const {
-    return ((ES & 0x000c0000) >> 18);
-  }
-
-  uint8_t ResAArch64() const {
-    return ((ES & 0x000f0000) >> 18);
-  }
-
-  // Condition is only applicable to ARM.
-  uint8_t Condition() const {
-    return ((ES & 0x00f00000) >> 20);
-  }
-
-  // Different implementations for ARM and AArch64.
-  uint8_t EpilogueStartIndexARM() const {
-    return ((ES & 0xff000000) >> 24);
-  }
-
-  uint16_t EpilogueStartIndexAArch64() const {
-    return ((ES & 0xffc00000) >> 22);
-  }
-};
-
-struct ExceptionDataRecord;
-inline size_t HeaderWords(const ExceptionDataRecord &XR);
-
-struct ExceptionDataRecord {
-  const support::ulittle32_t *Data;
-  bool isAArch64;
-
-  ExceptionDataRecord(const support::ulittle32_t *Data, bool isAArch64) :
-    Data(Data), isAArch64(isAArch64) {}
-
-  uint32_t FunctionLength() const {
-    return (Data[0] & 0x0003ffff);
-  }
-
-  uint32_t FunctionLengthInBytesARM() const {
-    return FunctionLength() << 1;
-  }
-
-  uint32_t FunctionLengthInBytesAArch64() const {
-    return FunctionLength() << 2;
-  }
-
-  uint8_t Vers() const {
-    return (Data[0] & 0x000C0000) >> 18;
-  }
-
-  bool X() const {
-    return ((Data[0] & 0x00100000) >> 20);
-  }
-
-  bool E() const {
-    return ((Data[0] & 0x00200000) >> 21);
-  }
-
-  bool F() const {
-    assert(!isAArch64 && "Fragments are only supported on ARMv7 WinEH");
-    return ((Data[0] & 0x00400000) >> 22);
-  }
-
-  uint16_t EpilogueCount() const {
-    if (HeaderWords(*this) == 1) {
-      if (isAArch64)
-        return (Data[0] & 0x07C00000) >> 22;
-      return (Data[0] & 0x0f800000) >> 23;
-    }
-    return Data[1] & 0x0000ffff;
-  }
-
-  uint8_t CodeWords() const {
-    if (HeaderWords(*this) == 1) {
-      if (isAArch64)
-        return (Data[0] & 0xf8000000) >> 27;
-      return (Data[0] & 0xf0000000) >> 28;
-    }
-    return (Data[1] & 0x00ff0000) >> 16;
-  }
-
-  ArrayRef<support::ulittle32_t> EpilogueScopes() const {
-    assert(E() == 0 && "epilogue scopes are only present when the E bit is 0");
-    size_t Offset = HeaderWords(*this);
-    return ArrayRef(&Data[Offset], EpilogueCount());
-  }
-
-  ArrayRef<uint8_t> UnwindByteCode() const {
-    const size_t Offset = HeaderWords(*this)
-                        + (E() ? 0 :  EpilogueCount());
-    const uint8_t *ByteCode =
-      reinterpret_cast<const uint8_t *>(&Data[Offset]);
-    return ArrayRef(ByteCode, CodeWords() * sizeof(uint32_t));
-  }
-
-  uint32_t ExceptionHandlerRVA() const {
-    assert(X() && "Exception Handler RVA is only valid if the X bit is set");
-    return Data[HeaderWords(*this) + (E() ? 0 : EpilogueCount()) + CodeWords()];
-  }
-
-  uint32_t ExceptionHandlerParameter() const {
-    assert(X() && "Exception Handler RVA is only valid if the X bit is set");
-    return Data[HeaderWords(*this) + (E() ? 0 : EpilogueCount()) + CodeWords() +
-                1];
-  }
-};
-
-inline size_t HeaderWords(const ExceptionDataRecord &XR) {
-  if (XR.isAArch64)
-    return (XR.Data[0] & 0xffc00000) ? 1 : 2;
-  return (XR.Data[0] & 0xff800000) ? 1 : 2;
-}
-}
-}
-}
-
-#endif
diff --git a/tool/_testcpp/llvm-22.1.8-support/include/llvm/Support/Automaton.h b/tool/_testcpp/llvm-22.1.8-support/include/llvm/Support/Automaton.h
deleted file mode 100644
index 25573303..00000000
--- a/tool/_testcpp/llvm-22.1.8-support/include/llvm/Support/Automaton.h
+++ /dev/null
@@ -1,261 +0,0 @@
-//===-- Automaton.h - Support for driving TableGen-produced DFAs ----------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements class that drive and introspect deterministic finite-
-// state automata (DFAs) as generated by TableGen's -gen-automata backend.
-//
-// For a description of how to define an automaton, see
-// include/llvm/TableGen/Automaton.td.
-//
-// One important detail is that these deterministic automata are created from
-// (potentially) nondeterministic definitions. Therefore a unique sequence of
-// input symbols will produce one path through the DFA but multiple paths
-// through the original NFA. An automaton by default only returns "accepted" or
-// "not accepted", but frequently we want to analyze what NFA path was taken.
-// Finding a path through the NFA states that results in a DFA state can help
-// answer *what* the solution to a problem was, not just that there exists a
-// solution.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_AUTOMATON_H
-#define LLVM_SUPPORT_AUTOMATON_H
-
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/Allocator.h"
-#include <deque>
-#include <map>
-#include <memory>
-
-namespace llvm {
-
-using NfaPath = SmallVector<uint64_t, 4>;
-
-/// Forward define the pair type used by the automata transition info tables.
-///
-/// Experimental results with large tables have shown a significant (multiple
-/// orders of magnitude) parsing speedup by using a custom struct here with a
-/// trivial constructor rather than std::pair<uint64_t, uint64_t>.
-struct NfaStatePair {
-  uint64_t FromDfaState, ToDfaState;
-
-  bool operator<(const NfaStatePair &Other) const {
-    return std::make_tuple(FromDfaState, ToDfaState) <
-           std::make_tuple(Other.FromDfaState, Other.ToDfaState);
-  }
-};
-
-namespace internal {
-/// The internal class that maintains all possible paths through an NFA based
-/// on a path through the DFA.
-class NfaTranscriber {
-private:
-  /// Cached transition table. This is a table of NfaStatePairs that contains
-  /// zero-terminated sequences pointed to by DFA transitions.
-  ArrayRef<NfaStatePair> TransitionInfo;
-
-  /// A simple linked-list of traversed states that can have a shared tail. The
-  /// traversed path is stored in reverse order with the latest state as the
-  /// head.
-  struct PathSegment {
-    uint64_t State;
-    PathSegment *Tail;
-  };
-
-  /// We allocate segment objects frequently. Allocate them upfront and dispose
-  /// at the end of a traversal rather than hammering the system allocator.
-  SpecificBumpPtrAllocator<PathSegment> Allocator;
-
-  /// Heads of each tracked path. These are not ordered.
-  std::deque<PathSegment *> Heads;
-
-  /// The returned paths. This is populated during getPaths.
-  SmallVector<NfaPath, 4> Paths;
-
-  /// Create a new segment and return it.
-  PathSegment *makePathSegment(uint64_t State, PathSegment *Tail) {
-    PathSegment *P = Allocator.Allocate();
-    *P = {State, Tail};
-    return P;
-  }
-
-  /// Pairs defines a sequence of possible NFA transitions for a single DFA
-  /// transition.
-  void transition(ArrayRef<NfaStatePair> Pairs) {
-    // Iterate over all existing heads. We will mutate the Heads deque during
-    // iteration.
-    unsigned NumHeads = Heads.size();
-    for (unsigned I = 0; I < NumHeads; ++I) {
-      PathSegment *Head = Heads[I];
-      // The sequence of pairs is sorted. Select the set of pairs that
-      // transition from the current head state.
-      auto PI = lower_bound(Pairs, NfaStatePair{Head->State, 0ULL});
-      auto PE = upper_bound(Pairs, NfaStatePair{Head->State, INT64_MAX});
-      // For every transition from the current head state, add a new path
-      // segment.
-      for (; PI != PE; ++PI)
-        if (PI->FromDfaState == Head->State)
-          Heads.push_back(makePathSegment(PI->ToDfaState, Head));
-    }
-    // Now we've iterated over all the initial heads and added new ones,
-    // dispose of the original heads.
-    Heads.erase(Heads.begin(), std::next(Heads.begin(), NumHeads));
-  }
-
-public:
-  NfaTranscriber(ArrayRef<NfaStatePair> TransitionInfo)
-      : TransitionInfo(TransitionInfo) {
-    reset();
-  }
-
-  ArrayRef<NfaStatePair> getTransitionInfo() const {
-    return TransitionInfo;
-  }
-
-  void reset() {
-    Paths.clear();
-    Heads.clear();
-    Allocator.DestroyAll();
-    // The initial NFA state is 0.
-    Heads.push_back(makePathSegment(0ULL, nullptr));
-  }
-
-  void transition(unsigned TransitionInfoIdx) {
-    unsigned EndIdx = TransitionInfoIdx;
-    while (TransitionInfo[EndIdx].ToDfaState != 0)
-      ++EndIdx;
-    ArrayRef<NfaStatePair> Pairs(&TransitionInfo[TransitionInfoIdx],
-                                 EndIdx - TransitionInfoIdx);
-    transition(Pairs);
-  }
-
-  ArrayRef<NfaPath> getPaths() {
-    Paths.clear();
-    for (auto *Head : Heads) {
-      NfaPath P;
-      while (Head->State != 0) {
-        P.push_back(Head->State);
-        Head = Head->Tail;
-      }
-      std::reverse(P.begin(), P.end());
-      Paths.push_back(std::move(P));
-    }
-    return Paths;
-  }
-};
-} // namespace internal
-
-/// A deterministic finite-state automaton. The automaton is defined in
-/// TableGen; this object drives an automaton defined by tblgen-emitted tables.
-///
-/// An automaton accepts a sequence of input tokens ("actions"). This class is
-/// templated on the type of these actions.
-template <typename ActionT> class Automaton {
-  /// Map from {State, Action} to {NewState, TransitionInfoIdx}.
-  /// TransitionInfoIdx is used by the DfaTranscriber to analyze the transition.
-  /// FIXME: This uses a std::map because ActionT can be a pair type including
-  /// an enum. In particular DenseMapInfo<ActionT> must be defined to use
-  /// DenseMap here.
-  /// This is a shared_ptr to allow very quick copy-construction of Automata; this
-  /// state is immutable after construction so this is safe.
-  using MapTy = std::map<std::pair<uint64_t, ActionT>, std::pair<uint64_t, unsigned>>;
-  std::shared_ptr<MapTy> M;
-  /// An optional transcription object. This uses much more state than simply
-  /// traversing the DFA for acceptance, so is heap allocated.
-  std::shared_ptr<internal::NfaTranscriber> Transcriber;
-  /// The initial DFA state is 1.
-  uint64_t State = 1;
-  /// True if we should transcribe and false if not (even if Transcriber is defined).
-  bool Transcribe;
-
-public:
-  /// Create an automaton.
-  /// \param Transitions The Transitions table as created by TableGen. Note that
-  ///                    because the action type differs per automaton, the
-  ///                    table type is templated as ArrayRef<InfoT>.
-  /// \param TranscriptionTable The TransitionInfo table as created by TableGen.
-  ///
-  /// Providing the TranscriptionTable argument as non-empty will enable the
-  /// use of transcription, which analyzes the possible paths in the original
-  /// NFA taken by the DFA. NOTE: This is substantially more work than simply
-  /// driving the DFA, so unless you require the getPaths() method leave this
-  /// empty.
-  template <typename InfoT>
-  Automaton(ArrayRef<InfoT> Transitions,
-            ArrayRef<NfaStatePair> TranscriptionTable = {}) {
-    if (!TranscriptionTable.empty())
-      Transcriber =
-          std::make_shared<internal::NfaTranscriber>(TranscriptionTable);
-    Transcribe = Transcriber != nullptr;
-    M = std::make_shared<MapTy>();
-    for (const auto &I : Transitions)
-      // Greedily read and cache the transition table.
-      M->emplace(std::make_pair(I.FromDfaState, I.Action),
-                 std::make_pair(I.ToDfaState, I.InfoIdx));
-  }
-  Automaton(const Automaton &Other)
-      : M(Other.M), State(Other.State), Transcribe(Other.Transcribe) {
-    // Transcriber is not thread-safe, so create a new instance on copy.
-    if (Other.Transcriber)
-      Transcriber = std::make_shared<internal::NfaTranscriber>(
-          Other.Transcriber->getTransitionInfo());
-  }
-
-  /// Reset the automaton to its initial state.
-  void reset() {
-    State = 1;
-    if (Transcriber)
-      Transcriber->reset();
-  }
-
-  /// Enable or disable transcription. Transcription is only available if
-  /// TranscriptionTable was provided to the constructor.
-  void enableTranscription(bool Enable = true) {
-    assert(Transcriber &&
-           "Transcription is only available if TranscriptionTable was provided "
-           "to the Automaton constructor");
-    Transcribe = Enable;
-  }
-
-  /// Transition the automaton based on input symbol A. Return true if the
-  /// automaton transitioned to a valid state, false if the automaton
-  /// transitioned to an invalid state.
-  ///
-  /// If this function returns false, all methods are undefined until reset() is
-  /// called.
-  bool add(const ActionT &A) {
-    auto I = M->find({State, A});
-    if (I == M->end())
-      return false;
-    if (Transcriber && Transcribe)
-      Transcriber->transition(I->second.second);
-    State = I->second.first;
-    return true;
-  }
-
-  /// Return true if the automaton can be transitioned based on input symbol A.
-  bool canAdd(const ActionT &A) {
-    auto I = M->find({State, A});
-    return I != M->end();
-  }
-
-  /// Obtain a set of possible paths through the input nondeterministic
-  /// automaton that could be obtained from the sequence of input actions
-  /// presented to this deterministic automaton.
-  ArrayRef<NfaPath> getNfaPaths() {
-    assert(Transcriber && Transcribe &&
-           "Can only obtain NFA paths if transcribing!");
-    return Transcriber->getPaths();
-  }
-};
-
-} // namespace llvm
-
-#endif // LLVM_SUPPORT_AUTOMATON_H
diff --git a/tool/_testcpp/llvm-22.1.8-support/iterator_range/out.go b/tool/_testcpp/llvm-22.1.8-support/iterator_range/out.go
new file mode 100644
index 00000000..60edcfb7
--- /dev/null
+++ b/tool/_testcpp/llvm-22.1.8-support/iterator_range/out.go
@@ -0,0 +1,3 @@
+package iterator_range
+
+const LLGoPackage = "link: -L$(llvm-config --libdir) -lLLVM; -lLLVM"
diff --git a/tool/_testcpp/llvm-22.1.8-support/llcppg-adt.cfg b/tool/_testcpp/llvm-22.1.8-support/llcppg-adt.cfg
new file mode 100644
index 00000000..8790d899
--- /dev/null
+++ b/tool/_testcpp/llvm-22.1.8-support/llcppg-adt.cfg
@@ -0,0 +1,16 @@
+{
+	"Name": "/adt",
+	"Dir": "./include/llvm/ADT",
+	"Class": [],
+	"NonClass": [],
+	"FuncPrefix": ["Llvm"],
+	"EnumPrefix": ["Llvm"],
+	"TypePrefix": ["Llvm"],
+	"MacroPrefix": ["LLVM_"],
+	"TypeAbbr": {
+	},
+	"Rename": {
+	},
+	"TypeIgnore": [],
+	"NSIgnore": []
+}
diff --git a/tool/_testcpp/llvm-22.1.8-support/llcppg-system.cfg b/tool/_testcpp/llvm-22.1.8-support/llcppg-system.cfg
index 2caa0928..a8b2b616 100644
--- a/tool/_testcpp/llvm-22.1.8-support/llcppg-system.cfg
+++ b/tool/_testcpp/llvm-22.1.8-support/llcppg-system.cfg
@@ -3,9 +3,10 @@
 	"Dir": "./include/llvm/Support",
 	"Class": [],
 	"NonClass": [],
-	"FuncPrefix": [],
+	"FuncPrefix": ["Llvm"],
 	"EnumPrefix": ["Llvm"],
 	"TypePrefix": ["Llvm"],
+	"MacroPrefix": ["LLVM_"],
 	"TypeAbbr": {
 	},
 	"Rename": {
diff --git a/tool/_testcpp/llvm-22.1.8-support/llcppg.cfg b/tool/_testcpp/llvm-22.1.8-support/llcppg.cfg
index ec2595da..57c1dfb1 100644
--- a/tool/_testcpp/llvm-22.1.8-support/llcppg.cfg
+++ b/tool/_testcpp/llvm-22.1.8-support/llcppg.cfg
@@ -3,6 +3,6 @@
 	"LLGoPackage": "link: -L$(llvm-config --libdir) -lLLVM; -lLLVM",
 	"Stdlib": "",
 	"Deps": ["libcxx", "llvm-c"],
-    "Pkgs": ["system"],
+    "Pkgs": ["system", "adt"],
 	"Language": "c++"
 }
diff --git a/tool/gen_test.go b/tool/gen_test.go
index e369e995..bb50a3ad 100644
--- a/tool/gen_test.go
+++ b/tool/gen_test.go
@@ -162,7 +162,7 @@ func testSingleFile(t *testing.T, idx clang.Index, pkgDir, headerDir, headerFile
 	testGenGo(t, pkg.Package, pkgDir, "", exp)
 }
 
-func testFromDir(t *testing.T, sel, relDir string, single bool) {
+func testFromDir(t *testing.T, sel, relDir string, single bool, subPkg ...string) {
 	dirSel := sel
 	if single {
 		dirSel = ""
@@ -177,18 +177,26 @@ func testFromDir(t *testing.T, sel, relDir string, single bool) {
 			log.Fatal("LoadConf failed:", err)
 		}
 
-		switch len(conf.Pkgs) {
-		case 0:
-		case 1:
-			cfgFile := pkgDir + "/llcppg-" + conf.Pkgs[0] + ".cfg"
+		var pkgSel string
+		if len(subPkg) > 0 {
+			pkgSel = subPkg[0]
+		} else {
+			switch len(conf.Pkgs) {
+			case 0:
+			case 1:
+				pkgSel = conf.Pkgs[0]
+			default:
+				t.Fatal("conf.Pkgs can't be multi-packages for testing")
+			}
+		}
+		if pkgSel != "" {
+			cfgFile := pkgDir + "/llcppg-" + pkgSel + ".cfg"
 			subConf, err := tool.LoadConf(cfgFile)
 			if err != nil {
 				t.Fatal("LoadConf failed:", err)
 			}
 			subConf.Apply(&conf)
 			conf = subConf
-		default:
-			t.Fatal("conf.Pkgs can't be multi-packages for testing")
 		}
 
 		if single {
@@ -257,21 +265,29 @@ func TestSingleC(t *testing.T) {
 }
 
 func TestLLVM_AMDGPUAddrSpace(t *testing.T) {
-	testFromDir(t, "AMDGPUAddrSpace", "./_testcpp", true)
+	testFromDir(t, "AMDGPUAddrSpace", "./_testcpp", true, "system")
 }
 
 func TestLLVM_AMDHSAKernelDescriptor(t *testing.T) {
-	testFromDir(t, "AMDHSAKernelDescriptor", "./_testcpp", true)
+	testFromDir(t, "AMDHSAKernelDescriptor", "./_testcpp", true, "system")
 }
 
 func TestLLVM_AtomicOrdering(t *testing.T) {
-	testFromDir(t, "AtomicOrdering", "./_testcpp", true)
+	testFromDir(t, "AtomicOrdering", "./_testcpp", true, "system")
 }
 
 func TestLLVM_Atomic(t *testing.T) {
-	testFromDir(t, "Atomic", "./_testcpp", true)
+	testFromDir(t, "Atomic", "./_testcpp", true, "system")
 }
 
 func TestLLVM_Compiler(t *testing.T) {
-	testFromDir(t, "Compiler", "./_testcpp", true)
+	testFromDir(t, "Compiler", "./_testcpp", true, "system")
+}
+
+func TestLLVM_DenseMapInfo(t *testing.T) {
+	testFromDir(t, "DenseMapInfo", "./_testcpp", true, "adt")
+}
+
+func _TestLLVM_String(t *testing.T) {
+	testFromDir(t, "StringRef", "./_testcpp", true, "adt")
 }