// https://golang.org/issue/37238
func TestGdbInfCallstack(t *testing.T) {
	checkGdbEnvironment(t)

	testenv.MustHaveCGO(t)
	if runtime.GOARCH != "arm64" {
		t.Skip("skipping infinite callstack test on non-arm64 arches")
	}

	t.Parallel()
	checkGdbVersion(t)

	dir := t.TempDir()

	// Build the source code.
	src := filepath.Join(dir, "main.go")
	err := os.WriteFile(src, []byte(InfCallstackSource), 0644)

quarrelling with the other players, and shouting `Off with his
head!' or `Off with her head!'  Those whom she sentenced were
taken into custody by the soldiers, who of course had to leave
off being arches to do this, so that by the end of half an hour
or so there were no arches left, and all the players, except the
King, the Queen, and Alice, were in custody and under sentence of
execution.

  Then the Queen left off, quite out of breath, and said to

quarrelling with the other players, and shouting `Off with his
head!' or `Off with her head!'  Those whom she sentenced were
taken into custody by the soldiers, who of course had to leave
off being arches to do this, so that by the end of half an hour
or so there were no arches left, and all the players, except the
King, the Queen, and Alice, were in custody and under sentence of
execution.

  Then the Queen left off, quite out of breath, and said to

			}

			// Flow backwards from the control value to find the
			// flag load. We don't know what lowered ops we're
			// looking for, but all current arches produce a
			// single op that does the memory load from the flag
			// address, so we look for that.
			var load *ssa.Value
			v := decisionBlock.Controls[0]
			for {
				if v.MemoryArg() != nil {

	MOVD	g_m(g), R3
	MOVD	m_curg(R3), g
	BL	runtime·save_g(SB)
	MOVD	(g_sched+gobuf_sp)(g), R1
	MOVD	R0, (g_sched+gobuf_sp)(g)
	RET

noswitch:
	// already on m stack, just call directly
	// On other arches we do a tail call here, but it appears to be
	// impossible to tail call a function pointer in shared mode on
	// ppc64 because the caller is responsible for restoring the TOC.
	MOVD	0(R11), R12	// code pointer
	MOVD	R12, CTR

	_NumStackOrders = 4 - goarch.PtrSize/4*goos.IsWindows - 1*goos.IsPlan9

	// heapAddrBits is the number of bits in a heap address. On
	// amd64, addresses are sign-extended beyond heapAddrBits. On
	// other arches, they are zero-extended.
	//
	// On most 64-bit platforms, we limit this to 48 bits based on a
	// combination of hardware and OS limitations.
	//
	// amd64 hardware limits addresses to 48 bits, sign-extended

apiVersion: release-notes/v2
kind: feature
area: installation
releaseNotes:
- |

pkg debug/macho, type FatArchHeader struct, Size uint32
pkg debug/macho, type FatArchHeader struct, SubCpu uint32
pkg debug/macho, type FatFile struct
pkg debug/macho, type FatFile struct, Arches []FatArch
pkg debug/macho, type FatFile struct, Magic uint32
pkg debug/macho, var ErrNotFat *FormatError
pkg debug/pe, type DataDirectory struct
pkg debug/pe, type DataDirectory struct, Size uint32

)

// split cache lookups across N striped caches
type stripedCache struct {
	stripeCount uint32
	hashFunc    func(string) uint32
	caches      []cache
}

type hashFunc func(string) uint32
type newCacheFunc func() cache

func newStripedCache(stripeCount int, hash hashFunc, newCacheFunc newCacheFunc) cache {
	caches := []cache{}
	for i := 0; i < stripeCount; i++ {
		caches = append(caches, newCacheFunc())
	}

public class ModuleRepositoryCacheProvider {
    private final ModuleRepositoryCaches caches;
    private final ModuleRepositoryCaches inMemoryCaches;
    private final ResolvedArtifactCaches resolvedArtifactCaches = new ResolvedArtifactCaches();

    public ModuleRepositoryCacheProvider(ModuleRepositoryCaches caches, ModuleRepositoryCaches inMemoryCaches) {
        this.caches = caches;
        this.inMemoryCaches = inMemoryCaches;
    }

    /**