p256 := ecdh.P256() // ERROR "inlining call to ecdh.P256"

	ourKey, err := p256.GenerateKey(rand.Reader) // ERROR "devirtualizing p256.GenerateKey" "inlining call to ecdh.*GenerateKey"
	if err != nil {
		return nil, err
	}

	peerPublic, err := p256.NewPublicKey(peerShare) // ERROR "devirtualizing p256.NewPublicKey" "inlining call to ecdh.*NewPublicKey"
	if err != nil {
		return nil, err
	}

	}
	tree.nodes = append(tree.nodes, call)
	return r
}

// AllParents invokes do on each InlinedCall in the inlining call
// stack, from outermost to innermost.
//
// That is, if inlIndex corresponds to f inlining g inlining h,
// AllParents invokes do with the call for inlining g into f, and then
// inlining h into g.
func (tree *InlTree) AllParents(inlIndex int, do func(InlinedCall)) {
	if inlIndex >= 0 {

package main

func run() { // ERROR "cannot inline run: recursive"
	f := func() { // ERROR "can inline run.func1 with cost .* as:.*" "func literal does not escape"
		g() // ERROR "inlining call to g"
	}
	f() // ERROR "inlining call to run.func1" "inlining call to g"
	run()
}

func g() { // ERROR "can inline g with cost .* as:.*"
}

func main() { // ERROR "can inline main with cost .* as:.*"
	run()

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

// Test that inlining works with generic functions.

package testcase

type C interface{ ~uint | ~uint32 | ~uint64 }

func isAligned[T C](x, y T) bool { // ERROR "can inline isAligned\[uint\]" "can inline isAligned\[go\.shape\.uint\]" "inlining call to isAligned\[go\.shape\.uint\]"
	return x%y == 0
}

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

package b

import "./a"

func g() {
	h := a.E() // ERROR "inlining call to a.E" "T\(0\) does not escape"
	h.M()      // ERROR "devirtualizing h.M to a.T" "inlining call to a.T.M"

	// BAD: T(0) could be stack allocated.
	i := a.F(a.T(0)) // ERROR "inlining call to a.F" "a.T\(0\) escapes to heap"

	// Testing that we do NOT devirtualize here:
	i.M()

	i = nil
	return i
}

func g() {
	h := E() // ERROR "inlining call to E" "T\(0\) does not escape"
	h.M()    // ERROR "devirtualizing h.M to T" "inlining call to T.M"

	// BAD: T(0) could be stack allocated.
	i := F(T(0)) // ERROR "inlining call to F" "T\(0\) escapes to heap"

	// Testing that we do NOT devirtualize here:
	i.M()

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

package q

import "./p"

func x() { // ERROR "can inline x"
	p.F() // ERROR "inlining call to .*\.F" "inlining call to .*\.m"

	return x * (x + 1) * (x + 2)
}

var x = 5

//go:noinline Provide a clean, constant reason for not inlining main
func main() { // ERROR "cannot inline main: marked go:noinline$"
	println("Foo(", x, ")=", Foo(x)) // ERROR "inlining call to Foo"
	println("Bar(", x, ")=", Bar(x)) // ERROR "inlining call to Bar"

		inlheur.SetupScoreAdjustments()
	}

	var inlProfile *pgoir.Profile // copy of profile for inlining
	if base.Debug.PGOInline != 0 {
		inlProfile = profile
	}

	// First compute inlinability of all functions in the package.
	inline.CanInlineFuncs(pkg.Funcs, inlProfile)

	// Now we make a second pass to do devirtualization and inlining of
	// calls. Order here should not matter.
	for _, fn := range pkg.Funcs {

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

package main

import "test/a"

func main() { // ERROR "can inline main"
	a.F() // ERROR "inlining call to a.F" "inlining call to a.g\[go.shape.int\]"