| blob | a62bc86c26232638f861c5fe35edecbd727ad199 |
1 // Copyright 2011 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
5 package main
8 "bufio"
9 "bytes"
10 "container/heap"
11 "debug/elf"
12 "errors"
13 "flag"
14 "fmt"
15 "go/build"
16 "io"
17 "io/ioutil"
18 "log"
19 "os"
20 "os/exec"
21 "path"
22 "path/filepath"
23 "regexp"
24 "runtime"
25 "strconv"
26 "strings"
27 "sync"
28 "time"
29 )
35 Build compiles the packages named by the import paths,
36 along with their dependencies, but it does not install the results.
38 If the arguments to build are a list of .go files, build treats
39 them as a list of source files specifying a single package.
41 When compiling a single main package, build writes
42 the resulting executable to an output file named after
43 the first source file ('go build ed.go rx.go' writes 'ed' or 'ed.exe')
44 or the source code directory ('go build unix/sam' writes 'sam' or 'sam.exe').
45 The '.exe' suffix is added when writing a Windows executable.
47 When compiling multiple packages or a single non-main package,
48 build compiles the packages but discards the resulting object,
49 serving only as a check that the packages can be built.
51 When compiling packages, build ignores files that end in '_test.go'.
53 The -o flag, only allowed when compiling a single package,
54 forces build to write the resulting executable or object
55 to the named output file, instead of the default behavior described
56 in the last two paragraphs.
58 The -i flag installs the packages that are dependencies of the target.
60 The build flags are shared by the build, clean, get, install, list, run,
61 and test commands:
63 -a
64 force rebuilding of packages that are already up-to-date.
65 -n
66 print the commands but do not run them.
67 -p n
68 the number of programs, such as build commands or
69 test binaries, that can be run in parallel.
70 The default is the number of CPUs available.
71 -race
72 enable data race detection.
73 Supported only on linux/amd64, freebsd/amd64, darwin/amd64 and windows/amd64.
74 -msan
75 enable interoperation with memory sanitizer.
76 Supported only on linux/amd64,
77 and only with Clang/LLVM as the host C compiler.
78 -v
79 print the names of packages as they are compiled.
80 -work
81 print the name of the temporary work directory and
82 do not delete it when exiting.
83 -x
84 print the commands.
86 -asmflags 'flag list'
87 arguments to pass on each go tool asm invocation.
88 -buildmode mode
89 build mode to use. See 'go help buildmode' for more.
90 -compiler name
91 name of compiler to use, as in runtime.Compiler (gccgo or gc).
92 -gccgoflags 'arg list'
93 arguments to pass on each gccgo compiler/linker invocation.
94 -gcflags 'arg list'
95 arguments to pass on each go tool compile invocation.
96 -installsuffix suffix
97 a suffix to use in the name of the package installation directory,
98 in order to keep output separate from default builds.
99 If using the -race flag, the install suffix is automatically set to race
100 or, if set explicitly, has _race appended to it. Likewise for the -msan
101 flag. Using a -buildmode option that requires non-default compile flags
102 has a similar effect.
103 -ldflags 'flag list'
104 arguments to pass on each go tool link invocation.
105 -linkshared
106 link against shared libraries previously created with
107 -buildmode=shared.
108 -pkgdir dir
109 install and load all packages from dir instead of the usual locations.
110 For example, when building with a non-standard configuration,
111 use -pkgdir to keep generated packages in a separate location.
112 -tags 'tag list'
113 a list of build tags to consider satisfied during the build.
114 For more information about build tags, see the description of
115 build constraints in the documentation for the go/build package.
116 -toolexec 'cmd args'
117 a program to use to invoke toolchain programs like vet and asm.
118 For example, instead of running asm, the go command will run
119 'cmd args /path/to/asm <arguments for asm>'.
121 The list flags accept a space-separated list of strings. To embed spaces
122 in an element in the list, surround it with either single or double quotes.
124 For more about specifying packages, see 'go help packages'.
125 For more about where packages and binaries are installed,
126 run 'go help gopath'.
127 For more about calling between Go and C/C++, run 'go help c'.
129 Note: Build adheres to certain conventions such as those described
130 by 'go help gopath'. Not all projects can follow these conventions,
131 however. Installations that have their own conventions or that use
132 a separate software build system may choose to use lower-level
133 invocations such as 'go tool compile' and 'go tool link' to avoid
134 some of the overheads and design decisions of the build tool.
136 See also: go install, go get, go clean.
138 }
141 // break init cycle
149 }
151 // Flags set by multiple commands.
171 // Require the source for go std packages
177 // buildCompiler implements flag.Var.
178 // It implements Set by updating both
179 // buildToolchain and buildContext.Compiler.
190 }
193 }
197 }
205 }
206 }
208 // addBuildFlags adds the flags common to the build, clean, get,
209 // install, list, run, and test commands.
236 }
237 }
242 }
246 }
248 // fileExtSplit expects a filename and returns the name
249 // and ext (without the dot). If the file has no
250 // extension, ext will be empty.
256 }
257 return
258 }
263 var err error
267 }
268 return err
269 }
272 // Split fields allowing '' or "" around elements.
273 // Quotes further inside the string do not count.
278 }
280 break
281 }
282 // Accepted quoted string. No unescaping inside.
288 i++
289 }
292 }
295 continue
296 }
299 i++
300 }
303 }
305 }
309 }
315 }
316 }
317 return res
318 }
324 }
325 }
326 return res
327 }
337 pkgsFilter = pkgsNotMain
342 }
343 return p
344 }
354 // Use -shared so that the result is
355 // suitable for inclusion in a PIE or
356 // shared library.
358 }
359 }
360 }
364 pkgsFilter = pkgsMain
375 }
376 }
383 }
388 }
389 fallthrough
392 }
394 pkgsFilter = pkgsMain
406 }
407 }
410 pkgsFilter = pkgsNotMain
418 }
420 }
423 }
426 pkgsFilter = pkgsMain
435 }
437 }
442 }
452 }
454 // TODO(mwhudson): remove -w when that gets fixed in linker.
456 }
457 }
464 }
465 // Don't alter InstallSuffix when modifying default codegen args.
469 }
471 }
472 }
473 }
478 var b builder
486 }
488 // Special case -o /dev/null by not writing at all.
491 }
493 // sanity check some often mis-used options
497 fmt.Println("go build: when using gccgo toolchain, please pass compiler flags using -gccgoflags, not -gcflags")
498 }
500 fmt.Println("go build: when using gccgo toolchain, please pass linker flags using -gccgoflags, not -ldflags")
501 }
504 fmt.Println("go build: when using gc toolchain, please pass compile flags using -gcflags, and linker flags using -ldflags")
505 }
506 }
508 depMode := modeBuild
510 depMode = modeInstall
511 }
518 }
525 return
526 }
535 }
540 }
541 }
543 }
549 Install compiles and installs the packages named by the import paths,
550 along with their dependencies.
552 For more about the build flags, see 'go help build'.
553 For more about specifying packages, see 'go help packages'.
555 See also: go build, go get, go clean.
557 }
559 // isMetaPackage checks if name is a reserved package name that expands to multiple packages
562 }
564 // libname returns the filename to use for the shared library when using
565 // -buildmode=shared. The rules we use are:
566 // Use arguments for special 'meta' packages:
567 // std --> libstd.so
568 // std cmd --> libstd,cmd.so
569 // A single non-meta argument with trailing "/..." is special cased:
570 // foo/... --> libfoo.so
571 // (A relative path like "./..." expands the "." first)
572 // Use import paths for other cases, changing '/' to '-':
573 // somelib --> libsubdir-somelib.so
574 // ./ or ../ --> libsubdir-somelib.so
575 // gopkg.in/tomb.v2 -> libgopkg.in-tomb.v2.so
576 // a/... b/... ---> liba/c,b/d.so - all matching import paths
577 // Name parts are joined with ','.
582 libname = arg
585 }
586 }
593 }
594 }
597 // Special case of "foo/..." as mentioned above.
604 }
605 }
610 }
611 }
614 }
615 // TODO(mwhudson): Needs to change for platforms that use different naming
616 // conventions...
618 }
622 }
627 }
645 }
646 }
647 }
650 var b builder
652 // Set the behavior for `go get` to not error on packages with test files only.
660 }
665 // If p is a tool, delay the installation until the end of the build.
666 // This avoids installing assemblers/compilers that are being executed
667 // by other steps in the build.
668 // cmd/cgo is handled specially in b.action, so that we can
669 // both build and use it in the same 'go install'.
675 continue
676 }
678 }
682 }
683 }
684 }
688 // Success. If this command is 'go install' with no arguments
689 // and the current directory (the implicit argument) is a command,
690 // remove any leftover command binary from a previous 'go build'.
691 // The binary is installed; it's not needed here anymore.
692 // And worse it might be a stale copy, which you don't want to find
693 // instead of the installed one if $PATH contains dot.
694 // One way to view this behavior is that it is as if 'go install' first
695 // runs 'go build' and the moves the generated file to the install dir.
696 // See issue 9645.
698 // Compute file 'go build' would have created.
699 // If it exists and is an executable file, remove it.
701 targ += exeSuffix
702 if filepath.Join(pkgs[0].Dir, targ) != pkgs[0].Target { // maybe $GOBIN is the current directory
709 }
710 }
711 }
712 }
713 }
714 }
716 // Global build parameters (used during package load)
718 goarch string
719 goos string
720 exeSuffix string
722 )
730 }
732 }
734 // A builder holds global state about a build.
735 // It does not hold per-package state, because we
736 // build packages in parallel, and the builder is shared.
746 output sync.Mutex
749 exec sync.Mutex
751 ready actionQueue
752 }
754 // An action represents a single action in the action graph.
766 // Generated files, directories.
773 // Execution state.
777 }
779 // cacheKey is the key for the action cache.
781 mode buildMode
782 p *Package
783 shlib string
784 }
786 // buildMode specifies the build mode:
787 // are we just building things or also installing the results?
792 modeInstall
793 )
801 )
804 var err error
807 }
817 }
820 }
824 }
825 }
826 }
828 // goFilesPackage creates a package for building a collection of Go files
829 // (typically named on the command line). The target is named p.a for
830 // package p or named after the first Go file for package main.
832 // TODO: Remove this restriction.
836 }
837 }
839 var stk importStack
840 ctxt := buildContext
843 // Synthesize fake "directory" that only shows the named files,
844 // to make it look like this is a standard package or
845 // command directory. So that local imports resolve
846 // consistently, the files must all be in the same directory.
853 }
856 }
860 }
862 dir = dir1
865 }
867 }
870 var err error
872 dir = cwd
873 }
877 }
895 }
898 }
899 }
906 return pkg
907 }
909 // readpkglist returns the list of packages that were built into the shared library
910 // at shlibpath. For the native toolchain this list is stored, newline separated, in
911 // an ELF note with name "Go\x00\x00" and type 1. For GCCGO it is extracted from the
912 // .go_export section.
914 var stk importStack
926 }
927 }
932 }
937 }
938 }
939 return
940 }
942 // action returns the action for applying the given operation (mode) to the package.
943 // depMode is the action to use when building dependencies.
944 // action never looks for p in a shared library, but may find p's dependencies in a
945 // shared library if buildLinkshared is true.
948 }
950 // action1 returns the action for applying the given operation (mode) to the package.
951 // depMode is the action to use when building dependencies.
952 // action1 will look for p in a shared library if lookshared is true.
953 // forShlib is the shared library that p will become part of, if any.
954 func (b *builder) action1(mode buildMode, depMode buildMode, p *Package, lookshared bool, forShlib string) *action {
958 }
963 return a
964 }
970 return a
971 }
976 return a
977 }
982 }
987 // p is part of a shared library.
989 // p1 is explicitly part of a different shared library.
990 // Put the action for that shared library into a.deps.
993 // p1 is (implicitly or not) part of this shared library.
994 // Put the action for p1 into a.deps.
996 }
998 // p is not part of a shared library.
999 // If p1 is in a shared library, put the action for that into
1000 // a.deps, otherwise put the action for p1 into a.deps.
1002 }
1003 }
1005 // If we are not doing a cross-build, then record the binary we'll
1006 // generate for cgo as a dependency of the build of any package
1007 // using cgo, to make sure we do not overwrite the binary while
1008 // a package is using it. If this is a cross-build, then the cgo we
1009 // are writing is not the cgo we need to use.
1010 if goos == runtime.GOOS && goarch == runtime.GOARCH && !buildRace && !buildMSan && reqStdPkgSrc {
1011 if (len(p.CgoFiles) > 0 || p.Standard && p.ImportPath == "runtime/cgo") && !buildLinkshared && buildBuildmode != "shared" {
1012 var stk importStack
1016 }
1019 }
1020 }
1025 // Fake packages - nothing to build.
1026 return a
1027 }
1028 // gccgo standard library is "fake" too.
1030 // the target name is needed for cgo.
1032 return a
1033 }
1034 }
1037 // p.Stale==false implies that p.target is up-to-date.
1038 // Record target name for use by actions depending on this one.
1040 return a
1041 }
1044 // Imported via local path. No permanent target.
1045 mode = modeBuild
1046 }
1050 }
1061 // Install header for cgo in c-archive and c-shared modes.
1065 // For the header file, remove the "lib"
1066 // added by go/build, so we generate pkg.h
1067 // rather than libpkg.h.
1071 }
1079 }
1081 }
1087 // An executable file. (This is the name of a temporary file.)
1088 // Because we run the temporary file in 'go run' and 'go test',
1089 // the name will show up in ps listings. If the caller has specified
1090 // a name, use that instead of a.out. The binary is generated
1091 // in an otherwise empty subdirectory named exe to avoid
1092 // naming conflicts. The only possible conflict is if we were
1093 // to create a top-level package named exe.
1098 // On OS X, the linker output name gets recorded in the
1099 // shared library's LC_ID_DYLIB load command.
1100 // The code invoking the linker knows to pass only the final
1101 // path element. Arrange that the path element matches what
1102 // we'll install it as; otherwise the library is only loadable as "a.out".
1104 }
1106 }
1107 }
1109 return a
1110 }
1112 func (b *builder) libaction(libname string, pkgs []*Package, mode, depMode buildMode) *action {
1123 continue
1124 }
1126 }
1129 // Currently build mode shared forces external linking mode, and
1130 // external linking mode forces an import of runtime/cgo (and
1131 // math on arm). So if it was not passed on the command line and
1132 // it is not present in another shared library, add it here.
1138 }
1140 var stk importStack
1144 }
1146 // If runtime/cgo is in another shared library, then that's
1147 // also the shared library that contains runtime, so
1148 // something will depend on it and so runtime/cgo's staleness
1149 // will be checked when processing that library.
1153 }
1154 }
1159 }
1161 var stk importStack
1165 }
1167 // If math is in another shared library, then that's
1168 // also the shared library that contains runtime, so
1169 // something will depend on it and so math's staleness
1170 // will be checked when processing that library.
1174 }
1175 }
1176 }
1177 }
1179 // Figure out where the library will go.
1185 }
1187 libdir = plibdir
1190 }
1191 }
1194 // Now we can check whether we need to rebuild it.
1199 }
1202 continue
1203 }
1208 }
1210 }
1218 continue
1219 }
1225 }
1226 }
1227 }
1228 return a
1229 }
1231 // actionList returns the list of actions in the dag rooted at root
1232 // as visited in a depth-first post-order traversal.
1239 return
1240 }
1244 }
1246 }
1248 return all
1249 }
1251 // allArchiveActions returns a list of the archive dependencies of root.
1252 // This is needed because if package p depends on package q that is in libr.so, the
1253 // action graph looks like p->libr.so->q and so just scanning through p's
1254 // dependencies does not find the import dir for q.
1261 return
1262 }
1267 }
1270 }
1271 }
1273 return r
1274 }
1276 // do runs the action graph rooted at root.
1278 /* Commented out for gccgo, which does not have osArchSupportsCgo.
1280 if _, ok := osArchSupportsCgo[goos+"/"+goarch]; !ok && buildContext.Compiler == "gc" {
1281 fmt.Fprintf(os.Stderr, "cmd/go: unsupported GOOS/GOARCH pair %s/%s\n", goos, goarch)
1282 os.Exit(2)
1283 }
1284 */
1286 // Build list of all actions, assigning depth-first post-order priority.
1287 // The original implementation here was a true queue
1288 // (using a channel) but it had the effect of getting
1289 // distracted by low-level leaf actions to the detriment
1290 // of completing higher-level actions. The order of
1291 // work does not matter much to overall execution time,
1292 // but when running "go test std" it is nice to see each test
1293 // results as soon as possible. The priorities assigned
1294 // ensure that, all else being equal, the execution prefers
1295 // to do what it would have done first in a simple depth-first
1296 // dependency order traversal.
1300 }
1304 // Initialize per-action execution state.
1308 }
1313 }
1314 }
1316 // Handle runs a single action and takes care of triggering
1317 // any actions that are runnable as a result.
1319 var err error
1322 }
1324 // The actions run in parallel but all the updates to the
1325 // shared work state are serialized through b.exec.
1332 } else if _, ok := err.(*build.NoGoError); ok && len(a.p.TestGoFiles) > 0 && b.testFilesOnlyOK {
1333 // Ignore the "no buildable Go source files" error for a package with only test files.
1336 }
1338 }
1343 }
1347 }
1348 }
1352 }
1353 }
1357 // Kick off goroutines according to parallelism.
1358 // If we are using the -n flag (just printing commands)
1359 // drop the parallelism to 1, both to make the output
1360 // deterministic and because there is no real work anyway.
1361 par := buildP
1364 }
1373 return
1374 }
1375 // Receiving a value from b.readySema entitles
1376 // us to take from the ready queue.
1383 return
1384 }
1385 }
1386 }()
1387 }
1390 }
1392 // build is the action for building a single package or command.
1394 // Return an error for binary-only package.
1395 // We only reach this if isStale believes the binary form is
1396 // either not present or not usable.
1398 return fmt.Errorf("missing or invalid package binary for binary-only package %s", a.p.ImportPath)
1399 }
1401 // Return an error if the package has CXX files but it's not using
1402 // cgo nor SWIG, since the CXX files can only be processed by cgo
1403 // and SWIG.
1405 return fmt.Errorf("can't build package %s because it contains C++ files (%s) but it's not using cgo nor SWIG",
1407 }
1408 // Same as above for Objective-C files
1410 return fmt.Errorf("can't build package %s because it contains Objective-C files (%s) but it's not using cgo nor SWIG",
1412 }
1413 // Same as above for Fortran files
1415 return fmt.Errorf("can't build package %s because it contains Fortran files (%s) but it's not using cgo nor SWIG",
1417 }
1420 if _, ok := err.(*build.NoGoError); err != nil && err != errPrintedOutput && !(ok && b.testFilesOnlyOK && len(a.p.TestGoFiles) > 0) {
1422 }
1423 }()
1425 // In -n mode, print a banner between packages.
1426 // The banner is five lines so that when changes to
1427 // different sections of the bootstrap script have to
1428 // be merged, the banners give patch something
1429 // to use to find its context.
1431 }
1435 }
1437 // Make build directory.
1440 return err
1441 }
1443 // make target directory
1447 return err
1448 }
1449 }
1451 var gofiles, cgofiles, objdirCgofiles, cfiles, sfiles, cxxfiles, objects, cgoObjects, pcCFLAGS, pcLDFLAGS []string
1461 return
1462 }
1463 }
1465 // Run SWIG on each .swig and .swigcxx file.
1466 // Each run will generate two files, a .go file and a .c or .cxx file.
1467 // The .go file will use import "C" and is to be processed by cgo.
1471 return err
1472 }
1476 }
1478 // Run cgo.
1480 // In a package using cgo, cgo compiles the C, C++ and assembly files with gcc.
1481 // There is one exception: runtime/cgo's job is to bridge the
1482 // cgo and non-cgo worlds, so it necessarily has files in both.
1483 // In that case gcc only gets the gcc_* files.
1494 }
1495 }
1497 }
1502 }
1507 }
1508 outGo, outObj, err := b.cgo(a, cgoExe, obj, pcCFLAGS, pcLDFLAGS, cgofiles, objdirCgofiles, gccfiles, cxxfiles, a.p.MFiles, a.p.FFiles)
1510 return err
1511 }
1514 }
1517 }
1521 }
1523 // If we're doing coverage, preprocess the .go files and put them in the work directory
1530 // cgo files have absolute paths
1532 sourceFile = file
1538 key = file
1539 }
1542 // Not covering this file.
1543 continue
1544 }
1546 return err
1547 }
1549 }
1550 }
1552 // Prepare Go import path list.
1555 // Compile Go.
1560 return errPrintedOutput
1561 }
1562 }
1564 return err
1565 }
1568 }
1570 // Copy .h files named for goos or goarch or goos_goarch
1571 // to names using GOOS and GOARCH.
1572 // For example, defs_linux_amd64.h becomes defs_GOOS_GOARCH.h.
1582 return err
1583 }
1587 return err
1588 }
1592 return err
1593 }
1594 }
1595 }
1600 return err
1601 }
1603 }
1605 // Assemble .s files.
1609 return err
1610 }
1612 }
1614 // NOTE(rsc): On Windows, it is critically important that the
1615 // gcc-compiled objects (cgoObjects) be listed after the ordinary
1616 // objects in the archive. I do not know why this is.
1617 // https://golang.org/issue/2601
1620 // Add system object files.
1623 }
1625 // Pack into archive in obj directory.
1626 // If the Go compiler wrote an archive, we only need to add the
1627 // object files for non-Go sources to the archive.
1628 // If the Go compiler wrote an archive and the package is entirely
1629 // Go sources, there is no pack to execute at all.
1632 return err
1633 }
1634 }
1636 // Link if needed.
1638 // The compiler only cares about direct imports, but the
1639 // linker needs the whole dependency tree.
1643 return err
1644 }
1645 }
1648 }
1650 // pkgconfigCmd returns a pkg-config binary name
1651 // defaultPkgConfig is defined in zdefaultcc.go, written by cmd/dist.
1654 }
1656 // splitPkgConfigOutput parses the pkg-config output into a slice of
1657 // flags. pkg-config always uses \ to escape special characters.
1661 }
1670 }
1673 r++
1674 fallthrough
1678 w++
1679 }
1680 }
1681 r++
1682 }
1685 }
1686 return flags
1687 }
1689 // Calls pkg-config if needed and returns the cflags/ldflags needed to build the package.
1697 err = errPrintedOutput
1698 return
1699 }
1702 }
1707 err = errPrintedOutput
1708 return
1709 }
1712 }
1713 }
1714 return
1715 }
1721 return err
1722 }
1725 }
1727 }
1733 }
1735 // install is the action for installing a single package or executable.
1740 }
1741 }()
1749 }
1750 }
1752 // make target directory
1756 return err
1757 }
1758 }
1760 // remove object dir to keep the amount of
1761 // garbage down in a large build. On an operating system
1762 // with aggressive buffering, cleaning incrementally like
1763 // this keeps the intermediate objects from hitting the disk.
1767 }
1770 }
1772 // includeArgs returns the -I or -L directory list for access
1773 // to the results of the list of actions.
1780 }
1782 // Look in the temporary space for results of test-specific actions.
1783 // This is the $WORK/my/package/_test directory for the
1784 // package being built, so there are few of these.
1787 continue
1788 }
1792 }
1793 }
1795 // Also look in $WORK for any non-test packages that have
1796 // been built but not installed.
1799 // Finally, look in the installed package directories for each action.
1800 // First add the package dirs corresponding to GOPATH entries
1801 // in the original GOPATH order.
1806 }
1807 }
1812 }
1813 }
1815 // Then add anything that's left.
1818 continue
1819 }
1823 }
1824 }
1826 return inc
1827 }
1829 // moveOrCopyFile is like 'mv src dst' or 'cp src dst'.
1830 func (b *builder) moveOrCopyFile(a *action, dst, src string, perm os.FileMode, force bool) error {
1834 }
1836 // If we can update the mode and rename to the dst, do it.
1837 // Otherwise fall back to standard copy.
1839 // The perm argument is meant to be adjusted according to umask,
1840 // but we don't know what the umask is.
1841 // Create a dummy file to find out.
1842 // This avoids build tags and works even on systems like Plan 9
1843 // where the file mask computation incorporates other information.
1844 mode := perm
1845 f, err := os.OpenFile(filepath.Clean(dst)+"-go-tmp-umask", os.O_WRONLY|os.O_CREATE|os.O_EXCL, perm)
1850 }
1854 }
1860 }
1862 }
1863 }
1866 }
1868 // copyFile is like 'cp src dst'.
1874 }
1875 }
1879 return err
1880 }
1883 // Be careful about removing/overwriting dst.
1884 // Do not remove/overwrite if dst exists and is a directory
1885 // or a non-object file.
1889 }
1892 }
1893 }
1895 // On Windows, remove lingering ~ file from last attempt.
1899 }
1900 }
1905 // Windows does not allow deletion of a binary file
1906 // while it is executing. Try to move it out of the way.
1907 // If the move fails, which is likely, we'll try again the
1908 // next time we do an install of this binary.
1911 }
1913 }
1915 return err
1916 }
1923 }
1925 }
1927 // Install the cgo export header file, if there is one.
1931 // If the file does not exist, there are no exported
1932 // functions, and we do not install anything.
1934 }
1939 return err
1940 }
1941 }
1944 }
1946 // cover runs, in effect,
1947 // go tool cover -mode=b.coverMode -var="varName" -o dst.go src.go
1950 buildToolExec,
1955 src)
1956 }
1969 }
1975 }
1982 }
1983 }
1985 }
1987 // mayberemovefile removes a file only if it is a regular file
1988 // When running as a user with sufficient privileges, we may delete
1989 // even device files, for example, which is not intended.
1992 return
1993 }
1995 }
1997 // fmtcmd formats a command in the manner of fmt.Sprintf but also:
1998 //
1999 // If dir is non-empty and the script is not in dir right now,
2000 // fmtcmd inserts "cd dir\n" before the command.
2001 //
2002 // fmtcmd replaces the value of b.work with $WORK.
2003 // fmtcmd replaces the value of goroot with $GOROOT.
2004 // fmtcmd replaces the value of b.gobin with $GOBIN.
2005 //
2006 // fmtcmd replaces the name of the current directory with dot (.)
2007 // but only when it is at the beginning of a space-separated token.
2008 //
2016 }
2017 }
2020 }
2021 return cmd
2022 }
2024 // showcmd prints the given command to standard output
2025 // for the implementation of -n or -x.
2030 }
2032 // showOutput prints "# desc" followed by the given output.
2033 // The output is expected to contain references to 'dir', usually
2034 // the source directory for the package that has failed to build.
2035 // showOutput rewrites mentions of dir with a relative path to dir
2036 // when the relative path is shorter. This is usually more pleasant.
2037 // For example, if fmt doesn't compile and we are in src/html,
2038 // the output is
2039 //
2040 // $ go build
2041 // # fmt
2042 // ../fmt/print.go:1090: undefined: asdf
2043 // $
2044 //
2045 // instead of
2046 //
2047 // $ go build
2048 // # fmt
2049 // /usr/gopher/go/src/fmt/print.go:1090: undefined: asdf
2050 // $
2051 //
2052 // showOutput also replaces references to the work directory with $WORK.
2053 //
2060 }
2066 }
2068 // shortPath returns an absolute or relative name for path, whatever is shorter.
2071 return rel
2072 }
2073 return path
2074 }
2076 // relPaths returns a copy of paths with absolute paths
2077 // made relative to the current directory if they would be shorter.
2084 p = rel
2085 }
2087 }
2088 return out
2089 }
2091 // errPrintedOutput is a special error indicating that a command failed
2092 // but that it generated output as well, and that output has already
2093 // been printed, so there's no point showing 'exit status 1' or whatever
2094 // the wait status was. The main executor, builder.do, knows not to
2095 // print this error.
2101 // run runs the command given by cmdline in the directory dir.
2102 // If the command fails, run prints information about the failure
2103 // and returns a non-nil error.
2109 }
2112 err = errPrintedOutput
2113 }
2114 }
2115 return err
2116 }
2118 // processOutput prepares the output of runOut to be output to the console.
2122 }
2124 // Fix up output referring to cgo-generated code to be more readable.
2125 // Replace x.go:19[/tmp/.../x.cgo1.go:18] with x.go:19.
2126 // Replace *[100]_Ctype_foo with *[100]C.foo.
2127 // If we're using -x, assume we're debugging and want the full dump, so disable the rewrite.
2131 }
2132 return messages
2133 }
2135 // runOut runs the command given by cmdline in the directory dir.
2136 // It returns the command output and any errors that occurred.
2137 func (b *builder) runOut(dir string, desc string, env []string, cmdargs ...interface{}) ([]byte, error) {
2144 }
2149 }
2150 }
2162 // cmd.Run will fail on Unix if some other process has the binary
2163 // we want to run open for writing. This can happen here because
2164 // we build and install the cgo command and then run it.
2165 // If another command was kicked off while we were writing the
2166 // cgo binary, the child process for that command may be holding
2167 // a reference to the fd, keeping us from running exec.
2168 //
2169 // But, you might reasonably wonder, how can this happen?
2170 // The cgo fd, like all our fds, is close-on-exec, so that we need
2171 // not worry about other processes inheriting the fd accidentally.
2172 // The answer is that running a command is fork and exec.
2173 // A child forked while the cgo fd is open inherits that fd.
2174 // Until the child has called exec, it holds the fd open and the
2175 // kernel will not let us run cgo. Even if the child were to close
2176 // the fd explicitly, it would still be open from the time of the fork
2177 // until the time of the explicit close, and the race would remain.
2178 //
2179 // On Unix systems, this results in ETXTBSY, which formats
2180 // as "text file busy". Rather than hard-code specific error cases,
2181 // we just look for that string. If this happens, sleep a little
2182 // and try again. We let this happen three times, with increasing
2183 // sleep lengths: 100+200+400 ms = 0.7 seconds.
2184 //
2185 // An alternate solution might be to split the cmd.Run into
2186 // separate cmd.Start and cmd.Wait, and then use an RWLock
2187 // to make sure that copyFile only executes when no cmd.Start
2188 // call is in progress. However, cmd.Start (really syscall.forkExec)
2189 // only guarantees that when it returns, the exec is committed to
2190 // happen and succeed. It uses a close-on-exec file descriptor
2191 // itself to determine this, so we know that when cmd.Start returns,
2192 // at least one close-on-exec file descriptor has been closed.
2193 // However, we cannot be sure that all of them have been closed,
2194 // so the program might still encounter ETXTBSY even with such
2195 // an RWLock. The race window would be smaller, perhaps, but not
2196 // guaranteed to be gone.
2197 //
2198 // Sleeping when we observe the race seems to be the most reliable
2199 // option we have.
2200 //
2201 // https://golang.org/issue/3001
2202 //
2205 nbusy++
2206 continue
2207 }
2209 // err can be something like 'exit status 1'.
2210 // Add information about what program was running.
2211 // Note that if buf.Bytes() is non-empty, the caller usually
2212 // shows buf.Bytes() and does not print err at all, so the
2213 // prefix here does not make most output any more verbose.
2216 }
2218 }
2219 }
2221 // joinUnambiguously prints the slice, quoting where necessary to make the
2222 // output unambiguous.
2223 // TODO: See issue 5279. The printing of commands needs a complete redo.
2229 }
2235 }
2236 }
2238 }
2240 // mkdir makes the named directory.
2244 // We can be a little aggressive about being
2245 // sure directories exist. Skip repeated calls.
2248 }
2255 }
2256 }
2259 return err
2260 }
2262 }
2264 // mkAbs returns an absolute path corresponding to
2265 // evaluating f in the directory dir.
2266 // We always pass absolute paths of source files so that
2267 // the error messages will include the full path to a file
2268 // in need of attention.
2270 // Leave absolute paths alone.
2271 // Also, during -n mode we use the pseudo-directory $WORK
2272 // instead of creating an actual work directory that won't be used.
2273 // Leave paths beginning with $WORK alone too.
2275 return f
2276 }
2278 }
2281 // gc runs the compiler in a specific directory on a set of files
2282 // and returns the name of the generated output file.
2283 gc(b *builder, p *Package, archive, obj string, asmhdr bool, importArgs []string, gofiles []string) (ofile string, out []byte, err error)
2284 // cc runs the toolchain's C compiler in a directory on a C file
2285 // to produce an output file.
2287 // asm runs the assembler in a specific directory on specific files
2288 // and returns a list of named output files.
2290 // pkgpath builds an appropriate path for a temporary package file.
2292 // pack runs the archive packer in a specific directory to create
2293 // an archive from a set of object files.
2294 // typically it is run in the object directory.
2296 // ld runs the linker to create an executable starting at mainpkg.
2297 ld(b *builder, root *action, out string, allactions []*action, mainpkg string, ofiles []string) error
2298 // ldShared runs the linker to create a shared library containing the pkgs built by toplevelactions
2303 }
2310 }
2315 }
2320 }
2322 func (noToolchain) gc(b *builder, p *Package, archive, obj string, asmhdr bool, importArgs []string, gofiles []string) (ofile string, out []byte, err error) {
2324 }
2326 func (noToolchain) asm(b *builder, p *Package, obj string, sfiles []string) ([]string, error) {
2328 }
2333 }
2337 }
2339 func (noToolchain) ld(b *builder, root *action, out string, allactions []*action, mainpkg string, ofiles []string) error {
2341 }
2343 func (noToolchain) ldShared(b *builder, toplevelactions []*action, out string, allactions []*action) error {
2345 }
2349 }
2351 // The Go toolchain.
2356 }
2360 }
2362 func (gcToolchain) gc(b *builder, p *Package, archive, obj string, asmhdr bool, importArgs []string, gofiles []string) (ofile string, output []byte, err error) {
2364 ofile = archive
2368 }
2373 }
2374 if p.Standard && (p.ImportPath == "runtime" || strings.HasPrefix(p.ImportPath, "runtime/internal")) {
2375 // runtime compiles with a special gc flag to emit
2376 // additional reflect type data.
2378 }
2380 // If we're giving the compiler the entire package (no C etc files), tell it that,
2381 // so that it can give good error messages about forward declarations.
2382 // Exceptions: a few standard packages have forward declarations for
2383 // pieces supplied behind-the-scenes by package runtime.
2384 extFiles := len(p.CgoFiles) + len(p.CFiles) + len(p.CXXFiles) + len(p.MFiles) + len(p.FFiles) + len(p.SFiles) + len(p.SysoFiles) + len(p.SwigFiles) + len(p.SwigCXXFiles)
2388 extFiles++
2389 }
2390 }
2393 }
2396 }
2399 }
2406 }
2407 }
2409 args := []interface{}{buildToolExec, tool("compile"), "-o", ofile, "-trimpath", b.work, buildGcflags, gcargs, "-D", p.localPrefix, importArgs}
2412 }
2415 }
2418 }
2422 }
2424 func (gcToolchain) asm(b *builder, p *Package, obj string, sfiles []string) ([]string, error) {
2425 // Add -I pkg/GOOS_GOARCH so #include "textflag.h" works in .s files.
2427 args := []interface{}{buildToolExec, tool("asm"), "-trimpath", b.work, "-I", obj, "-I", inc, "-D", "GOOS_" + goos, "-D", "GOARCH_" + goarch, buildAsmflags}
2432 }
2433 }
2434 }
2442 }
2443 }
2445 }
2447 // toolVerify checks that the command line args writes the same output file
2448 // if run using newTool instead.
2449 // Unused now but kept around for future use.
2450 func toolVerify(b *builder, p *Package, newTool string, ofile string, args []interface{}) error {
2456 return err
2457 }
2460 return err
2461 }
2464 return err
2465 }
2467 return fmt.Errorf("%s and %s produced different output files:\n%s\n%s", filepath.Base(args[1].(string)), newTool, strings.Join(stringList(args...), " "), strings.Join(stringList(newArgs...), " "))
2468 }
2471 }
2476 }
2482 }
2485 // The archive file should have been created by the compiler.
2486 // Since it used to not work that way, verify.
2490 }
2491 }
2496 }
2499 }
2502 return errPrintedOutput
2503 }
2505 }
2510 return err
2511 }
2518 return err
2519 }
2523 return err
2524 }
2525 // Note: Not using %-16.16s format because we care
2526 // about bytes, not runes.
2532 }
2542 }
2545 }
2548 }
2549 }
2552 return err
2553 }
2555 }
2557 // setextld sets the appropriate linker flags for the specified compiler.
2561 // don't override -extld if supplied
2562 return ldflags
2563 }
2564 }
2573 break
2577 break
2578 }
2579 }
2582 }
2583 }
2584 return ldflags
2585 }
2587 func (gcToolchain) ld(b *builder, root *action, out string, allactions []*action, mainpkg string, ofiles []string) error {
2593 }
2594 }
2598 }
2601 }
2606 }
2608 }
2610 // If the user has not specified the -extld option, then specify the
2611 // appropriate linker. In case of C++ code, use the compiler named
2612 // by the CXX environment variable or defaultCXX if CXX is not set.
2613 // Else, use the CC environment variable and defaultCC as fallback.
2619 }
2624 }
2627 // On OS X when using external linking to build a shared library,
2628 // the argument passed here to -o ends up recorded in the final
2629 // shared library in the LC_ID_DYLIB load command.
2630 // To avoid putting the temporary output directory name there
2631 // (and making the resulting shared library useless),
2632 // run the link in the output directory so that -o can name
2633 // just the final path element.
2637 }
2639 return b.run(dir, root.p.ImportPath, nil, buildToolExec, tool("link"), "-o", out, importArgs, ldflags, mainpkg)
2640 }
2642 func (gcToolchain) ldShared(b *builder, toplevelactions []*action, out string, allactions []*action) error {
2651 }
2652 }
2653 // If the user has not specified the -extld option, then specify the
2654 // appropriate linker. In case of C++ code, use the compiler named
2655 // by the CXX environment variable or defaultCXX if CXX is not set.
2656 // Else, use the CC environment variable and defaultCC as fallback.
2662 }
2665 if !strings.HasSuffix(d.target, ".a") { // omit unsafe etc and actions for other shared libraries
2666 continue
2667 }
2669 }
2671 }
2675 }
2677 // The Gccgo toolchain.
2685 gccgoName = defaultGCCGO
2686 }
2688 }
2691 return gccgoBin
2692 }
2695 return gccgoBin
2696 }
2698 func (tools gccgoToolchain) gc(b *builder, p *Package, archive, obj string, asmhdr bool, importArgs []string, gofiles []string) (ofile string, output []byte, err error) {
2707 }
2710 }
2715 }
2716 }
2719 // If this is a new vendor path, add it to the list of importArgs
2722 // Check if the vendor path is already included in dir
2724 continue
2725 }
2726 // Make sure this vendor path is not already in the list for importArgs
2730 continue
2731 }
2732 // This vendorPath is already in the list
2734 goto nextSuffixPath
2735 }
2736 }
2737 // New vendorPath not yet in the importArgs list, so add it
2739 nextSuffixPath:
2740 }
2743 // Make sure this vendor path is not already in the list for importArgs
2747 continue
2748 }
2750 goto nextPrefixPath
2751 }
2752 }
2753 // This vendor path is needed and not already in the list, so add it
2755 nextPrefixPath:
2756 }
2757 }
2758 }
2763 }
2767 }
2769 func (tools gccgoToolchain) asm(b *builder, p *Package, obj string, sfiles []string) ([]string, error) {
2778 }
2781 err := b.run(p.Dir, p.ImportPath, nil, tools.compiler(), "-xassembler-with-cpp", "-I", obj, "-c", "-o", ofile, defs, sfile)
2784 }
2785 }
2787 }
2792 // add "lib" to the final element
2794 }
2796 func (gccgoToolchain) pack(b *builder, p *Package, objDir, afile string, ofiles []string) error {
2800 }
2802 // Try with D modifier first, then without if that fails.
2805 }
2807 }
2809 func (tools gccgoToolchain) link(b *builder, root *action, out string, allactions []*action, mainpkg string, ofiles []string, buildmode, desc string) error {
2810 // gccgo needs explicit linking with all package dependencies,
2811 // and all LDFLAGS from cgo dependencies.
2825 }
2830 return err
2831 }
2837 // Every _cgo_flags file has -g and -O2 in _CGO_LDFLAGS
2838 // but they don't mean anything to the linker so filter
2839 // them out.
2842 }
2843 }
2844 }
2845 }
2847 }
2853 }
2857 }
2861 }
2865 }
2869 }
2875 }
2879 }
2883 }
2885 }
2888 // Make a pre-order depth-first traversal of the action graph, taking note of
2889 // whether a shared library action has been seen on the way to an action (the
2890 // construction of the graph means that if any path to a node passes through
2891 // a shared library action, they all do).
2893 var err error
2896 return
2897 }
2901 return
2902 }
2903 // We record the target of the first time we see a .a file
2904 // for a package to make sure that we prefer the 'install'
2905 // rather than the 'build' location (which may not exist any
2906 // more). We still need to traverse the dependencies of the
2907 // build action though so saying
2908 // if apackagePathsSeen[a.p.ImportPath] { return }
2909 // doesn't work.
2916 return
2917 }
2918 }
2920 }
2921 }
2925 }
2929 return
2930 }
2931 }
2932 }
2936 return err
2937 }
2938 }
2941 // Gather CgoLDFLAGS, but not from standard packages.
2942 // The go tool can dig up runtime/cgo from GOROOT and
2943 // think that it should use its CgoLDFLAGS, but gccgo
2944 // doesn't use runtime/cgo.
2946 continue
2947 }
2950 }
2953 }
2956 }
2959 }
2962 }
2965 }
2966 }
2972 break
2973 }
2974 }
2984 }
2990 ldflags,
2996 }
3003 }
3006 // Link the Go files into a single .o, and also link
3007 // in -lgolibbegin.
3008 //
3009 // We need to use --whole-archive with -lgolibbegin
3010 // because it doesn't define any symbols that will
3011 // cause the contents to be pulled in; it's just
3012 // initialization code.
3013 //
3014 // The user remains responsible for linking against
3015 // -lgo -lpthread -lm in the final link. We can't use
3016 // -r to pick them up because we can't combine
3017 // split-stack and non-split-stack code in a single -r
3018 // link, and libgo picks up non-split-stack code from
3019 // libffi.
3020 ldflags = append(ldflags, "-Wl,-r", "-nostdlib", "-Wl,--whole-archive", "-lgolibbegin", "-Wl,--no-whole-archive")
3024 }
3026 // We are creating an object file, so we don't want a build ID.
3029 realOut = out
3033 ldflags = append(ldflags, "-shared", "-nostdlib", "-Wl,--whole-archive", "-lgolibbegin", "-Wl,--no-whole-archive", "-lgo", "-lgcc_s", "-lgcc", "-lc", "-lgcc")
3041 }
3047 }
3050 }
3055 }
3056 // support gfortran out of the box and let others pass the correct link options
3057 // via CGO_LDFLAGS
3060 }
3061 }
3062 }
3064 if err := b.run(".", desc, nil, tools.linker(), "-o", out, ofiles, ldflags, buildGccgoflags); err != nil {
3065 return err
3066 }
3071 return err
3072 }
3073 }
3075 }
3077 func (tools gccgoToolchain) ld(b *builder, root *action, out string, allactions []*action, mainpkg string, ofiles []string) error {
3079 }
3081 func (tools gccgoToolchain) ldShared(b *builder, toplevelactions []*action, out string, allactions []*action) error {
3085 }
3094 }
3097 }
3101 }
3104 }
3107 }
3109 // maybePIC adds -fPIC to the list of arguments if needed.
3114 }
3115 return args
3116 }
3121 }
3123 }
3130 return r
3131 }
3133 }
3135 }
3137 // gcc runs the gcc C compiler to create an object from a single C file.
3140 }
3142 // gxx runs the g++ C++ compiler to create an object from a single C++ file.
3145 }
3147 // gfortran runs the gfortran Fortran compiler to create an object from a single Fortran file.
3150 }
3152 // ccompile runs the given C or C++ compiler and creates an object from a single source file.
3153 func (b *builder) ccompile(p *Package, outfile string, flags []string, file string, compiler []string) error {
3158 // On FreeBSD 11, when we pass -g to clang 3.8 it
3159 // invokes its internal assembler with -dwarf-version=2.
3160 // When it sees .section .note.GNU-stack, it warns
3161 // "DWARF2 only supports one section per compilation unit".
3162 // This warning makes no sense, since the section is empty,
3163 // but it confuses people.
3164 // We work around the problem by detecting the warning
3165 // and dropping -g and trying again.
3171 }
3172 }
3175 }
3176 }
3180 err = errPrintedOutput
3183 }
3184 }
3185 return err
3186 }
3188 // gccld runs the gcc linker to create an executable from a set of object files.
3195 }
3197 }
3199 // gccCmd returns a gcc command line prefix
3200 // defaultCC is defined in zdefaultcc.go, written by cmd/dist.
3203 }
3205 // gxxCmd returns a g++ command line prefix
3206 // defaultCXX is defined in zdefaultcc.go, written by cmd/dist.
3209 }
3211 // gfortranCmd returns a gfortran command line prefix.
3214 }
3216 // ccompilerCmd returns a command line prefix for the given environment
3217 // variable and using the default command when the variable is empty.
3219 // NOTE: env.go's mkEnv knows that the first three
3220 // strings returned are "gcc", "-I", objdir (and cuts them off).
3226 // Definitely want -fPIC but on Windows gcc complains
3227 // "-fPIC ignored for target (all code is position independent)"
3230 }
3232 // gcc-4.5 and beyond require explicit "-pthread" flag
3233 // for multithreading with pthread library.
3240 }
3241 }
3244 // disable ASCII art in clang errors, if possible
3246 // clang is too smart about command-line arguments
3248 }
3250 // disable word wrapping in error messages
3253 // Tell gcc not to include the work directory in object files.
3256 }
3258 // Tell gcc not to include flags in object files, which defeats the
3259 // point of -fdebug-prefix-map above.
3262 }
3264 // On OS X, some of the compilers behave as if -fno-common
3265 // is always set, and the Mach-O linker in 6l/8l assumes this.
3266 // See https://golang.org/issue/3253.
3269 }
3271 // gccgo uses the language-independent exception mechanism to
3272 // handle panics, so it always needs unwind tables.
3275 }
3277 return a
3278 }
3280 // On systems with PIE (position independent executables) enabled by default,
3281 // -no-pie must be passed when doing a partial link with -Wl,-r. But -no-pie is
3282 // not supported by all compilers.
3285 }
3287 // gccSupportsFlag checks to see if the compiler supports a flag.
3292 return b
3293 }
3298 }
3300 }
3306 }
3307 }
3314 return supported
3315 }
3317 // gccArchArgs returns arguments to pass to gcc based on the architecture.
3332 }
3334 }
3336 // envList returns the value of the given environment variable broken
3337 // into fields, using the default value when the variable is empty.
3341 v = def
3342 }
3344 }
3346 // Return the flags to use when invoking the C, C++ or Fortran compilers, or cgo.
3355 return
3356 }
3360 func (b *builder) cgo(a *action, cgoExe, obj string, pcCFLAGS, pcLDFLAGS, cgofiles, objdirCgofiles, gccfiles, gxxfiles, mfiles, ffiles []string) (outGo, outObj []string, err error) {
3365 // If we are compiling Objective-C code, then we need to link against libobjc
3368 }
3370 // Likewise for Fortran, except there are many Fortran compilers.
3371 // Support gfortran out of the box and let others pass the correct link options
3372 // via CGO_LDFLAGS
3377 }
3380 }
3381 }
3386 }
3388 // Allows including _cgo_export.h from .[ch] files in the package.
3391 // If we have cgo files in the object directory, then copy any
3392 // other cgo files into the object directory, and pass a
3393 // -srcdir option to cgo.
3397 if err := b.copyFile(a, obj+filepath.Base(fn), filepath.Join(p.Dir, fn), 0666, false); err != nil {
3399 }
3400 }
3403 }
3405 // cgo
3406 // TODO: CGO_FLAGS?
3413 }
3415 // TODO: make cgo not depend on $GOARCH?
3420 }
3421 if p.Standard && (p.ImportPath == "runtime/race" || p.ImportPath == "runtime/msan" || p.ImportPath == "runtime/cgo") {
3423 }
3425 // Update $CGO_LDFLAGS with p.CgoLDFLAGS.
3431 }
3433 }
3438 }
3442 }
3443 }
3447 // Tell cgo that if there are any exported functions
3448 // it should generate a header file that C code can
3449 // #include.
3451 }
3453 if err := b.run(p.Dir, p.ImportPath, cgoenv, buildToolExec, cgoExe, srcdirarg, "-objdir", obj, "-importpath", p.ImportPath, cgoflags, "--", cgoCPPFLAGS, cgoCFLAGS, cgofiles); err != nil {
3455 }
3458 // gcc
3464 }
3466 }
3473 }
3475 }
3479 // Append .o to the file, just in case the pkg has file.c and file.cpp
3483 }
3485 }
3488 // Append .o to the file, just in case the pkg has file.c and file.m
3492 }
3494 }
3498 // Append .o to the file, just in case the pkg has file.c and file.f
3502 }
3504 }
3511 }
3517 }
3525 }
3530 }
3533 }
3535 // dynimport creates a Go source file named importGo containing
3536 // //go:cgo_import_dynamic directives for each symbol or library
3537 // dynamically imported by the object files outObj.
3538 func (b *builder) dynimport(p *Package, obj, importGo, cgoExe string, cflags, cgoLDFLAGS, outObj []string) error {
3542 return err
3543 }
3548 // we need to use -pie for Linux/ARM to get accurate imported sym
3549 ldflags := cgoLDFLAGS
3552 }
3554 return err
3555 }
3557 // cgo -dynimport
3561 }
3562 return b.run(p.Dir, p.ImportPath, nil, buildToolExec, cgoExe, "-dynpackage", p.Name, "-dynimport", dynobj, "-dynout", importGo, cgoflags)
3563 }
3565 // collect partially links the object files outObj into a single
3566 // relocatable object file named ofile.
3568 // When linking relocatable objects, various flags need to be
3569 // filtered out as they are inapplicable and can cause some linkers
3570 // to fail.
3575 // skip "-lc" or "-l somelib"
3578 i++
3579 }
3580 // skip "-framework X" on Darwin
3582 i++
3583 // skip "*.{dylib,so,dll,o,a}"
3589 // Remove any -fsanitize=foo flags.
3590 // Otherwise the compiler driver thinks that we are doing final link
3591 // and links sanitizer runtime into the object file. But we are not doing
3592 // the final link, we will link the resulting object file again. And
3593 // so the program ends up with two copies of sanitizer runtime.
3594 // See issue 8788 for details.
3596 continue
3597 // runpath flags not applicable unless building a shared
3598 // object or executable; see issue 12115 for details. This
3599 // is necessary as Go currently does not offer a way to
3600 // specify the set of LDFLAGS that only apply to shared
3601 // objects.
3604 // Skip following argument to -rpath* too.
3605 i++
3606 }
3609 }
3610 }
3616 }
3618 // We are creating an object file, so we don't want a build ID.
3622 }
3624 // Run SWIG on all SWIG input files.
3625 // TODO: Don't build a shared library, once SWIG emits the necessary
3626 // pragmas for external linking.
3627 func (b *builder) swig(p *Package, obj string, pcCFLAGS []string) (outGo, outC, outCXX []string, err error) {
3630 }
3635 }
3641 }
3644 }
3647 }
3648 }
3653 }
3656 }
3659 }
3660 }
3662 }
3664 // Make sure SWIG is new enough.
3666 swigCheckOnce sync.Once
3667 swigCheck error
3668 )
3673 return err
3674 }
3678 // Can't find version number; hope for the best.
3680 }
3684 // Can't find version number; hope for the best.
3686 }
3690 }
3692 // 4.0 or later
3694 }
3696 // We have SWIG version 3.x.
3701 }
3703 // 3.1 or later
3705 }
3706 }
3708 // We have SWIG version 3.0.x.
3713 }
3715 // Before 3.0.6.
3717 }
3718 }
3721 }
3726 })
3727 return swigCheck
3728 }
3730 // Find the value to pass for the -intgosize option to swig.
3732 swigIntSizeOnce sync.Once
3733 swigIntSize string
3734 swigIntSizeError error
3735 )
3737 // This code fails to build if sizeof(int) <= 32
3739 package main
3740 const i int = 1 << 32
3741 `
3743 // Determine the size of int on the target system for the -intgosize option
3744 // of swig >= 2.0.9. Run only once.
3748 }
3751 return
3752 }
3759 }
3761 }
3763 // Determine the size of int on the target system for the -intgosize option
3764 // of swig >= 2.0.9.
3768 })
3770 }
3772 // Run SWIG on one SWIG input file.
3773 func (b *builder) swigOne(p *Package, file, obj string, pcCFLAGS []string, cxx bool, intgosize string) (outGo, outC string, err error) {
3780 }
3785 }
3792 }
3796 // swig
3804 }
3809 }
3810 }
3816 }
3817 }
3820 }
3827 }
3830 }
3832 }
3835 }
3838 }
3840 // disableBuildID adjusts a linker command line to avoid creating a
3841 // build ID when creating an object file rather than an executable or
3842 // shared library. Some systems, such as Ubuntu, always add
3843 // --build-id to every link, but we don't want a build ID when we are
3844 // producing an object file. On some of those system a plain -r (not
3845 // -Wl,-r) will turn off --build-id, but clang 3.0 doesn't support a
3846 // plain -r. I don't know how to turn off --build-id when using clang
3847 // other than passing a trailing --build-id=none. So that is what we
3848 // do, but only on systems likely to support it, which is to say,
3849 // systems that normally use gold or the GNU linker.
3854 }
3855 return ldflags
3856 }
3858 // An actionQueue is a priority queue of actions.
3861 // Implement heap.Interface
3870 return x
3871 }
3875 }
3879 }
3883 return
3884 }
3888 }
3892 }
3893 if goarch != "amd64" || goos != "linux" && goos != "freebsd" && goos != "darwin" && goos != "windows" {
3894 fmt.Fprintf(os.Stderr, "go %s: -race and -msan are only supported on linux/amd64, freebsd/amd64, darwin/amd64 and windows/amd64\n", flag.Args()[0])
3896 }
3898 fmt.Fprintf(os.Stderr, "go %s: -race requires cgo; enable cgo by setting CGO_ENABLED=1\n", flag.Args()[0])
3900 }
3907 }
3910 }
3918 }
3919 }