const asanenabled = true

// asan{read,write} are nosplit because they may be called between
// fork and exec, when the stack must not grow. See issue #50391.

//go:linkname asanread
//go:nosplit
func asanread(addr unsafe.Pointer, sz uintptr) {
	sp := getcallersp()
	pc := getcallerpc()
	doasanread(addr, sz, sp, pc)
}

//go:linkname asanwrite
//go:nosplit

// license that can be found in the LICENSE file.

//go:build asan

package asan

import (
	"unsafe"
)

const Enabled = true

//go:linkname Read runtime.asanread
func Read(addr unsafe.Pointer, len uintptr)

//go:linkname Write runtime.asanwrite

package runtime

import (
	"unsafe"
)

const asanenabled = false

// Because asanenabled is false, none of these functions should be called.

func asanread(addr unsafe.Pointer, sz uintptr)            { throw("asan") }
func asanwrite(addr unsafe.Pointer, sz uintptr)           { throw("asan") }
func asanunpoison(addr unsafe.Pointer, sz uintptr)        { throw("asan") }

        try {
            final DaemonContext daemonContext = daemon.getDaemonContext();
            final File daemonRegistryDir = daemonContext.getDaemonRegistryDir();
            if (!new DaemonDir(daemonRegistryDir).getRegistry().canRead()) {
                LOG.warn("Daemon registry {} became unreadable. Expiring daemon.", daemonRegistryDir);
                return new DaemonExpirationResult(GRACEFUL_EXPIRE, REGISTRY_BECAME_UNREADABLE);
            } else {

        try {
            Assert.assertTrue("$dir exists", dir.exists())
            Assert.assertTrue("$dir is a directory", dir.isDirectory())
            Assert.assertFalse("$dir is not readable", dir.canRead())
            Assert.assertTrue("$dir is writable", dir.canWrite())

            testFile('build.gradle') << '''
                task copy(type: Copy) {
                    from 'src'
                    into 'dest'

                    }
                }
            }
        } else {
            File pluginXml = new File(extensionJar, getExtensionDescriptorLocation());

            if (pluginXml.canRead()) {
                try (InputStream is = Files.newInputStream(pluginXml.toPath())) {
                    extensionDescriptor = build(is);
                }
            }
        }

            if (!directory.isDirectory()) {
                throw new IllegalArgumentException(String.format("Cache directory %s must be a directory", directory));
            }
            if (!directory.canRead()) {
                throw new IllegalArgumentException(String.format("Cache directory %s must be readable", directory));
            }
            if (!directory.canWrite()) {

            for (String fileName : fileNames) {
                File candidate = new File(fileName);
                if (candidate.isFile() && candidate.canRead()) {
                    storePath = fileName;
                    break;
                } else if (!fileName.equals(getDefaultJsseTrustStore())) {

            PatternStep step = PatternStepFactory.getStep(segment, false);
            File[] children = file.listFiles();
            if (children == null) {
                if (!file.canRead()) {
                    throw new GradleException(String.format("Could not list contents of directory '%s' as it is not readable.", file));
                }

	trace := traceAcquire()
	if !trace.ok() {
		throw("traceSnapshotMemory: tracing is not enabled")
	}

	// Write out all the heap spans and heap objects.
	for _, s := range mheap_.allspans {
		if s.state.get() == mSpanDead {
			continue
		}
		// It's some kind of span, so trace that it exists.
		trace.SpanExists(s)

		// Write out allocated objects if it's a heap span.
		if s.state.get() != mSpanInUse {
			continue
		}