ready = make(chan struct{})
			v, loaded = c.m.LoadOrStore(suffix, (<-chan struct{})(ready))

			if !loaded {
				inPanic := true
				defer func() {
					if inPanic {
						c.m.Delete(suffix)
					}
					close(ready)
				}()

				b, err := c.eval(suffix)
				inPanic = false

				if err == nil {
					c.m.Store(suffix, b)
					return b, nil
				} else {
					c.m.Store(suffix, err)

		panic(fmt.Sprintf("unexpected f1 size == %d, want %d", got, want))
	}
	if got, want := unsafe.Sizeof(p.Field2), uintptr(8); got != want {
		panic(fmt.Sprintf("unexpected f2 size == %d, want %d", got, want))
	}

	type mypair struct {
		Field1 int32
		Field2 int64
	}
	mp := mypair(p)
	if mp.Field1 != 1 || mp.Field2 != 2 {
		panic(fmt.Sprintf("mp == %#v, want %#v", mp, mypair{1, 2}))
	}

	if got, want := unsafe.Sizeof(p.f1), uintptr(4); got != want {
		panic(fmt.Sprintf("unexpected f1 size == %d, want %d", got, want))
	}
	if got, want := unsafe.Sizeof(p.f2), uintptr(8); got != want {
		panic(fmt.Sprintf("unexpected f2 size == %d, want %d", got, want))
	}

	type mypair struct {
		f1 int32
		f2 int64
	}
	mp := mypair(p)
	if mp.f1 != 1 || mp.f2 != 2 {
		panic(fmt.Sprintf("mp == %#v, want %#v", mp, mypair{1, 2}))
	}

		pkgName string
	}{
		{Sym{goVersion: ver120, Name: "type:.eq.[9]debug/elf.intName"}, ""},
		{Sym{goVersion: ver120, Name: "type:.hash.debug/elf.ProgHeader"}, ""},
		{Sym{goVersion: ver120, Name: "type:.eq.runtime._panic"}, ""},
		{Sym{goVersion: ver120, Name: "type:.hash.struct { runtime.gList; runtime.n int32 }"}, ""},
		{Sym{goVersion: ver120, Name: "go:(*struct { sync.Mutex; math/big.table [64]math/big"}, ""},

	// To disable max/min, remove the next two lines.
	_Max:     {"max", 1, true, expression},
	_Min:     {"min", 1, true, expression},
	_New:     {"new", 1, false, expression},
	_Panic:   {"panic", 1, false, statement},
	_Print:   {"print", 0, true, statement},
	_Println: {"println", 0, true, statement},
	_Real:    {"real", 1, false, expression},
	_Recover: {"recover", 0, false, statement},

	// To disable max/min, remove the next two lines.
	_Max:     {"max", 1, true, expression},
	_Min:     {"min", 1, true, expression},
	_New:     {"new", 1, false, expression},
	_Panic:   {"panic", 1, false, statement},
	_Print:   {"print", 0, true, statement},
	_Println: {"println", 0, true, statement},
	_Real:    {"real", 1, false, expression},
	_Recover: {"recover", 0, false, statement},

	switch s := s.(type) {
	default:
		panic("unreachable")

	case *syntax.DeclStmt, *syntax.EmptyStmt, *syntax.SendStmt,
		*syntax.AssignStmt, *syntax.CallStmt:
		// no chance

	case *syntax.LabeledStmt:
		return check.isTerminating(s.Stmt, s.Label.Value)

	case *syntax.ExprStmt:
		// calling the predeclared (possibly parenthesized) panic() function is terminating

	switch s := s.(type) {
	default:
		panic("unreachable")

	case *ast.BadStmt, *ast.DeclStmt, *ast.EmptyStmt, *ast.SendStmt,
		*ast.IncDecStmt, *ast.AssignStmt, *ast.GoStmt, *ast.DeferStmt,
		*ast.RangeStmt:
		// no chance

	case *ast.LabeledStmt:
		return check.isTerminating(s.Stmt, s.Label.Name)

	case *ast.ExprStmt:
		// calling the predeclared (possibly parenthesized) panic() function is terminating

	{"runtime.mallocgc", 1},
	{"runtime.panicdivide", 1},
	{"runtime.panicshift", 1},
	{"runtime.panicmakeslicelen", 1},
	{"runtime.panicmakeslicecap", 1},
	{"runtime.throwinit", 1},
	{"runtime.panicwrap", 1},
	{"runtime.gopanic", 1},
	{"runtime.gorecover", 1},
	{"runtime.goschedguarded", 1},
	{"runtime.goPanicIndex", 1},
	{"runtime.goPanicIndexU", 1},
	{"runtime.goPanicSliceAlen", 1},
	{"runtime.goPanicSliceAlenU", 1},

	if err != nil {
		t.Fatal(err)
	}

	// Unwind the stack using this executable's symbol table.
	got := formatStack(pcs)
	want := `redacted.go:0: runtime.gopanic
traceback_system_test.go:85: runtime_test.child7: 	panic("oops")
traceback_system_test.go:68: runtime_test.child6: 	child7() // appears in stack trace
traceback_system_test.go:59: runtime_test.child5: 	child6() // appears in stack trace