[dev.power64] code review 160200044: build: merge default into dev.power64

misc/cgo/test/callback.go

 // Copyright 2011 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 cgotest
 
 /*
 void callback(void *f);
 void callGoFoo(void);
 void callGoStackCheck(void);
 void callPanic(void);
 */
 import "C"
 
 import (
-        "./backdoor"
         "path"
         "runtime"
         "strings"
         "testing"
         "unsafe"
+
+        "./backdoor"
 )
 
 // nestedCall calls into C, back into Go, and finally to f.
 func nestedCall(f func()) {
         // NOTE: Depends on representation of f.
         // callback(x) calls goCallback(x)
         C.callback(*(*unsafe.Pointer)(unsafe.Pointer(&f)))
 }
 
 //export goCallback
@@ skipping 113 matching lines @@
 // into Go.
 func testCallbackCallers(t *testing.T) {
         if runtime.Compiler != "gc" {
                 // The exact function names are not going to be the same.
                 t.Skip("skipping for non-gc toolchain")
         }
         pc := make([]uintptr, 100)
         n := 0
         name := []string{
                 "test.goCallback",
+                "runtime.call16",
                 "runtime.cgocallbackg1",
                 "runtime.cgocallbackg",
                 "runtime.cgocallback_gofunc",
-                "runtime.asmcgocall",
-                "runtime.cgocall",
+                "asmcgocall",
+                "runtime.asmcgocall_errno",
+                "runtime.cgocall_errno",
                 "test._Cfunc_callback",
                 "test.nestedCall",
                 "test.testCallbackCallers",
                 "test.TestCallbackCallers",
                 "testing.tRunner",
                 "runtime.goexit",
         }
         nestedCall(func() {
                 n = runtime.Callers(2, pc)
         })
         if n != len(name) {
                 t.Errorf("expected %d frames, got %d", len(name), n)
         }
         for i := 0; i < n; i++ {
                 f := runtime.FuncForPC(pc[i])
                 if f == nil {
                         t.Fatalf("expected non-nil Func for pc %p", pc[i])
                 }
                 fname := f.Name()
                 // Remove the prepended pathname from automatically
                 // generated cgo function names.
                 if strings.HasPrefix(fname, "_") {
                         fname = path.Base(f.Name()[1:])
                 }
-                if fname != name[i] {
-                        t.Errorf("expected function name %s, got %s", name[i], fname)
+                namei := ""
+                if i < len(name) {
+                        namei = name[i]
+                }
+                if fname != namei {
+                        t.Errorf("stk[%d] = %q, want %q", i, fname, namei)
                 }
         }
 }
 
 func testPanicFromC(t *testing.T) {
         defer func() {
                 r := recover()
                 if r == nil {
                         t.Fatal("did not panic")
                 }
@@ skipping 1483 matching lines @@
 func stack4964() { var buf [4964]byte; use(buf[:]); C.callGoStackCheck() }
 func stack4968() { var buf [4968]byte; use(buf[:]); C.callGoStackCheck() }
 func stack4972() { var buf [4972]byte; use(buf[:]); C.callGoStackCheck() }
 func stack4976() { var buf [4976]byte; use(buf[:]); C.callGoStackCheck() }
 func stack4980() { var buf [4980]byte; use(buf[:]); C.callGoStackCheck() }
 func stack4984() { var buf [4984]byte; use(buf[:]); C.callGoStackCheck() }
 func stack4988() { var buf [4988]byte; use(buf[:]); C.callGoStackCheck() }
 func stack4992() { var buf [4992]byte; use(buf[:]); C.callGoStackCheck() }
 func stack4996() { var buf [4996]byte; use(buf[:]); C.callGoStackCheck() }
 func stack5000() { var buf [5000]byte; use(buf[:]); C.callGoStackCheck() }