Adrian Kuegel <******@****.***> 1698648479 -0700

Adrian Kuegel <******@****.***> 1648477243 -0700

	runtime.GC()
}

// Issue #29737 - make sure we can do inlining for a chain of recursive functions
func ee() { // ERROR "can inline ee"
	ff(100) // ERROR "inlining call to ff" "inlining call to gg" "inlining call to hh"
}

func ff(x int) { // ERROR "can inline ff"
	if x < 0 {
		return
	}
	gg(x - 1) // ERROR "inlining call to gg" "inlining call to hh"
}
func gg(x int) { // ERROR "can inline gg"

	// the RUnlock fast path should be inlined
	rwmutex.RUnlock() // ERROR "inlining call to sync\.\(\*RWMutex\)\.RUnlock" "inlining call to atomic\.\(\*Int32\)\.Add"
}

func small9() { // ERROR "can inline small9"
	// the RLock fast path should be inlined
	rwmutex.RLock() // ERROR "inlining call to sync\.\(\*RWMutex\)\.RLock" "inlining call to atomic\.\(\*Int32\)\.Add"

	runtime.GC()
}

// Issue #29737 - make sure we can do inlining for a chain of recursive functions
func ee() { // ERROR "can inline ee"
	ff(100) // ERROR "inlining call to ff" "inlining call to gg" "inlining call to hh"
}

func ff(x int) { // ERROR "can inline ff"
	if x < 0 {
		return
	}
	gg(x - 1) // ERROR "inlining call to gg" "inlining call to hh"
}
func gg(x int) { // ERROR "can inline gg"

	_ = a.G(1).(*int)                                 // ERROR "inlining call to a.G" "does not escape"
	_ = a.G(2.0).(*float64)                           // ERROR "inlining call to a.G" "does not escape"
	_ = (*a.G("").(*interface{})).(string)            // ERROR "inlining call to a.G" "does not escape"
	_ = (*a.G(([]byte)(nil)).(*interface{})).([]byte) // ERROR "inlining call to a.G" "does not escape"

					return a*x + b*y + c*z
				}(10) // ERROR "inlining call to main.func27.1.1"
			}(100) // ERROR "inlining call to main.func27.1" "inlining call to main.func27.main.func27.1.2"
		}(1000); r != 2350 { // ERROR "inlining call to main.func27" "inlining call to main.main.func27.func34" "inlining call to main.main.func27.main.main.func27.func34.func36"
			ppanic("r != 2350")
		}
	}

	{

	for _, x := range xs {
		b.WriteString(x)
	}
	return b.Len() // ERROR "inlining call to bytes.\(\*Buffer\).Len$"
}

func bufferNoEscape3(xs []string) string { // ERROR "xs does not escape$"
	b := bytes.NewBuffer(make([]byte, 0, 64)) // ERROR "&bytes.Buffer{...} does not escape$" "make\(\[\]byte, 0, 64\) does not escape$" "inlining call to bytes.NewBuffer$"

	return binary.LittleEndian.Uint64(b) + binary.BigEndian.Uint64(b) // ERROR "inlining call to binary.littleEndian.Uint64" "inlining call to binary.bigEndian.Uint64"
}

func appendLittleEndian(b []byte) []byte { // ERROR "can inline appendLittleEndian" "leaking param: b to result ~r0 level=0"
	b = binary.LittleEndian.AppendUint64(b, 64) // ERROR "inlining call to binary.littleEndian.AppendUint64"

		p = alloc(3) // ERROR "inlining call to alloc"
	}() // ERROR "inlining call to f1.func1" "inlining call to alloc" "moved to heap: x"

	f = func() { // ERROR "func literal escapes to heap" "can inline f1.func2"
		p = alloc(3) // ERROR "inlining call to alloc" "moved to heap: x"
	}
	f()
}

func f2() {} // ERROR "can inline f2"

// No inline for recover; panic now allowed to inline.