// or 0 for impossible errors.
func AddMeta(p unsafe.Pointer, dlen uint32, hash [16]byte, pkgpath string, pkgid int, cmode uint8, cgran uint8) uint32 {
	slot := len(Meta.List)
	Meta.List = append(Meta.List, CovMetaBlob{
		P:                  (*byte)(p),
		Len:                dlen,
		Hash:               hash,
		PkgPath:            pkgpath,
		PkgID:              pkgid,
		CounterMode:        cmode,
		CounterGranularity: cgran,
	})

func libfuzzerTraceConstCmp8(uint64, uint64, uint)
func libfuzzerHookStrCmp(string, string, uint)
func libfuzzerHookEqualFold(string, string, uint)

func addCovMeta(p unsafe.Pointer, len uint32, hash [16]byte, pkpath string, pkgId int, cmode uint8, cgran uint8) uint32

// architecture variants
var x86HasPOPCNT bool
var x86HasSSE41 bool
var x86HasFMA bool
var armHasVFPv4 bool
var arm64HasATOMICS bool

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

// Package pkgpath determines the package path used by gccgo/GoLLVM symbols.
// This package is not used for the gc compiler.
package pkgpath

import (
	"bytes"
	"errors"
	"fmt"
	"os"
	"os/exec"
	"strings"
)

// ToSymbolFunc returns a function that may be used to convert a
// package path into a string suitable for use as a symbol.

}

func (gcToolchain) linker() string {
	return base.Tool("link")
}

func pkgPath(a *Action) string {
	p := a.Package
	ppath := p.ImportPath
	if cfg.BuildBuildmode == "plugin" {
		ppath = pluginPath(a)
	} else if p.Name == "main" && !p.Internal.ForceLibrary {
		ppath = "main"
	}
	return ppath
}

	"encoding/json"
	"fmt"
	"internal/testenv"
	"os"
	"path/filepath"
	"strings"
	"testing"
)

func writeFile(t *testing.T, path string, contents []byte) {
	if err := os.WriteFile(path, contents, 0666); err != nil {
		t.Fatalf("os.WriteFile(%s) failed: %v", path, err)
	}
}

func writePkgConfig(t *testing.T, outdir, tag, ppath, pname string, gran string, mpath string) string {
	incfg := filepath.Join(outdir, tag+"incfg.txt")

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"`)
	}

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

package main

import (
	"reflect"
	"unsafe"
)

func main() {
	t := reflect.TypeOf(unsafe.Pointer(nil))
	if pkgPath := t.PkgPath(); pkgPath != "unsafe" {
		panic("unexpected t.PkgPath(): " + pkgPath)
	}

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

// The PkgPath of unexported fields of types defined in package main was incorrectly ""

package main

import (
	"fmt"
	"reflect"
)

type foo struct {
	bar int
}

func main() {
	pkgpath := reflect.ValueOf(foo{}).Type().Field(0).PkgPath
	if pkgpath != "main" {
		fmt.Printf("BUG: incorrect PkgPath: %v", pkgpath)
	}

	{pkgpath: "conversions", name: "Bits", want: "const Bits Units", wantval: `"bits"`},
	{pkgpath: "time", name: "Duration", want: "type Duration int64"},
	{pkgpath: "time", name: "Nanosecond", want: "const Nanosecond Duration", wantval: "1"},
	{pkgpath: "unicode", name: "IsUpper", want: "func IsUpper(r rune) bool"},
	{pkgpath: "unicode", name: "MaxRune", want: "const MaxRune untyped rune", wantval: "1114111"},

		}
		f, fpkgpath := runtimeStructField(field)
		ft := f.Typ
		if ft.Kind_&abi.KindGCProg != 0 {
			hasGCProg = true
		}
		if fpkgpath != "" {
			if pkgpath == "" {
				pkgpath = fpkgpath
			} else if pkgpath != fpkgpath {
				panic("reflect.Struct: fields with different PkgPath " + pkgpath + " and " + fpkgpath)
			}
		}

		// Update string and hash