b.WriteString(builtinProlog)
b.WriteString(f.Preamble)
b.WriteString("void __cgo__f__(void) {\n")
- b.WriteString("#line 0 \"cgo-test\"\n")
+ b.WriteString("#line 1 \"cgo-test\"\n")
for i, n := range toSniff {
- fmt.Fprintf(&b, "%s; enum { _cgo_enum_%d = %s }; /* cgo-test:%d */\n", n.C, i, n.C, i)
+ fmt.Fprintf(&b, "%s; /* #%d */\nenum { _cgo_enum_%d = %s }; /* #%d */\n", n.C, i, i, n.C, i)
}
b.WriteString("}\n")
stderr := p.gccErrors(b.Bytes())
if err != nil {
continue
}
+ i = (i - 1) / 2
what := ""
switch {
default:
continue
- case strings.Contains(line, ": useless type name in empty declaration"):
+ case strings.Contains(line, ": useless type name in empty declaration"),
+ strings.Contains(line, ": declaration does not declare anything"),
+ strings.Contains(line, ": unexpected type name"):
what = "type"
isConst[i] = false
- case strings.Contains(line, ": statement with no effect"):
+ case strings.Contains(line, ": statement with no effect"),
+ strings.Contains(line, ": expression result unused"):
what = "not-type" // const or func or var
case strings.Contains(line, "undeclared"):
error_(token.NoPos, "%s", strings.TrimSpace(line[colon+1:]))
}
}
-// gccName returns the name of the compiler to run. Use $GCC if set in
+// gccName returns the name of the compiler to run. Use $CC if set in
// the environment, otherwise just "gcc".
-func (p *Package) gccName() (ret string) {
- if ret = os.Getenv("GCC"); ret == "" {
- ret = "gcc"
+func (p *Package) gccName() string {
+ // Use $CC if set, since that's what the build uses.
+ if ret := os.Getenv("CC"); ret != "" {
+ return ret
}
- return
+ // Fall back to $GCC if set, since that's what we used to use.
+ if ret := os.Getenv("GCC"); ret != "" {
+ return ret
+ }
+ return "gcc"
}
// gccMachine returns the gcc -m flag to use, either "-m32", "-m64" or "-marm".
"-c", // do not link
"-xc", // input language is C
}
+ if strings.Contains(p.gccName(), "clang") {
+ c = append(c,
+ "-ferror-limit=0",
+ "-Wno-unneeded-internal-declaration",
+ )
+ }
+
c = append(c, p.GccOptions...)
c = append(c, p.gccMachine()...)
c = append(c, "-") //read input from standard input
case "gc":
buildToolchain = gcToolchain{}
case "gccgo":
- buildToolchain = gccgcToolchain{}
+ buildToolchain = gccgoToolchain{}
default:
return fmt.Errorf("unknown compiler %q", value)
}
case "gc":
buildToolchain = gcToolchain{}
case "gccgo":
- buildToolchain = gccgcToolchain{}
+ buildToolchain = gccgoToolchain{}
}
}
return a
}
// gccgo standard library is "fake" too.
- if _, ok := buildToolchain.(gccgcToolchain); ok {
+ if _, ok := buildToolchain.(gccgoToolchain); ok {
// the target name is needed for cgo.
a.target = p.target
return a
}
objExt := archChar
- if _, ok := buildToolchain.(gccgcToolchain); ok {
+ if _, ok := buildToolchain.(gccgoToolchain); ok {
objExt = "o"
}
for _, a1 := range all {
if dir := a1.pkgdir; dir == a1.p.build.PkgRoot && !incMap[dir] {
incMap[dir] = true
- if _, ok := buildToolchain.(gccgcToolchain); ok {
+ if _, ok := buildToolchain.(gccgoToolchain); ok {
dir = filepath.Join(dir, "gccgo_"+goos+"_"+goarch)
} else {
dir = filepath.Join(dir, goos+"_"+goarch)
}
// The Gccgo toolchain.
-type gccgcToolchain struct{}
+type gccgoToolchain struct{}
var gccgoBin, _ = exec.LookPath("gccgo")
-func (gccgcToolchain) compiler() string {
+func (gccgoToolchain) compiler() string {
return gccgoBin
}
-func (gccgcToolchain) linker() string {
+func (gccgoToolchain) linker() string {
return gccgoBin
}
-func (gccgcToolchain) gc(b *builder, p *Package, obj string, importArgs []string, gofiles []string) (ofile string, err error) {
+func (gccgoToolchain) gc(b *builder, p *Package, obj string, importArgs []string, gofiles []string) (ofile string, err error) {
out := p.Name + ".o"
ofile = obj + out
gcargs := []string{"-g"}
return ofile, b.run(p.Dir, p.ImportPath, args)
}
-func (gccgcToolchain) asm(b *builder, p *Package, obj, ofile, sfile string) error {
+func (gccgoToolchain) asm(b *builder, p *Package, obj, ofile, sfile string) error {
sfile = mkAbs(p.Dir, sfile)
defs := []string{"-D", "GOOS_" + goos, "-D", "GOARCH_" + goarch}
if pkgpath := gccgoCleanPkgpath(p); pkgpath != "" {
return b.run(p.Dir, p.ImportPath, "gccgo", "-I", obj, "-o", ofile, defs, sfile)
}
-func (gccgcToolchain) pkgpath(basedir string, p *Package) string {
+func (gccgoToolchain) pkgpath(basedir string, p *Package) string {
end := filepath.FromSlash(p.ImportPath + ".a")
afile := filepath.Join(basedir, end)
// add "lib" to the final element
return filepath.Join(filepath.Dir(afile), "lib"+filepath.Base(afile))
}
-func (gccgcToolchain) pack(b *builder, p *Package, objDir, afile string, ofiles []string) error {
+func (gccgoToolchain) pack(b *builder, p *Package, objDir, afile string, ofiles []string) error {
var absOfiles []string
for _, f := range ofiles {
absOfiles = append(absOfiles, mkAbs(objDir, f))
return b.run(p.Dir, p.ImportPath, "ar", "cru", mkAbs(objDir, afile), absOfiles)
}
-func (tools gccgcToolchain) ld(b *builder, p *Package, out string, allactions []*action, mainpkg string, ofiles []string) error {
+func (tools gccgoToolchain) ld(b *builder, p *Package, out string, allactions []*action, mainpkg string, ofiles []string) error {
// gccgo needs explicit linking with all package dependencies,
// and all LDFLAGS from cgo dependencies.
afiles := make(map[*Package]string)
return b.run(".", p.ImportPath, "gccgo", "-o", out, ofiles, "-Wl,-(", ldflags, "-Wl,-)", buildGccgoflags)
}
-func (gccgcToolchain) cc(b *builder, p *Package, objdir, ofile, cfile string) error {
+func (gccgoToolchain) cc(b *builder, p *Package, objdir, ofile, cfile string) error {
inc := filepath.Join(goroot, "pkg", fmt.Sprintf("%s_%s", goos, goarch))
cfile = mkAbs(p.Dir, cfile)
defs := []string{"-D", "GOOS_" + goos, "-D", "GOARCH_" + goarch}
if pkgpath := gccgoCleanPkgpath(p); pkgpath != "" {
defs = append(defs, `-D`, `GOPKGPATH="`+pkgpath+`"`)
}
+ // TODO: Support using clang here (during gccgo build)?
return b.run(p.Dir, p.ImportPath, "gcc", "-Wall", "-g",
"-I", objdir, "-I", inc, "-o", ofile, defs, "-c", cfile)
}
// NOTE: env.go's mkEnv knows that the first three
// strings returned are "gcc", "-I", objdir (and cuts them off).
- // TODO: HOST_CC?
- a := []string{"gcc", "-I", objdir, "-g", "-O2"}
+ gcc := strings.Fields(os.Getenv("CC"))
+ if len(gcc) == 0 {
+ gcc = append(gcc, "gcc")
+ }
+ a := []string{gcc[0], "-I", objdir, "-g", "-O2"}
+ a = append(a, gcc[1:]...)
// Definitely want -fPIC but on Windows gcc complains
// "-fPIC ignored for target (all code is position independent)"
}
a = append(a, b.gccArchArgs()...)
// gcc-4.5 and beyond require explicit "-pthread" flag
- // for multithreading with pthread library.
+ // for multithreading with pthread library, but clang whines
+ // about unused arguments if we pass it.
if buildContext.CgoEnabled {
switch goos {
case "windows":
a = append(a, "-mthreads")
default:
- a = append(a, "-pthread")
+ if !strings.Contains(a[0], "clang") {
+ a = append(a, "-pthread")
+ }
}
}
cgoflags = append(cgoflags, "-import_syscall=false")
}
- if _, ok := buildToolchain.(gccgcToolchain); ok {
+ if _, ok := buildToolchain.(gccgoToolchain); ok {
cgoflags = append(cgoflags, "-gccgo")
if pkgpath := gccgoPkgpath(p); pkgpath != "" {
cgoflags = append(cgoflags, "-gccgopkgpath="+pkgpath)
cgoLDFLAGS = cgoLDFLAGS[0 : len(cgoLDFLAGS)-1]
}
- if _, ok := buildToolchain.(gccgcToolchain); ok {
+ if _, ok := buildToolchain.(gccgoToolchain); ok {
// we don't use dynimport when using gccgo.
return outGo, outObj, nil
}
}
soname := p.swigSoname(file)
- _, gccgo := buildToolchain.(gccgcToolchain)
+ _, gccgo := buildToolchain.(gccgoToolchain)
// swig
args := []string{