Add files using upload-large-folder tool

platform/dbops/binaries/go/go/test/fixedbugs/issue11656.dir/issue11656.go

@@ -0,0 +1,75 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"encoding/binary"
+	"runtime"
+	"runtime/debug"
+	"unsafe"
+)
+
+func main() {
+	debug.SetPanicOnFault(true)
+	defer func() {
+		if err := recover(); err == nil {
+			panic("not panicking")
+		}
+		pc, _, _, _ := runtime.Caller(10)
+		f := runtime.FuncForPC(pc)
+		if f == nil || f.Name() != "main.f" {
+			if f == nil {
+				println("no func for ", unsafe.Pointer(pc))
+			} else {
+				println("found func:", f.Name())
+			}
+			panic("cannot find main.f on stack")
+		}
+	}()
+	f(20)
+}
+
+func f(n int) {
+	if n > 0 {
+		f(n - 1)
+	}
+	var f struct {
+		x uintptr
+	}
+
+	// We want to force a seg fault, to get a crash at a PC value != 0.
+	// Not all systems make the data section non-executable.
+	ill := make([]byte, 64)
+	switch runtime.GOARCH {
+	case "386", "amd64":
+		ill = append(ill[:0], 0x89, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00) // MOVL AX, 0
+	case "arm":
+		binary.LittleEndian.PutUint32(ill[0:4], 0xe3a00000) // MOVW $0, R0
+		binary.LittleEndian.PutUint32(ill[4:8], 0xe5800000) // MOVW R0, (R0)
+	case "arm64":
+		binary.LittleEndian.PutUint32(ill, 0xf90003ff) // MOVD ZR, (ZR)
+	case "ppc64":
+		binary.BigEndian.PutUint32(ill, 0xf8000000) // MOVD R0, (R0)
+	case "ppc64le":
+		binary.LittleEndian.PutUint32(ill, 0xf8000000) // MOVD R0, (R0)
+	case "mips", "mips64":
+		binary.BigEndian.PutUint32(ill, 0xfc000000) // MOVV R0, (R0)
+	case "mipsle", "mips64le":
+		binary.LittleEndian.PutUint32(ill, 0xfc000000) // MOVV R0, (R0)
+	case "s390x":
+		ill = append(ill[:0], 0xa7, 0x09, 0x00, 0x00)         // MOVD $0, R0
+		ill = append(ill, 0xe3, 0x00, 0x00, 0x00, 0x00, 0x24) // MOVD R0, (R0)
+	case "riscv64":
+		binary.LittleEndian.PutUint32(ill, 0x00003023) // MOV X0, (X0)
+	default:
+		// Just leave it as 0 and hope for the best.
+	}
+
+	f.x = uintptr(unsafe.Pointer(&ill[0]))
+	p := &f
+	fn := *(*func())(unsafe.Pointer(&p))
+	syncIcache(f.x)
+	fn()
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue12677.dir/p.go

@@ -0,0 +1,8 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+func Baz(f int) float64 {
+    return 1 / float64(int(1)<<(uint(f)))
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue12677.dir/q.go

@@ -0,0 +1,7 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// 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 f() { println(p.Baz(2)) }

platform/dbops/binaries/go/go/test/fixedbugs/issue13777.dir/burnin.go

@@ -0,0 +1,19 @@
+package burnin
+
+type sendCmdFunc func(string)
+
+func sendCommand(c string) {}
+
+func NewSomething() {
+	// This works...
+	// var sendCmd sendCmdFunc
+	// sendCmd = sendCommand
+
+	// So does this...
+	//sendCmd := sendCmdFunc(sendCommand)
+
+	// This fails...
+	sendCmd := sendCommand
+
+	_ = sendCmd
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue13777.dir/main.go

@@ -0,0 +1,11 @@
+// build
+
+package main
+
+import (
+	x "./burnin"
+)
+
+func main() {
+	x.NewSomething()
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue14164.dir/a.go

@@ -0,0 +1,47 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package a
+
+// F is an exported function, small enough to be inlined.
+// It defines a local interface with an unexported method
+// f, which will appear with a package-qualified method
+// name in the export data.
+func F(x interface{}) bool {
+	_, ok := x.(interface {
+		f()
+	})
+	return ok
+}
+
+// Like F but with the unexported interface method f
+// defined via an embedded interface t. The compiler
+// always flattens embedded interfaces so there should
+// be no difference between F and G. Alas, currently
+// G is not inlineable (at least via export data), so
+// the issue is moot, here.
+func G(x interface{}) bool {
+	type t0 interface {
+		f()
+	}
+	_, ok := x.(interface {
+		t0
+	})
+	return ok
+}
+
+// Like G but now the embedded interface is declared
+// at package level. This function is inlineable via
+// export data. The export data representation is like
+// for F.
+func H(x interface{}) bool {
+	_, ok := x.(interface {
+		t1
+	})
+	return ok
+}
+
+type t1 interface {
+	f()
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue14164.dir/main.go

@@ -0,0 +1,12 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+// Verify that we can import package "a" containing an inlineable
+// function F that declares a local interface with a non-exported
+// method f.
+import _ "./a"
+
+func main() {}

platform/dbops/binaries/go/go/test/fixedbugs/issue14331.dir/a.go

@@ -0,0 +1,14 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package a
+
+var S struct {
+	Str string `tag`
+}
+
+func F() string {
+	v := S
+	return v.Str
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue14331.dir/b.go

@@ -0,0 +1,11 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package b
+
+import "./a"
+
+func G() string {
+	return a.F()
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue15071.dir/exp.go

@@ -0,0 +1,24 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package exp
+
+func Exported(x int) int {
+	return inlined(x)
+}
+
+func inlined(x int) int {
+	y := 0
+	switch {
+	case x > 0:
+		y += 5
+		return 0 + y
+	case x < 1:
+		y += 6
+		fallthrough
+	default:
+		y += 7
+		return 2 + y
+	}
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue15071.dir/main.go

@@ -0,0 +1,14 @@
+// run
+
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import "os"
+import "./exp"
+
+func main() {
+	_ = exp.Exported(len(os.Args))
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue15470.dir/a.go

@@ -0,0 +1,24 @@
+package a
+
+import "io"
+
+type T interface {
+	M0(_ int)
+	M1(x, _ int) // _ (blank) caused crash
+	M2() (x, _ int)
+}
+
+type S struct{}
+
+func (S) M0(_ int) {}
+func (S) M1(x, _ int) {}
+func (S) M2() (x, _ int) { return }
+func (_ S) M3() {}
+
+// Snippet from x/tools/godoc/analysis/analysis.go.
+// Offending code from #5470.
+type Link interface {
+	Start() int
+	End() int
+	Write(w io.Writer, _ int, start bool) // _ (blank) caused crash
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue15470.dir/b.go

@@ -0,0 +1,3 @@
+package b
+
+import _ "./a" // must not fail

platform/dbops/binaries/go/go/test/fixedbugs/issue15514.dir/a.go

@@ -0,0 +1,7 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package a
+
+type A struct{ _ int32 }

platform/dbops/binaries/go/go/test/fixedbugs/issue15514.dir/b.go

@@ -0,0 +1,7 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package b
+
+func B() (_ struct{ _ int32 }) { return }

platform/dbops/binaries/go/go/test/fixedbugs/issue15514.dir/c.go

@@ -0,0 +1,10 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package c
+
+import "./a"
+import "./b"
+
+var _ a.A = b.B() // ERROR "cannot use b\.B|incompatible type"

platform/dbops/binaries/go/go/test/fixedbugs/issue15548.dir/a.go

@@ -0,0 +1,17 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package a
+
+type I0 interface {
+	I1
+}
+
+type T struct {
+	I1
+}
+
+type I1 interface {
+	M(*T) // removing * makes crash go away
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue15548.dir/b.go

@@ -0,0 +1,9 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package b
+
+import "./a"
+
+var X a.T

platform/dbops/binaries/go/go/test/fixedbugs/issue15548.dir/c.go

@@ -0,0 +1,10 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package c
+
+import (
+	_ "./b"
+	_ "./a"
+)

platform/dbops/binaries/go/go/test/fixedbugs/issue15572.dir/a.go

@@ -0,0 +1,40 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package a
+
+type T struct {
+}
+
+func F() []T {
+	return []T{T{}}
+}
+
+func Fi() []T {
+	return []T{{}} // element with implicit composite literal type
+}
+
+func Fp() []*T {
+	return []*T{&T{}}
+}
+
+func Fip() []*T {
+	return []*T{{}} // element with implicit composite literal type
+}
+
+func Gp() map[int]*T {
+	return map[int]*T{0: &T{}}
+}
+
+func Gip() map[int]*T {
+	return map[int]*T{0: {}} // element with implicit composite literal type
+}
+
+func Hp() map[*T]int {
+	return map[*T]int{&T{}: 0}
+}
+
+func Hip() map[*T]int {
+	return map[*T]int{{}: 0} // key with implicit composite literal type
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue15572.dir/b.go

@@ -0,0 +1,27 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package b
+
+import "./a"
+
+func F() {
+	a.F()
+	a.Fi()
+}
+
+func Fp() {
+	a.Fp()
+	a.Fip()
+}
+
+func Gp() {
+	a.Gp()
+	a.Gip()
+}
+
+func Hp() {
+	a.Hp()
+	a.Hip()
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue15609.dir/call.go

@@ -0,0 +1,7 @@
+//go:build !amd64 && !386
+
+package main
+
+func jump() {
+	target()
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue15609.dir/call_386.s

@@ -0,0 +1,8 @@
+#include "textflag.h"
+
+DATA ·pointer(SB)/4, $·target(SB)
+GLOBL ·pointer(SB),RODATA,$4
+
+TEXT ·jump(SB),NOSPLIT,$4
+        CALL *·pointer(SB)
+        RET

platform/dbops/binaries/go/go/test/fixedbugs/issue15609.dir/call_amd64.s

@@ -0,0 +1,8 @@
+#include "textflag.h"
+
+DATA ·pointer(SB)/8, $·target(SB)
+GLOBL ·pointer(SB),RODATA,$8
+
+TEXT ·jump(SB),NOSPLIT,$8
+        CALL *·pointer(SB)
+        RET

platform/dbops/binaries/go/go/test/fixedbugs/issue15609.dir/call_decl.go

@@ -0,0 +1,5 @@
+//go:build amd64 || 386
+
+package main
+
+func jump()

platform/dbops/binaries/go/go/test/fixedbugs/issue15609.dir/main.go

@@ -0,0 +1,14 @@
+package main
+
+var called bool
+
+func target() {
+	called = true
+}
+
+func main() {
+	jump()
+	if !called {
+		panic("target not called")
+	}
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue15646.dir/a.go

@@ -0,0 +1,23 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package a
+
+type T struct{}
+
+func (T) m() string {
+	return "m"
+}
+
+func (*T) mp() string {
+	return "mp"
+}
+
+func F() func(T) string {
+	return T.m // method expression
+}
+
+func Fp() func(*T) string {
+	return (*T).mp // method expression
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue15646.dir/b.go

@@ -0,0 +1,16 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import "./a" // import must succeed
+
+func main() {
+	if a.F()(a.T{}) != "m" {
+		panic(0)
+	}
+	if a.Fp()(nil) != "mp" {
+		panic(1)
+	}
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue15838.dir/a.go

@@ -0,0 +1,61 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package a
+
+func F1() {
+L:
+	goto L
+}
+
+func F2() {
+L:
+	for {
+		break L
+	}
+}
+
+func F3() {
+L:
+	for {
+		continue L
+	}
+}
+
+func F4() {
+	switch {
+	case true:
+		fallthrough
+	default:
+	}
+}
+
+type T struct{}
+
+func (T) M1() {
+L:
+	goto L
+}
+
+func (T) M2() {
+L:
+	for {
+		break L
+	}
+}
+
+func (T) M3() {
+L:
+	for {
+		continue L
+	}
+}
+
+func (T) M4() {
+	switch {
+	case true:
+		fallthrough
+	default:
+	}
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue15838.dir/b.go

@@ -0,0 +1,9 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package b
+
+import "./a"
+
+type T struct{ a.T }

platform/dbops/binaries/go/go/test/fixedbugs/issue15920.dir/a.go

@@ -0,0 +1,9 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package a
+
+type Error error
+
+func F() Error { return nil }

platform/dbops/binaries/go/go/test/fixedbugs/issue15920.dir/b.go

@@ -0,0 +1,7 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package b
+
+import _ "./a"

platform/dbops/binaries/go/go/test/fixedbugs/issue16133.dir/a1.go

@@ -0,0 +1,7 @@
+package a
+
+type X string
+
+func NewX() X {
+	return ""
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue16133.dir/a2.go

@@ -0,0 +1,7 @@
+package a
+
+type X string
+
+func NewX() X {
+	return ""
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue16133.dir/b.go

@@ -0,0 +1,7 @@
+package b
+
+import "./a2"
+
+type T struct {
+	X a.X
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue16133.dir/c.go

@@ -0,0 +1,10 @@
+package p
+
+import (
+	"./a1"
+	"./b"
+)
+
+var _ = b.T{
+	X: a.NewX(), // ERROR `cannot use "a1"\.NewX\(\)`
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue16317.dir/a.go

@@ -0,0 +1,11 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package a
+
+import "unsafe"
+
+func ConstUnsafePointer() unsafe.Pointer {
+	return unsafe.Pointer(uintptr(0))
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue16317.dir/b.go

@@ -0,0 +1,11 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import "./a"
+
+func main() {
+	_ = a.ConstUnsafePointer()
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue16616.dir/a.go

@@ -0,0 +1,7 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package a
+
+type V struct{ i int }

platform/dbops/binaries/go/go/test/fixedbugs/issue16616.dir/b.go

@@ -0,0 +1,14 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package b
+
+import "./a"
+
+var V struct{ i int }
+
+var U struct {
+	a.V
+	j int
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue16616.dir/issue16616.go

@@ -0,0 +1,26 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"reflect"
+
+	_ "./a"
+	"./b"
+)
+
+var V struct{ i int }
+
+func main() {
+	if got := reflect.ValueOf(b.V).Type().Field(0).PkgPath; got != "b" {
+		panic(`PkgPath=` + got + ` for first field of b.V, want "b"`)
+	}
+	if got := reflect.ValueOf(V).Type().Field(0).PkgPath; got != "main" {
+		panic(`PkgPath=` + got + ` for first field of V, want "main"`)
+	}
+	if got := reflect.ValueOf(b.U).Type().Field(0).PkgPath; got != "b" {
+		panic(`PkgPath=` + got + ` for first field of b.U, want "b"`)
+	}
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue18419.dir/other.go

@@ -0,0 +1,11 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package other
+
+type Exported struct {
+	Member int
+}
+
+func (e *Exported) member() int { return 1 }

platform/dbops/binaries/go/go/test/fixedbugs/issue18419.dir/test.go

@@ -0,0 +1,15 @@
+// errorcheck -0 -m -l
+
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import "./other"
+
+func InMyCode(e *other.Exported) {
+	e.member() // ERROR "e\.member undefined .cannot refer to unexported field or method other\.\(\*Exported\)\.member.|unexported field or method"
+}
+
+func main() {}

platform/dbops/binaries/go/go/test/fixedbugs/issue18895.dir/p.go

@@ -0,0 +1,14 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+func F() { // ERROR "can inline"
+	var v t
+	v.m() // ERROR "inlining call"
+}
+
+type t int
+
+func (t) m() {} // ERROR "can inline"

platform/dbops/binaries/go/go/test/fixedbugs/issue18895.dir/q.go

@@ -0,0 +1,11 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// 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"
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue18911.dir/a.go

@@ -0,0 +1,7 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package a
+
+var X interface{} = struct{ x int }{}

platform/dbops/binaries/go/go/test/fixedbugs/issue18911.dir/b.go

@@ -0,0 +1,21 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import "./a"
+import "strings"
+
+func main() {
+	defer func() {
+		p, ok := recover().(error)
+		if ok && strings.Contains(p.Error(), "different packages") {
+			return
+		}
+		panic(p)
+	}()
+
+	// expected to fail and report two identical looking (but different) types
+	_ = a.X.(struct{ x int })
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue19028.dir/a.go

@@ -0,0 +1,9 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package reflect
+
+import "reflect"
+
+type Type reflect.Type

platform/dbops/binaries/go/go/test/fixedbugs/issue19028.dir/main.go

@@ -0,0 +1,26 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+        "reflect"
+        fake "./a" // 2nd package with name "reflect"
+)
+
+type T struct {
+        _ fake.Type
+}
+
+func (T) f()            {}
+func (T) G() (_ int)    { return }
+func (T) H() (_, _ int) { return }
+
+func main() {
+        var x T
+        typ := reflect.TypeOf(x)
+        for i := 0; i < typ.NumMethod(); i++ {
+                _ = typ.Method(i) // must not crash
+        }
+}

platform/dbops/binaries/go/go/test/fixedbugs/issue19261.dir/p.go

@@ -0,0 +1,24 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+func F() { // ERROR "can inline F"
+	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+}
+
+func G() {
+	F() // ERROR "inlining call to F"
+	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+}