// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 20029: make sure we zero at VARKILLs of
// ambiguously live variables.
// The ambiguously live variable here is the hiter
// for the inner range loop.

package main

import "runtime"

func f(m map[int]int) {
outer:
	for i := 0; i < 10; i++ {
		for k := range m {
			if k == 5 {

	for i := 0; i < 1000000; i++ {
		_ = identity(u)         // installs u at return slot
		_ = liveReturnSlot(nil) // incorrectly marks return slot as live
	}
}

//go:noinline
func liveReturnSlot(x *int) *int {
	defer func() {}() // causes return slot to be marked live
	sink = &x         // causes x to be moved to the heap, triggering allocation
	return x
}

//go:noinline
func identity(x uintptr) uintptr {
	return x

	}
	liveObjVersioned, err := f.toVersioned(liveObj)
	if err != nil {
		return nil, nil, fmt.Errorf("failed to convert live object (%v) to proper version: %v", objectGVKNN(liveObj), err)
	}
	newObjTyped, err := f.typeConverter.ObjectToTyped(newObjVersioned, typed.AllowDuplicates)
	if err != nil {

}

func GCMemoryLimit() {
	gcMemoryLimit(100)
}

func GCMemoryLimitNoGCPercent() {
	gcMemoryLimit(-1)
}

// Test SetMemoryLimit functionality.
//
// This test lives here instead of runtime/debug because the entire
// implementation is in the runtime, and testprog gives us a more
// consistent testing environment to help avoid flakiness.
func gcMemoryLimit(gcPercent int) {

	runtime.ReadMemStats(&m.curMark.endM)
	if m.gc == GC {
		runtime.GC()
		runtime.ReadMemStats(&m.curMark.gcM)
		if m.shouldPProf() {
			// Collect a profile of the live heap. Do a
			// second GC to force sweep completion so we
			// get a complete snapshot of the live heap at
			// the end of this phase.
			runtime.GC()
			f, err := os.Create(makePProfFilename(m.filebase, m.curMark.name, "memprof"))
			if err != nil {

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

/**
 * Test that ArtifactView has a "live" view of the underlying configuration's attributes.
 */
class ArtifactViewAttributesIntegrationTest extends AbstractIntegrationSpec {
    def "artifact view has live view of underlying configuration attributes"() {
        buildFile << """
            def usage = Attribute.of('usage', String)

            '''
                /**
                 * A person.
                 * Can live in a house.
                 * Has a name and an age.
                 */
                class Person(val name: String, val age: Int)'''.stripIndent(),
            '''
                /**
                 * A person.
                 * Can live in a house.
                 * Has a name, age and a height.
                 */

	badPtr = uintptr(unsafe.Pointer(&b[len(b)-1])) + 1
}

var throttle = make(chan struct{}, 10)

// There are 2 arg bitmaps for this function, each with 2 bits.
// In the first, p and q are both live, so that bitmap is 11.
// In the second, only p is live, so that bitmap is 10.
// Bitmaps are byte aligned, so if the first bitmap is interpreted as
// extending across the entire argument area, we incorrectly concatenate

//   - It sets IsCA to false.
//   - It validates that the signer has not expired.
//   - It sets NotBefore and NotAfter:
//     All certificates set NotBefore = Now() - Backdate.
//     Long-lived certificates set NotAfter = Now() + TTL - Backdate.
//     Short-lived certificates set NotAfter = Now() + TTL.
//     All certificates truncate NotAfter to the expiration date of the signer.
type PermissiveSigningPolicy struct {

	score := f.Cache.allocInt8Slice(f.NumValues())
	defer f.Cache.freeInt8Slice(score)

	// maps mem values to the next live memory value
	nextMem := f.Cache.allocValueSlice(f.NumValues())
	defer f.Cache.freeValueSlice(nextMem)

	// inBlockUses records whether a value is used in the block
	// in which it lives. (block control values don't count as uses.)
	inBlockUses := f.Cache.allocBoolSlice(f.NumValues())