# Reject #cgo CFLAGS: -D @foo
cp y_cflags_dash_d_space_at_foo.txt y.go
! go build x
stderr 'invalid flag in #cgo CFLAGS: -D @foo'

# Reject #cgo CFLAGS -D@foo
cp y_cflags_dash_d_at_foo.txt y.go
! go build x
stderr 'invalid flag in #cgo CFLAGS: -D@foo'

# Check for CFLAGS in commands
env CGO_CFLAGS=-D@foo
cp y_no_cflags.txt y.go
go build -n x
stderr '-D@foo'

-- go.mod --

					cflags |= REG_ICASE;
					continue;
				case 'j':
					cflags |= REG_SPAN;
					continue;
				case 'k':
					cflags |= REG_ESCAPE;
					continue;
				case 'l':
					cflags |= REG_LEFT;
					continue;
				case 'm':
					cflags |= REG_MINIMAL;
					continue;
				case 'n':
					cflags |= REG_NEWLINE;
					continue;
				case 'o':
					cflags |= REG_SHELL_GROUP;
					continue;

		extraLDFlags := ""
		if strings.Contains(testenv.Builder(), "clang") {
			extraLDFlags += " -fuse-ld=lld"
		}
		const cflags = "-flto -Wno-lto-type-mismatch -Wno-unknown-warning-option"
		cmd.Env = append(cmd.Environ(),
			"CGO_CFLAGS="+cflags,
			"CGO_CXXFLAGS="+cflags,
			"CGO_LDFLAGS="+cflags+extraLDFlags)
	}
	out, err := cmd.CombinedOutput()
	if string(out) != "OK\n" {
		t.Errorf("%s", string(out))
	}

		t.Logf("%s %v -c -o %s %s", cc, cflags, obj, csrcFile)
		if out, err := testenv.Command(t, cc, append(cflags, "-c", "-o", obj, csrcFile)...).CombinedOutput(); err != nil {
			t.Logf("%s", out)
			t.Fatal(err)
		}
	}

	sysoObj := filepath.Join(dir, "ldr.syso")
	t.Logf("%s %v -nostdlib -r -o %s %v", cc, cflags, sysoObj, objs)

}

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 {

package main

// #cgo CFLAGS: -I../c
// #include "stdio.h"
// void printfile();
import "C"

func main() {
    C.printfile()
    C.fflush(C.stdout)
}
-- vendor/v.com/main/foo.c --
#include "bar.h"
-- vendor/v.com/c/bar.h --
#include "stdio.h"

void printfile() {
    printf("%s\n", __FILE__);
}
-- main/main.go --
package main

// #cgo CFLAGS: -I../c
// #include "stdio.h"

        private String CFlags;
        private String dns;
        private String URL;
        private String a;
        private String b;

        @Inject
        public TaskWithJavaBeanCornerCaseProperties(String cCompiler, String CFlags, String dns, String URL, String a, String b) {
            this.cCompiler = cCompiler;
            this.CFlags = CFlags;
            this.dns = dns;

[!GOOS:darwin] skip
[!cgo] skip

! go build
stderr 'invalid flag in #cgo LDFLAGS: -lto_library'

-- go.mod --
module ldflag

-- main.go --
package main

// #cgo CFLAGS: -flto
// #cgo LDFLAGS: -lto_library bad.dylib
import "C"

		compiler, _ := compilerVersion()
		if compiler.name == "gcc" {
			c.cFlags = append(c.cFlags, "-fPIC")
			c.ldFlags = append(c.ldFlags, "-fPIC", "-static-libtsan")
		}

	case "address":
		c.goFlags = append(c.goFlags, "-asan")
		// Set the debug mode to print the C stack trace.
		c.cFlags = append(c.cFlags, "-g")

	case "fuzzer":

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

package main

// This program will crash.
// We want to test unwinding from sigpanic into C code (without a C symbolizer).

/*
#cgo CFLAGS: -O0

char *pnil;

static int f1(void) {
	*pnil = 0;
	return 0;
}
*/
import "C"

func init() {
	register("TracebackSigpanic", TracebackSigpanic)
}

func TracebackSigpanic() {