[GOARCH:amd64] stdout '^\tbuild\tGOAMD64='
! stdout asmflags|gcflags|ldflags|gccgoflags

# Toolchain flags are added if present.
# The raw flags are included, with package patterns if specified.
go build -asmflags=example.com/m=-D=FOO=bar
go version -m m$GOEXE
stdout '^\tbuild\t-asmflags=example\.com/m=-D=FOO=bar$'

go build -gcflags=example.com/m=-N
go version -m m$GOEXE
stdout '^\tbuild\t-gcflags=example\.com/m=-N$'

	echo $pkg
	DIR=$GOROOT/src/$pkg
	go build -gcflags "$FLAGS1 -S" -o /dev/null $pkg &> $DIR/old.txt
done

echo
echo
echo "2a) clean build using $FLAGS2"
(export GO_GCFLAGS="$FLAGS2"; sh make.bash)

echo
echo
echo "2b) save go build output for all packages"
for pkg in `go list std`; do
	echo $pkg
	DIR=$GOROOT/src/$pkg
	go build -gcflags "$FLAGS2 -S" -o /dev/null $pkg &> $DIR/new.txt
done

echo

// buildrun -t 10  -gcflags=-d=ssa/insert_resched_checks/on,ssa/check/on

//go:build !nacl && !js && disabled_see_issue_18589

// 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.

// Test is disabled because it flakes when run in all.bash
// on some platforms, but is useful standalone to verify
// that rescheduling checks are working (and we may wish

// run -gcflags=all=-d=checkptr

//go:build cgo

// Copyright 2019 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

// #include <stdlib.h>
import "C"

func main() {
	C.malloc(100)

// testDebugLinesDefault removes the first wanted statement on architectures that are not (yet) register ABI.
func testDebugLinesDefault(t *testing.T, gcflags, file, function string, wantStmts []int, ignoreRepeats bool) {
	unixOnly(t)
	if !hasRegisterABI() {
		wantStmts = wantStmts[1:]
	}
	testDebugLines(t, gcflags, file, function, wantStmts, ignoreRepeats)
}

func TestDebugLinesSayHi(t *testing.T) {

}

func TestToleratesOptimizationFlag(t *testing.T) {
	for _, cflags := range []string{
		"",
		"-O",
	} {
		cflags := cflags
		t.Run(cflags, func(t *testing.T) {
			testenv.MustHaveGoBuild(t)
			testenv.MustHaveCGO(t)
			t.Parallel()

			cmd := exec.Command("go", "build", path("issue14669.go"))
			cmd.Env = append(os.Environ(), "CGO_CFLAGS="+cflags)
			out, err := cmd.CombinedOutput()
			if err != nil {

// run -gcflags="-d=checkptr"

// Copyright 2021 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 (
	"strings"
	"unsafe"
)

func main() {
	defer func() {
		err := recover()
		if err == nil {
			panic("expected panic")
		}
		if got := err.(error).Error(); !strings.Contains(got, "slice bounds out of range") {

// run -gcflags=-d=checkptr

// Copyright 2020 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.

// Test that reflect.Value.UnsafeAddr/Pointer is handled
// correctly by -d=checkptr

package main

import (
	"reflect"
	"unsafe"
)

func main() {
	n := 10
	m := make(map[string]string)

// run -gcflags=-d=checkptr

// Copyright 2020 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 "unsafe"

func main() {
	var x [2]uint64
	a := unsafe.Pointer(&x[1])

	b := a
	b = unsafe.Pointer(uintptr(b) + 2)
	b = unsafe.Pointer(uintptr(b) - 1)
	b = unsafe.Pointer(uintptr(b) &^ 1)

	if a != b {

	// so it's somewhat slow.
	if testing.Short() {
		t.Skip("skipping test in -short mode")
	}

	t.Parallel()
	testenv.MustHaveGoRun(t)

	exe, err := buildTestProg(t, "testprog", "-gcflags=all=-d=checkptr=1")
	if err != nil {
		t.Fatal(err)
	}

	testCases := []struct {
		cmd  string
		want string
	}{
		{"CheckPtrAlignmentPtr", "fatal error: checkptr: misaligned pointer conversion\n"},