qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-07 09:26:11 -07:00
Code Releases Activity

cmd/go, cmd/cgo: only set TERM=dumb when running the compiler

Browse Source 
The clang compiler on some terminals will issue colored error
messages, which can confuse tools like cgo. To avoid this we used to
set TERM=dumb for all programs started by the go tool. However, that
confuses the pprof tool, which doesn't know whether to support fancy
editing and colors itself.

Instead, change the go tool and the cgo tool to set TERM=dumb where it
matters--when invoking the C compiler--rather than in all cases.

Updates #26254

Change-Id: I95174f961ac269a50a83f5f9d268219043cba968
Reviewed-on: https://go-review.googlesource.com/122975
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
This commit is contained in:
Ian Lance Taylor 2018-07-10 07:19:17 -07:00
parent f9800a9473
commit fa71076d24
3 changed files with 14 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/cmd/cgo/util.go
View File

@ -59,6 +59,8 @@ func run(stdin []byte, argv []string) (stdout, stderr []byte, ok bool) {
var bout, berr bytes.Buffer var bout, berr bytes.Buffer
p.Stdout = &bout p.Stdout = &bout
p.Stderr = &berr p.Stderr = &berr
// Disable escape codes in clang error messages.
p.Env = append(os.Environ(), "TERM=dumb")
err := p.Run() err := p.Run()
if _, ok := err.(*exec.ExitError); err != nil && !ok { if _, ok := err.(*exec.ExitError); err != nil && !ok {
fatalf("%s", err) fatalf("%s", err)

3
src/cmd/go/internal/envcmd/env.go
View File

@ -62,9 +62,6 @@ func MkEnv() []cfg.EnvVar {
{Name: "GOROOT", Value: cfg.GOROOT}, {Name: "GOROOT", Value: cfg.GOROOT},
{Name: "GOTMPDIR", Value: os.Getenv("GOTMPDIR")}, {Name: "GOTMPDIR", Value: os.Getenv("GOTMPDIR")},
{Name: "GOTOOLDIR", Value: base.ToolDir}, {Name: "GOTOOLDIR", Value: base.ToolDir},
// disable escape codes in clang errors
{Name: "TERM", Value: "dumb"},
} }
if work.GccgoBin != "" { if work.GccgoBin != "" {

17
src/cmd/go/internal/work/exec.go
View File

@ -990,7 +990,7 @@ func (b *Builder) vet(a *Action) error {
return err return err
} }
var env []string env := b.cCompilerEnv()
if cfg.BuildToolchainName == "gccgo" { if cfg.BuildToolchainName == "gccgo" {
env = append(env, "GCCGO="+BuildToolchain.compiler()) env = append(env, "GCCGO="+BuildToolchain.compiler())
} }
@ -1863,6 +1863,13 @@ func joinUnambiguously(a []string) string {
return buf.String() return buf.String()
} }
// cCompilerEnv returns environment variables to set when running the
// C compiler. This is needed to disable escape codes in clang error
// messages that confuse tools like cgo.
func (b *Builder) cCompilerEnv() []string {
return []string{"TERM=dumb"}
}
// mkdir makes the named directory. // mkdir makes the named directory.
func (b *Builder) Mkdir(dir string) error { func (b *Builder) Mkdir(dir string) error {
// Make Mkdir(a.Objdir) a no-op instead of an error when a.Objdir == "". // Make Mkdir(a.Objdir) a no-op instead of an error when a.Objdir == "".
@ -2010,7 +2017,7 @@ func (b *Builder) ccompile(a *Action, p *load.Package, outfile string, flags []s
if !filepath.IsAbs(outfile) { if !filepath.IsAbs(outfile) {
outfile = filepath.Join(p.Dir, outfile) outfile = filepath.Join(p.Dir, outfile)
} }
output, err := b.runOut(filepath.Dir(file), nil, compiler, flags, "-o", outfile, "-c", filepath.Base(file)) output, err := b.runOut(filepath.Dir(file), b.cCompilerEnv(), compiler, flags, "-o", outfile, "-c", filepath.Base(file))
if len(output) > 0 { if len(output) > 0 {
// On FreeBSD 11, when we pass -g to clang 3.8 it // On FreeBSD 11, when we pass -g to clang 3.8 it
// invokes its internal assembler with -dwarf-version=2. // invokes its internal assembler with -dwarf-version=2.
@ -2050,7 +2057,7 @@ func (b *Builder) gccld(p *load.Package, objdir, out string, flags []string, obj
} else { } else {
cmd = b.GccCmd(p.Dir, objdir) cmd = b.GccCmd(p.Dir, objdir)
} }
return b.run(nil, p.Dir, p.ImportPath, nil, cmd, "-o", out, objs, flags) return b.run(nil, p.Dir, p.ImportPath, b.cCompilerEnv(), cmd, "-o", out, objs, flags)
} }
// Grab these before main helpfully overwrites them. // Grab these before main helpfully overwrites them.
@ -2345,7 +2352,7 @@ func (b *Builder) cgo(a *Action, cgoExe, objdir string, pcCFLAGS, pcLDFLAGS, cgo
// along to the host linker. At this point in the code, cgoLDFLAGS // along to the host linker. At this point in the code, cgoLDFLAGS
// consists of the original $CGO_LDFLAGS (unchecked) and all the // consists of the original $CGO_LDFLAGS (unchecked) and all the
// flags put together from source code (checked). // flags put together from source code (checked).
var cgoenv []string cgoenv := b.cCompilerEnv()
if len(cgoLDFLAGS) > 0 { if len(cgoLDFLAGS) > 0 {
flags := make([]string, len(cgoLDFLAGS)) flags := make([]string, len(cgoLDFLAGS))
for i, f := range cgoLDFLAGS { for i, f := range cgoLDFLAGS {
@ -2492,7 +2499,7 @@ func (b *Builder) dynimport(a *Action, p *load.Package, objdir, importGo, cgoExe
if p.Standard && p.ImportPath == "runtime/cgo" { if p.Standard && p.ImportPath == "runtime/cgo" {
cgoflags = []string{"-dynlinker"} // record path to dynamic linker cgoflags = []string{"-dynlinker"} // record path to dynamic linker
} }
return b.run(a, p.Dir, p.ImportPath, nil, cfg.BuildToolexec, cgoExe, "-dynpackage", p.Name, "-dynimport", dynobj, "-dynout", importGo, cgoflags) return b.run(a, p.Dir, p.ImportPath, b.cCompilerEnv(), cfg.BuildToolexec, cgoExe, "-dynpackage", p.Name, "-dynimport", dynobj, "-dynout", importGo, cgoflags)
} }
// Run SWIG on all SWIG input files. // Run SWIG on all SWIG input files.