John Howard <******@****.***> 1605827959 -0800

	Get SP
	I64Load a_base+0(FP)
	I64Load a_len+8(FP)
	I64Load b_base+16(FP)
	I64Load b_len+24(FP)
	Call cmpbody<>(SB)
	I64Store ret+32(FP)
	RET

// params: a, alen, b, blen
// ret: -1/0/1
TEXT cmpbody<>(SB), NOSPLIT, $0-0
	// len = min(alen, blen)
	Get R1
	Get R3
	Get R1
	Get R3
	I64LtU
	Select
	Set R4

	Get R0
	I32WrapI64
	Get R2
	I32WrapI64
	Get R4
	I32WrapI64
	Call memcmp<>(SB)

func ParseNetlinkMessage(b []byte) ([]NetlinkMessage, error) {
	var msgs []NetlinkMessage
	for len(b) >= NLMSG_HDRLEN {
		h, dbuf, dlen, err := netlinkMessageHeaderAndData(b)
		if err != nil {
			return nil, err
		}
		m := NetlinkMessage{Header: *h, Data: dbuf[:int(h.Len)-NLMSG_HDRLEN]}
		msgs = append(msgs, m)
		b = b[dlen:]
	}
	return msgs, nil
}

	MOVD	a_base+0(FP), R3
	MOVD	a_len+8(FP), R4
	MOVD	b_base+16(FP), R5
	MOVD	b_len+24(FP), R6
	LA	ret+32(FP), R7
	BR	cmpbody<>(SB)

// input:
//   R3 = a
//   R4 = alen
//   R5 = b
//   R6 = blen
//   R7 = address of output word (stores -1/0/1 here)
TEXT cmpbody<>(SB),NOSPLIT|NOFRAME,$0-0
	CMPBEQ	R3, R5, cmplengths
	MOVD	R4, R8
	CMPBLE	R4, R6, amin
	MOVD	R6, R8
amin:

	clean, _ := m.clean.Load().(map[any]any)
	actual, loaded = clean[key]
	if loaded {
		return actual, loaded
	}

	m.mu.Lock()
	// Reload clean in case it changed while we were waiting on m.mu.
	clean, _ = m.clean.Load().(map[any]any)
	actual, loaded = clean[key]
	if !loaded {
		dirty := m.dirty()
		dirty[key] = value
		actual = value
		m.clean.Store(dirty)
	}
	m.mu.Unlock()

        val tasks = mock<TaskContainer> {
            on { register("clean") } doReturn taskProvider
        }

        tasks {

            val clean by registering

            inOrder(tasks, taskProvider) {
                verify(tasks).register("clean")
                verifyNoMoreInteractions()
            }

            assertInferredTypeOf(
                clean,
                typeOf<TaskProvider<Task>>()
            )

        then: "clean is still marked UP-TO-DATE"
        result.groupedOutput.task(":clean").outcome == "UP-TO-DATE"

        when: "the kotlin script compiler is invoked due to a script change"
        buildKotlinFile << "\n"
        succeeds "clean"
        then: "clean is still marked as UP-TO-DATE"
        result.groupedOutput.task(":clean").outcome == "UP-TO-DATE"
    }

type RawSockaddrDatalink struct {
	Len    uint8
	Family uint8
	Index  uint16
	Type   uint8
	Nlen   uint8
	Alen   uint8
	Slen   uint8
	Data   [12]int8
}

type RawSockaddr struct {
	Len    uint8
	Family uint8
	Data   [14]int8
}

type RawSockaddrAny struct {
	Addr RawSockaddr
	Pad  [92]int8
}

type _Socklen uint32

type Linger struct {
	Onoff  int32
	Linger int32
}

env GOCACHE=$WORK/cache

# Build something so that the cache gets populates
go build main.go

# Check that cache contains directories before running
exists $GOCACHE/00

# Run go clean -cache -n and ensure that directories weren't deleted
go clean -cache -n
exists $GOCACHE/00

# Re-run go clean cache without the -n flag go ensure that directories were properly removed
go clean -cache

# 'go clean -r -modcache' should clean only the dependencies that are within the
# main module.
# BUG(golang.org/issue/28680): Today, it cleans across module boundaries.
cd r
exists ./test.out
exists ../replaced/test.out
go clean -r -modcache
! exists ./test.out
! exists ../replaced/test.out  # BUG: should still exist

# 'go clean -modcache' should not download anything before cleaning.