func CurrentStats() map[string]types.TargetStats {
	sys := SystemTargets()
	audit := AuditTargets()
	res := make(map[string]types.TargetStats, len(sys)+len(audit))
	cnt := make(map[string]int, len(sys)+len(audit))

	// Add system and audit.
	for _, t := range sys {
		key := strings.ToLower(t.Type().String())
		n := cnt[key]
		cnt[key]++
		key = fmt.Sprintf("sys_%s_%d", key, n)
		res[key] = t.Stats()
	}

		# https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/include/uapi/asm-generic/unistd.h?id=refs/heads/master#n716
		return;
	}
	$name =~ y/a-z/A-Z/;
	$num = $num + $offset;
	print "	SYS_$name = $num;\n";
}

my $prev;
open(GCC, "gcc -E -dD $ARGV[0] |") || die "can't run gcc";
while(<GCC>){
	if(/^#define __NR_Linux\s+([0-9]+)/){
		# mips/mips64: extract offset
		$offset = $1;
	}

	tg.parallel()
	tg.tempDir("src/syso")
	tg.tempFile("src/syso/a.syso", ``)
	tg.tempFile("src/syso/b.go", `package syso`)
	tg.setenv("GOPATH", tg.path("."))

	// We should see the .syso file regardless of the setting of
	// CGO_ENABLED.

	tg.setenv("CGO_ENABLED", "1")
	tg.run("list", "-f", "{{.SysoFiles}}", "syso")
	tg.grepStdout("a.syso", "missing syso file with CGO_ENABLED=1")

			checkPkg(t, m, pkg, data)
		}
	})
}

func TestImportRaw_IgnoreNonGo(t *testing.T) {
	path := filepath.Join("testdata", "ignore_non_source")
	p := importRaw(path, ".")

	wantFiles := []string{"a.syso", "b.go", "c.c"}

	var gotFiles []string
	for i := range p.sourceFiles {
		gotFiles = append(gotFiles, p.sourceFiles[i].name)
	}

	if !reflect.DeepEqual(gotFiles, wantFiles) {

	"SWPALH",
	"SWPALW",
	"SWPAW",
	"SWPB",
	"SWPD",
	"SWPH",
	"SWPLB",
	"SWPLD",
	"SWPLH",
	"SWPLW",
	"SWPW",
	"SXTB",
	"SXTBW",
	"SXTH",
	"SXTHW",
	"SXTW",
	"SYS",
	"SYSL",
	"TBNZ",
	"TBZ",
	"TLBI",
	"TST",
	"TSTW",
	"UBFIZ",
	"UBFIZW",
	"UBFM",
	"UBFMW",
	"UBFX",
	"UBFXW",
	"UCVTFD",
	"UCVTFS",
	"UCVTFWD",
	"UCVTFWS",
	"UDIV",

# Test that syso in deps is available to cgo.

[!compiler:gc] skip 'requires syso support'
[!cgo] skip
[short] skip 'invokes system C compiler'

# External linking is not supported on linux/ppc64.
# See: https://github.com/golang/go/issues/8912
[GOOS:linux] [GOARCH:ppc64] skip

cc -c -o syso/x.syso syso/x.c
cc -c -o syso2/x.syso syso2/x.c
go build m/cgo

-- go.mod --
module m

go 1.18
-- cgo/x.go --
package cgo

# Test that we can use the external linker with a host syso file that is
# embedded in a package, that is referenced by a Go assembly function.
# See issue 33139.

[!compiler:gc] skip
[!cgo] skip
[short] skip 'invokes system C compiler'

# External linking is not supported on linux/ppc64.
# See: https://github.com/golang/go/issues/8912
[GOOS:linux] [GOARCH:ppc64] skip

cc -c -o syso/objTestImpl.syso syso/src/objTestImpl.c

	if out, err := testenv.Command(t, cc, append(cflags, "-c", "-o", asmObj, asmFile)...).CombinedOutput(); err != nil {
		t.Logf("%s", out)
		t.Fatal(err)
	}

	asm2Obj := filepath.Join(dir, "x2.syso")
	t.Logf("%s --rename-section .text2=.text1 %s %s", objcopy, asmObj, asm2Obj)
	if out, err := testenv.Command(t, objcopy, "--rename-section", ".text2=.text1", asmObj, asm2Obj).CombinedOutput(); err != nil {
		t.Logf("%s", out)

---

This directory holds the core of the BoringCrypto implementation
as well as the build scripts for the module itself: syso/*.syso.

syso/goboringcrypto_linux_amd64.syso is built with:

	GOARCH=amd64 ./build.sh

syso/goboringcrypto_linux_arm64.syso is built with:

	GOARCH=arm64 ./build.sh

Both run on an x86 Debian Linux system using Docker.
For the arm64 build to run on an x86 system, you need

esac

docker build $platform $buildargs --build-arg GOARCH=$GOARCH -t goboring:$GOARCH .
id=$(docker create $platform goboring:$GOARCH)
docker cp $id:/boring/godriver/goboringcrypto_linux_$GOARCH.syso ./syso
docker rm $id