code review 7432048: cmd/cgo: use explicit flag to emit dynamic linker path

src/cmd/go/build.go

 // Copyright 2011 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 (
         "bytes"
         "container/heap"
         "errors"
@@ skipping 796 matching lines @@
                 }
                 cgoObjects = append(cgoObjects, outObj...)
                 gofiles = append(gofiles, outGo...)
         }
 
         // Prepare Go import path list.
         inc := b.includeArgs("-I", a.deps)
 
         // Compile Go.
         if len(gofiles) > 0 {
-                out, err := buildToolchain.gc(b, a.p, obj, inc, gofiles)
+                ofile, out, err := buildToolchain.gc(b, a.p, obj, inc, gofiles)
+                if len(out) > 0 {
+                        b.showOutput(a.p.Dir, a.p.ImportPath, b.processOutput(out))
+                        if err != nil {
+                                return errPrintedOutput
+                        }
+                }
                 if err != nil {
                         return err
                 }
-                objects = append(objects, out)
+                objects = append(objects, ofile)
         }
 
         // Copy .h files named for goos or goarch or goos_goarch
         // to names using GOOS and GOARCH.
         // For example, defs_linux_amd64.h becomes defs_GOOS_GOARCH.h.
         _goos_goarch := "_" + goos + "_" + goarch + ".h"
         _goos := "_" + goos + ".h"
         _goarch := "_" + goarch + ".h"
         for _, file := range a.p.HFiles {
                 switch {
@@ skipping 346 matching lines @@
 var errPrintedOutput = errors.New("already printed output - no need to show error")
 
 var cgoLine = regexp.MustCompile(`\[[^\[\]]+\.cgo1\.go:[0-9]+\]`)
 
 // run runs the command given by cmdline in the directory dir.
 // If the command fails, run prints information about the failure
 // and returns a non-nil error.
 func (b *builder) run(dir string, desc string, cmdargs ...interface{}) error {
         out, err := b.runOut(dir, desc, cmdargs...)
         if len(out) > 0 {
-                if out[len(out)-1] != '\n' {
-                        out = append(out, '\n')
-                }
                 if desc == "" {
                         desc = b.fmtcmd(dir, "%s", strings.Join(stringList(cmdargs...), " "))
                 }
-                out := string(out)
-                // Fix up output referring to cgo-generated code to be more readable.
-                // Replace x.go:19[/tmp/.../x.cgo1.go:18] with x.go:19.
-                // Replace _Ctype_foo with C.foo.
-                // If we're using -x, assume we're debugging and want the full dump, so disable the rewrite.
-                if !buildX && cgoLine.MatchString(out) {
-                        out = cgoLine.ReplaceAllString(out, "")
-                        out = strings.Replace(out, "type _Ctype_", "type C.", -1)
-                }
-                b.showOutput(dir, desc, out)
+                b.showOutput(dir, desc, b.processOutput(out))
                 if err != nil {
                         err = errPrintedOutput
                 }
         }
         return err
+}
+
+// processOutput prepares the output of runOut to be output to the console.
+func (b *builder) processOutput(out []byte) string {
+        if out[len(out)-1] != '\n' {
+                out = append(out, '\n')
+        }
+        messages := string(out)
+        // Fix up output referring to cgo-generated code to be more readable.
+        // Replace x.go:19[/tmp/.../x.cgo1.go:18] with x.go:19.
+        // Replace _Ctype_foo with C.foo.
+        // If we're using -x, assume we're debugging and want the full dump, so disable the rewrite.
+        if !buildX && cgoLine.MatchString(messages) {
+                messages = cgoLine.ReplaceAllString(messages, "")
+                messages = strings.Replace(messages, "type _Ctype_", "type C.", -1)
+        }
+        return messages
 }
 
 // runOut runs the command given by cmdline in the directory dir.
 // It returns the command output and any errors that occurred.
 func (b *builder) runOut(dir string, desc string, cmdargs ...interface{}) ([]byte, error) {
         cmdline := stringList(cmdargs...)
         if buildN || buildX {
                 b.showcmd(dir, "%s", strings.Join(cmdline, " "))
                 if buildN {
                         return nil, nil
@@ skipping 99 matching lines @@
         if filepath.IsAbs(f) || strings.HasPrefix(f, "$WORK") {
                 return f
         }
         return filepath.Join(dir, f)
 }
 
 type toolchain interface {
         // gc runs the compiler in a specific directory on a set of files
         // and returns the name of the generated output file.
         // The compiler runs in the directory dir.
-        gc(b *builder, p *Package, obj string, importArgs []string, gofiles []string) (ofile string, err error)
+        gc(b *builder, p *Package, obj string, importArgs []string, gofiles []string) (ofile string, out []byte, err error)
         // cc runs the toolchain's C compiler in a directory on a C file
         // to produce an output file.
         cc(b *builder, p *Package, objdir, ofile, cfile string) error
         // asm runs the assembler in a specific directory on a specific file
         // to generate the named output file.
         asm(b *builder, p *Package, obj, ofile, sfile string) error
         // pkgpath builds an appropriate path for a temporary package file.
         pkgpath(basedir string, p *Package) string
         // pack runs the archive packer in a specific directory to create
         // an archive from a set of object files.
@@ skipping 16 matching lines @@
 func (noToolchain) compiler() string {
         noCompiler()
         return ""
 }
 
 func (noToolchain) linker() string {
         noCompiler()
         return ""
 }
 
-func (noToolchain) gc(b *builder, p *Package, obj string, importArgs []string, gofiles []string) (ofile string, err error) {
-        return "", noCompiler()
+func (noToolchain) gc(b *builder, p *Package, obj string, importArgs []string, gofiles []string) (ofile string, out []byte, err error) {
+        return "", nil, noCompiler()
 }
 
 func (noToolchain) asm(b *builder, p *Package, obj, ofile, sfile string) error {
         return noCompiler()
 }
 
 func (noToolchain) pkgpath(basedir string, p *Package) string {
         noCompiler()
         return ""
 }
@@ skipping 14 matching lines @@
 type gcToolchain struct{}
 
 func (gcToolchain) compiler() string {
         return tool(archChar + "g")
 }
 
 func (gcToolchain) linker() string {
         return tool(archChar + "l")
 }
 
-func (gcToolchain) gc(b *builder, p *Package, obj string, importArgs []string, gofiles []string) (ofile string, err error) {
+func (gcToolchain) gc(b *builder, p *Package, obj string, importArgs []string, gofiles []string) (ofile string, output []byte, err error) {
         out := "_go_." + archChar
         ofile = obj + out
         gcargs := []string{"-p", p.ImportPath}
         if p.Standard && p.ImportPath == "runtime" {
                 // runtime compiles with a special 6g flag to emit
                 // additional reflect type data.
                 gcargs = append(gcargs, "-+")
         }
 
         // If we're giving the compiler the entire package (no C etc files), tell it that,
         // so that it can give good error messages about forward declarations.
         // Exceptions: a few standard packages have forward declarations for
         // pieces supplied behind-the-scenes by package runtime.
         extFiles := len(p.CgoFiles) + len(p.CFiles) + len(p.SFiles) + len(p.SysoFiles) + len(p.SwigFiles) + len(p.SwigCXXFiles)
         if p.Standard {
                 switch p.ImportPath {
                 case "os", "runtime/pprof", "sync", "time":
                         extFiles++
                 }
         }
         if extFiles == 0 {
                 gcargs = append(gcargs, "-complete")
         }
 
         args := stringList(tool(archChar+"g"), "-o", ofile, buildGcflags, gcargs, "-D", p.localPrefix, importArgs)
         for _, f := range gofiles {
                 args = append(args, mkAbs(p.Dir, f))
         }
-        return ofile, b.run(p.Dir, p.ImportPath, args)
+
+        output, err = b.runOut(p.Dir, p.ImportPath, args)
+        return ofile, output, err
 }
 
 func (gcToolchain) asm(b *builder, p *Package, obj, ofile, sfile string) error {
         sfile = mkAbs(p.Dir, sfile)
         return b.run(p.Dir, p.ImportPath, tool(archChar+"a"), "-I", obj, "-o", ofile, "-D", "GOOS_"+goos, "-D", "GOARCH_"+goarch, sfile)
 }
 
 func (gcToolchain) pkgpath(basedir string, p *Package) string {
         end := filepath.FromSlash(p.ImportPath + ".a")
         return filepath.Join(basedir, end)
@@ skipping 39 matching lines @@
 var gccgoBin, _ = exec.LookPath("gccgo")
 
 func (gccgoToolchain) compiler() string {
         return gccgoBin
 }
 
 func (gccgoToolchain) linker() string {
         return gccgoBin
 }
 
-func (gccgoToolchain) 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, output []byte, err error) {
         out := p.Name + ".o"
         ofile = obj + out
         gcargs := []string{"-g"}
         gcargs = append(gcargs, b.gccArchArgs()...)
         if pkgpath := gccgoPkgpath(p); pkgpath != "" {
                 gcargs = append(gcargs, "-fgo-pkgpath="+pkgpath)
         }
         if p.localPrefix != "" {
                 gcargs = append(gcargs, "-fgo-relative-import-path="+p.localPrefix)
         }
         args := stringList("gccgo", importArgs, "-c", gcargs, "-o", ofile, buildGccgoflags)
         for _, f := range gofiles {
                 args = append(args, mkAbs(p.Dir, f))
         }
-        return ofile, b.run(p.Dir, p.ImportPath, args)
+
+        output, err = b.runOut(p.Dir, p.ImportPath, args)
+        return ofile, output, err
 }
 
 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 != "" {
                 defs = append(defs, `-D`, `GOPKGPATH="`+pkgpath+`"`)
         }
         defs = append(defs, b.gccArchArgs()...)
         return b.run(p.Dir, p.ImportPath, "gccgo", "-I", obj, "-o", ofile, defs, sfile)
@@ skipping 378 matching lines @@
         // NOTE(rsc): The importObj is a 5c/6c/8c object and on Windows
         // must be processed before the gcc-generated objects.
         // Put it first.  http://golang.org/issue/2601
         outObj = stringList(importObj, nonGccObjs, ofile)
 
         return outGo, outObj, nil
 }
 
 // Run SWIG on all SWIG input files.
 func (b *builder) swig(p *Package, obj string, gccfiles []string) (outGo, outObj []string, err error) {
+
+        intgosize, err := b.swigIntSize(obj)
+        if err != nil {
+                return nil, nil, err
+        }
+
         for _, f := range p.SwigFiles {
-                goFile, objFile, err := b.swigOne(p, f, obj, false)
+                goFile, objFile, err := b.swigOne(p, f, obj, false, intgosize)
                 if err != nil {
                         return nil, nil, err
                 }
                 if goFile != "" {
                         outGo = append(outGo, goFile)
                 }
                 if objFile != "" {
                         outObj = append(outObj, objFile)
                 }
         }
         for _, f := range p.SwigCXXFiles {
-                goFile, objFile, err := b.swigOne(p, f, obj, true)
+                goFile, objFile, err := b.swigOne(p, f, obj, true, intgosize)
                 if err != nil {
                         return nil, nil, err
                 }
                 if goFile != "" {
                         outGo = append(outGo, goFile)
                 }
                 if objFile != "" {
                         outObj = append(outObj, objFile)
                 }
         }
         return outGo, outObj, nil
 }
 
+// This code fails to build if sizeof(int) <= 32
+const swigIntSizeCode = `
+package main
+const i int = 1 << 32
+`
+
+// Determine the size of int on the target system for the -intgosize option
+// of swig >= 2.0.9
+func (b *builder) swigIntSize(obj string) (intsize string, err error) {
+        src := filepath.Join(b.work, "swig_intsize.go")
+        if err = ioutil.WriteFile(src, []byte(swigIntSizeCode), 0644); err != nil {
+                return
+        }
+        srcs := []string{src}
+
+        p := goFilesPackage(srcs)
+
+        if _, _, e := buildToolchain.gc(b, p, obj, nil, srcs); e != nil {
+                return "32", nil
+        }
+        return "64", nil
+}
+
 // Run SWIG on one SWIG input file.
-func (b *builder) swigOne(p *Package, file, obj string, cxx bool) (outGo, outObj string, err error) {
+func (b *builder) swigOne(p *Package, file, obj string, cxx bool, intgosize string) (outGo, outObj string, err error) {
         n := 5 // length of ".swig"
         if cxx {
                 n = 8 // length of ".swigcxx"
         }
         base := file[:len(file)-n]
         goFile := base + ".go"
         cBase := base + "_gc."
         gccBase := base + "_wrap."
         gccExt := "c"
         if cxx {
                 gccExt = "cxx"
         }
         soname := p.swigSoname(file)
 
         _, gccgo := buildToolchain.(gccgoToolchain)
 
         // swig
         args := []string{
                 "-go",
+                "-intgosize", intgosize,
                 "-module", base,
                 "-soname", soname,
                 "-o", obj + gccBase + gccExt,
                 "-outdir", obj,
         }
         if gccgo {
                 args = append(args, "-gccgo")
         }
         if cxx {
                 args = append(args, "-c++")
         }
 
-        if err := b.run(p.Dir, p.ImportPath, "swig", args, file); err != nil {
+        if out, err := b.runOut(p.Dir, p.ImportPath, "swig", args, file); err != nil {
+                if len(out) > 0 {
+                        if bytes.Contains(out, []byte("Unrecognized option -intgosize")) {
+                                return "", "", errors.New("must have SWIG version >= 2.0.9\n")
+                        }
+                        b.showOutput(p.Dir, p.ImportPath, b.processOutput(out))
+                        return "", "", errPrintedOutput
+                }
                 return "", "", err
         }
 
         var cObj string
         if !gccgo {
                 // cc
                 cObj = obj + cBase + archChar
                 if err := buildToolchain.cc(b, p, obj, cObj, obj+cBase+"c"); err != nil {
                         return "", "", err
                 }
@@ skipping 52 matching lines @@
         if goarch != "amd64" || goos != "linux" && goos != "darwin" && goos != "windows" {
                 fmt.Fprintf(os.Stderr, "go %s: -race is only supported on linux/amd64, darwin/amd64 and windows/amd64\n", flag.Args()[0])
                 os.Exit(2)
         }
         buildGcflags = append(buildGcflags, "-race")
         buildLdflags = append(buildLdflags, "-race")
         buildCcflags = append(buildCcflags, "-D", "RACE")
         buildContext.InstallTag = "race"
         buildContext.BuildTags = append(buildContext.BuildTags, "race")
 }