const buildIDSeparator = "/"

// actionID returns the action ID half of a build ID.
func actionID(buildID string) string {
	i := strings.Index(buildID, buildIDSeparator)
	if i < 0 {
		return buildID
	}
	return buildID[:i]
}

// contentID returns the content ID half of a build ID.
func contentID(buildID string) string {
	return buildID[strings.LastIndex(buildID, buildIDSeparator)+1:]
}

	telemetry.CountFlags("buildid/flag:", *flag.CommandLine)
	if flag.NArg() != 1 {
		usage()
	}

	file := flag.Arg(0)
	id, err := buildid.ReadFile(file)
	if err != nil {
		log.Fatal(err)
	}
	if !*wflag {
		fmt.Printf("%s\n", id)
		return
	}

	// Keep in sync with src/cmd/go/internal/work/buildid.go:updateBuildID

	f, err := os.Open(file)
	if err != nil {
		log.Fatal(err)
	}

		case 2:
			if !bytes.HasPrefix(line, goobject) {
				return tryGccgo()
			}
		case 3:
			if !bytes.HasPrefix(line, buildid) {
				// Found the object header, just doesn't have a build id line.
				// Treat as successful, with empty build id.
				return "", nil
			}
			id, err := strconv.Unquote(string(line[len(buildid):]))
			if err != nil {
				return tryGccgo()
			}
			return id, nil
		}
	}
}

# Only the linker and buildid tool should be needed.

mkdir bar
cp foo/main.go bar/main.go
cd bar
go build -x -o a.exe main.go
! stderr ${/}compile$GOEXE

go tool buildid a.exe
cp stdout ../bar-buildid.txt
go version a.exe
cp stdout ../bar-version.txt
cd ..

cmp bar-buildid.txt foo-buildid.txt
cmp bar-version.txt foo-version.txt
cmp bar/a.exe foo/a.exe


-- $WORK/tmp/foo/main.go --

	const buildID = "TestNoteReading-Build-ID"
	tg.run("build", "-ldflags", "-buildid="+buildID, "-o", tg.path("hello.exe"), tg.path("hello.go"))
	id, err := buildid.ReadFile(tg.path("hello.exe"))
	if err != nil {
		t.Fatalf("reading build ID from hello binary: %v", err)
	}
	if id != buildID {
		t.Fatalf("buildID in hello binary = %q, want %q", id, buildID)
	}

	switch {
	case !testenv.HasCGO():

// made to obtain the buildID information.
func (b *profileBuilder) readMapping() {
	if !machVMInfo(b.addMapping) {
		b.addMappingEntry(0, 0, 0, "", "", true)
	}
}

func readMainModuleMapping() (start, end uint64, exe, buildID string, err error) {
	first := true
	ok := machVMInfo(func(lo, hi, off uint64, file, build string) {
		if first {
			start, end = lo, hi

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

/*
Buildid displays or updates the build ID stored in a Go package or binary.

Usage:

	go tool buildid [-w] file

By default, buildid prints the build ID found in the named file.
If the -w option is given, buildid rewrites the build ID found in
the file to accurately record a content hash of the file.

			var fileNames []string
			if m.BuildID != "" {
				fileNames = []string{filepath.Join(path, m.BuildID, baseName)}
				if matches, err := filepath.Glob(filepath.Join(path, m.BuildID, "*")); err == nil {
					fileNames = append(fileNames, matches...)
				}
				fileNames = append(fileNames, filepath.Join(path, noVolumeFile, m.BuildID)) // perf path format
				// Llvm buildid protocol: the first two characters of the build id

env GOCACHE=$WORK/gocache1
mkdir $GOCACHE

# Build a simple binary
go build -o binary1 -trimpath -x main.go

# Now repeat the same process with the compiler at a different local path
env GOROOT=$WORK/goroot2
symlink $GOROOT -> $TESTGO_GOROOT

env GOCACHE=$WORK/gocache2
mkdir $GOCACHE

go build -o binary2 -trimpath -x main.go

# Check that the binaries match exactly
go tool buildid binary1
cp stdout buildid1

    @Nullable
    private final String buildId;
    private final ChecksumService checksumService;

    public ModuleMetadataJsonWriter(
        JsonWriter jsonWriter,
        ModuleMetadataSpec metadata,
        @Nullable String buildId,
        ChecksumService checksumService
    ) {
        super(jsonWriter);
        this.metadata = metadata;
        this.buildId = buildId;
        this.checksumService = checksumService;