1
2
3
4
5 package help
6
7 import "cmd/go/internal/base"
8
9 var HelpC = &base.Command{
10 UsageLine: "c",
11 Short: "calling between Go and C",
12 Long: `
13 There are two different ways to call between Go and C/C++ code.
14
15 The first is the cgo tool, which is part of the Go distribution. For
16 information on how to use it see the cgo documentation (go doc cmd/cgo).
17
18 The second is the SWIG program, which is a general tool for
19 interfacing between languages. For information on SWIG see
20 http://swig.org/. When running go build, any file with a .swig
21 extension will be passed to SWIG. Any file with a .swigcxx extension
22 will be passed to SWIG with the -c++ option.
23
24 When either cgo or SWIG is used, go build will pass any .c, .m, .s, .S
25 or .sx files to the C compiler, and any .cc, .cpp, .cxx files to the C++
26 compiler. The CC or CXX environment variables may be set to determine
27 the C or C++ compiler, respectively, to use.
28 `,
29 }
30
31 var HelpPackages = &base.Command{
32 UsageLine: "packages",
33 Short: "package lists and patterns",
34 Long: `
35 Many commands apply to a set of packages:
36
37 go <action> [packages]
38
39 Usually, [packages] is a list of import paths.
40
41 An import path that is a rooted path or that begins with
42 a . or .. element is interpreted as a file system path and
43 denotes the package in that directory.
44
45 Otherwise, the import path P denotes the package found in
46 the directory DIR/src/P for some DIR listed in the GOPATH
47 environment variable (For more details see: 'go help gopath').
48
49 If no import paths are given, the action applies to the
50 package in the current directory.
51
52 There are four reserved names for paths that should not be used
53 for packages to be built with the go tool:
54
55 - "main" denotes the top-level package in a stand-alone executable.
56
57 - "all" expands to all packages found in all the GOPATH
58 trees. For example, 'go list all' lists all the packages on the local
59 system. When using modules, "all" expands to all packages in
60 the main module and their dependencies, including dependencies
61 needed by tests of any of those.
62
63 - "std" is like all but expands to just the packages in the standard
64 Go library.
65
66 - "cmd" expands to the Go repository's commands and their
67 internal libraries.
68
69 Import paths beginning with "cmd/" only match source code in
70 the Go repository.
71
72 An import path is a pattern if it includes one or more "..." wildcards,
73 each of which can match any string, including the empty string and
74 strings containing slashes. Such a pattern expands to all package
75 directories found in the GOPATH trees with names matching the
76 patterns.
77
78 To make common patterns more convenient, there are two special cases.
79 First, /... at the end of the pattern can match an empty string,
80 so that net/... matches both net and packages in its subdirectories, like net/http.
81 Second, any slash-separated pattern element containing a wildcard never
82 participates in a match of the "vendor" element in the path of a vendored
83 package, so that ./... does not match packages in subdirectories of
84 ./vendor or ./mycode/vendor, but ./vendor/... and ./mycode/vendor/... do.
85 Note, however, that a directory named vendor that itself contains code
86 is not a vendored package: cmd/vendor would be a command named vendor,
87 and the pattern cmd/... matches it.
88 See golang.org/s/go15vendor for more about vendoring.
89
90 An import path can also name a package to be downloaded from
91 a remote repository. Run 'go help importpath' for details.
92
93 Every package in a program must have a unique import path.
94 By convention, this is arranged by starting each path with a
95 unique prefix that belongs to you. For example, paths used
96 internally at Google all begin with 'google', and paths
97 denoting remote repositories begin with the path to the code,
98 such as 'github.com/user/repo'.
99
100 Packages in a program need not have unique package names,
101 but there are two reserved package names with special meaning.
102 The name main indicates a command, not a library.
103 Commands are built into binaries and cannot be imported.
104 The name documentation indicates documentation for
105 a non-Go program in the directory. Files in package documentation
106 are ignored by the go command.
107
108 As a special case, if the package list is a list of .go files from a
109 single directory, the command is applied to a single synthesized
110 package made up of exactly those files, ignoring any build constraints
111 in those files and ignoring any other files in the directory.
112
113 Directory and file names that begin with "." or "_" are ignored
114 by the go tool, as are directories named "testdata".
115 `,
116 }
117
118 var HelpImportPath = &base.Command{
119 UsageLine: "importpath",
120 Short: "import path syntax",
121 Long: `
122
123 An import path (see 'go help packages') denotes a package stored in the local
124 file system. In general, an import path denotes either a standard package (such
125 as "unicode/utf8") or a package found in one of the work spaces (For more
126 details see: 'go help gopath').
127
128 Relative import paths
129
130 An import path beginning with ./ or ../ is called a relative path.
131 The toolchain supports relative import paths as a shortcut in two ways.
132
133 First, a relative path can be used as a shorthand on the command line.
134 If you are working in the directory containing the code imported as
135 "unicode" and want to run the tests for "unicode/utf8", you can type
136 "go test ./utf8" instead of needing to specify the full path.
137 Similarly, in the reverse situation, "go test .." will test "unicode" from
138 the "unicode/utf8" directory. Relative patterns are also allowed, like
139 "go test ./..." to test all subdirectories. See 'go help packages' for details
140 on the pattern syntax.
141
142 Second, if you are compiling a Go program not in a work space,
143 you can use a relative path in an import statement in that program
144 to refer to nearby code also not in a work space.
145 This makes it easy to experiment with small multipackage programs
146 outside of the usual work spaces, but such programs cannot be
147 installed with "go install" (there is no work space in which to install them),
148 so they are rebuilt from scratch each time they are built.
149 To avoid ambiguity, Go programs cannot use relative import paths
150 within a work space.
151
152 Remote import paths
153
154 Certain import paths also
155 describe how to obtain the source code for the package using
156 a revision control system.
157
158 A few common code hosting sites have special syntax:
159
160 Bitbucket (Git, Mercurial)
161
162 import "bitbucket.org/user/project"
163 import "bitbucket.org/user/project/sub/directory"
164
165 GitHub (Git)
166
167 import "github.com/user/project"
168 import "github.com/user/project/sub/directory"
169
170 Launchpad (Bazaar)
171
172 import "launchpad.net/project"
173 import "launchpad.net/project/series"
174 import "launchpad.net/project/series/sub/directory"
175
176 import "launchpad.net/~user/project/branch"
177 import "launchpad.net/~user/project/branch/sub/directory"
178
179 IBM DevOps Services (Git)
180
181 import "hub.jazz.net/git/user/project"
182 import "hub.jazz.net/git/user/project/sub/directory"
183
184 For code hosted on other servers, import paths may either be qualified
185 with the version control type, or the go tool can dynamically fetch
186 the import path over https/http and discover where the code resides
187 from a <meta> tag in the HTML.
188
189 To declare the code location, an import path of the form
190
191 repository.vcs/path
192
193 specifies the given repository, with or without the .vcs suffix,
194 using the named version control system, and then the path inside
195 that repository. The supported version control systems are:
196
197 Bazaar .bzr
198 Fossil .fossil
199 Git .git
200 Mercurial .hg
201 Subversion .svn
202
203 For example,
204
205 import "example.org/user/foo.hg"
206
207 denotes the root directory of the Mercurial repository at
208 example.org/user/foo or foo.hg, and
209
210 import "example.org/repo.git/foo/bar"
211
212 denotes the foo/bar directory of the Git repository at
213 example.org/repo or repo.git.
214
215 When a version control system supports multiple protocols,
216 each is tried in turn when downloading. For example, a Git
217 download tries https://, then git+ssh://.
218
219 By default, downloads are restricted to known secure protocols
220 (e.g. https, ssh). To override this setting for Git downloads, the
221 GIT_ALLOW_PROTOCOL environment variable can be set (For more details see:
222 'go help environment').
223
224 If the import path is not a known code hosting site and also lacks a
225 version control qualifier, the go tool attempts to fetch the import
226 over https/http and looks for a <meta> tag in the document's HTML
227 <head>.
228
229 The meta tag has the form:
230
231 <meta name="go-import" content="import-prefix vcs repo-root">
232
233 The import-prefix is the import path corresponding to the repository
234 root. It must be a prefix or an exact match of the package being
235 fetched with "go get". If it's not an exact match, another http
236 request is made at the prefix to verify the <meta> tags match.
237
238 The meta tag should appear as early in the file as possible.
239 In particular, it should appear before any raw JavaScript or CSS,
240 to avoid confusing the go command's restricted parser.
241
242 The vcs is one of "bzr", "fossil", "git", "hg", "svn".
243
244 The repo-root is the root of the version control system
245 containing a scheme and not containing a .vcs qualifier.
246
247 For example,
248
249 import "example.org/pkg/foo"
250
251 will result in the following requests:
252
253 https://example.org/pkg/foo?go-get=1 (preferred)
254 http://example.org/pkg/foo?go-get=1 (fallback, only with use of correctly set GOINSECURE)
255
256 If that page contains the meta tag
257
258 <meta name="go-import" content="example.org git https://code.org/r/p/exproj">
259
260 the go tool will verify that https://example.org/?go-get=1 contains the
261 same meta tag and then git clone https://code.org/r/p/exproj into
262 GOPATH/src/example.org.
263
264 When using GOPATH, downloaded packages are written to the first directory
265 listed in the GOPATH environment variable.
266 (See 'go help gopath-get' and 'go help gopath'.)
267
268 When using modules, downloaded packages are stored in the module cache.
269 See https://golang.org/ref/mod#module-cache.
270
271 When using modules, an additional variant of the go-import meta tag is
272 recognized and is preferred over those listing version control systems.
273 That variant uses "mod" as the vcs in the content value, as in:
274
275 <meta name="go-import" content="example.org mod https://code.org/moduleproxy">
276
277 This tag means to fetch modules with paths beginning with example.org
278 from the module proxy available at the URL https://code.org/moduleproxy.
279 See https://golang.org/ref/mod#goproxy-protocol for details about the
280 proxy protocol.
281
282 Import path checking
283
284 When the custom import path feature described above redirects to a
285 known code hosting site, each of the resulting packages has two possible
286 import paths, using the custom domain or the known hosting site.
287
288 A package statement is said to have an "import comment" if it is immediately
289 followed (before the next newline) by a comment of one of these two forms:
290
291 package math // import "path"
292 package math /* import "path" */
293
294 The go command will refuse to install a package with an import comment
295 unless it is being referred to by that import path. In this way, import comments
296 let package authors make sure the custom import path is used and not a
297 direct path to the underlying code hosting site.
298
299 Import path checking is disabled for code found within vendor trees.
300 This makes it possible to copy code into alternate locations in vendor trees
301 without needing to update import comments.
302
303 Import path checking is also disabled when using modules.
304 Import path comments are obsoleted by the go.mod file's module statement.
305
306 See https://golang.org/s/go14customimport for details.
307 `,
308 }
309
310 var HelpGopath = &base.Command{
311 UsageLine: "gopath",
312 Short: "GOPATH environment variable",
313 Long: `
314 The Go path is used to resolve import statements.
315 It is implemented by and documented in the go/build package.
316
317 The GOPATH environment variable lists places to look for Go code.
318 On Unix, the value is a colon-separated string.
319 On Windows, the value is a semicolon-separated string.
320 On Plan 9, the value is a list.
321
322 If the environment variable is unset, GOPATH defaults
323 to a subdirectory named "go" in the user's home directory
324 ($HOME/go on Unix, %USERPROFILE%\go on Windows),
325 unless that directory holds a Go distribution.
326 Run "go env GOPATH" to see the current GOPATH.
327
328 See https://golang.org/wiki/SettingGOPATH to set a custom GOPATH.
329
330 Each directory listed in GOPATH must have a prescribed structure:
331
332 The src directory holds source code. The path below src
333 determines the import path or executable name.
334
335 The pkg directory holds installed package objects.
336 As in the Go tree, each target operating system and
337 architecture pair has its own subdirectory of pkg
338 (pkg/GOOS_GOARCH).
339
340 If DIR is a directory listed in the GOPATH, a package with
341 source in DIR/src/foo/bar can be imported as "foo/bar" and
342 has its compiled form installed to "DIR/pkg/GOOS_GOARCH/foo/bar.a".
343
344 The bin directory holds compiled commands.
345 Each command is named for its source directory, but only
346 the final element, not the entire path. That is, the
347 command with source in DIR/src/foo/quux is installed into
348 DIR/bin/quux, not DIR/bin/foo/quux. The "foo/" prefix is stripped
349 so that you can add DIR/bin to your PATH to get at the
350 installed commands. If the GOBIN environment variable is
351 set, commands are installed to the directory it names instead
352 of DIR/bin. GOBIN must be an absolute path.
353
354 Here's an example directory layout:
355
356 GOPATH=/home/user/go
357
358 /home/user/go/
359 src/
360 foo/
361 bar/ (go code in package bar)
362 x.go
363 quux/ (go code in package main)
364 y.go
365 bin/
366 quux (installed command)
367 pkg/
368 linux_amd64/
369 foo/
370 bar.a (installed package object)
371
372 Go searches each directory listed in GOPATH to find source code,
373 but new packages are always downloaded into the first directory
374 in the list.
375
376 See https://golang.org/doc/code.html for an example.
377
378 GOPATH and Modules
379
380 When using modules, GOPATH is no longer used for resolving imports.
381 However, it is still used to store downloaded source code (in GOPATH/pkg/mod)
382 and compiled commands (in GOPATH/bin).
383
384 Internal Directories
385
386 Code in or below a directory named "internal" is importable only
387 by code in the directory tree rooted at the parent of "internal".
388 Here's an extended version of the directory layout above:
389
390 /home/user/go/
391 src/
392 crash/
393 bang/ (go code in package bang)
394 b.go
395 foo/ (go code in package foo)
396 f.go
397 bar/ (go code in package bar)
398 x.go
399 internal/
400 baz/ (go code in package baz)
401 z.go
402 quux/ (go code in package main)
403 y.go
404
405
406 The code in z.go is imported as "foo/internal/baz", but that
407 import statement can only appear in source files in the subtree
408 rooted at foo. The source files foo/f.go, foo/bar/x.go, and
409 foo/quux/y.go can all import "foo/internal/baz", but the source file
410 crash/bang/b.go cannot.
411
412 See https://golang.org/s/go14internal for details.
413
414 Vendor Directories
415
416 Go 1.6 includes support for using local copies of external dependencies
417 to satisfy imports of those dependencies, often referred to as vendoring.
418
419 Code below a directory named "vendor" is importable only
420 by code in the directory tree rooted at the parent of "vendor",
421 and only using an import path that omits the prefix up to and
422 including the vendor element.
423
424 Here's the example from the previous section,
425 but with the "internal" directory renamed to "vendor"
426 and a new foo/vendor/crash/bang directory added:
427
428 /home/user/go/
429 src/
430 crash/
431 bang/ (go code in package bang)
432 b.go
433 foo/ (go code in package foo)
434 f.go
435 bar/ (go code in package bar)
436 x.go
437 vendor/
438 crash/
439 bang/ (go code in package bang)
440 b.go
441 baz/ (go code in package baz)
442 z.go
443 quux/ (go code in package main)
444 y.go
445
446 The same visibility rules apply as for internal, but the code
447 in z.go is imported as "baz", not as "foo/vendor/baz".
448
449 Code in vendor directories deeper in the source tree shadows
450 code in higher directories. Within the subtree rooted at foo, an import
451 of "crash/bang" resolves to "foo/vendor/crash/bang", not the
452 top-level "crash/bang".
453
454 Code in vendor directories is not subject to import path
455 checking (see 'go help importpath').
456
457 When 'go get' checks out or updates a git repository, it now also
458 updates submodules.
459
460 Vendor directories do not affect the placement of new repositories
461 being checked out for the first time by 'go get': those are always
462 placed in the main GOPATH, never in a vendor subtree.
463
464 See https://golang.org/s/go15vendor for details.
465 `,
466 }
467
468 var HelpEnvironment = &base.Command{
469 UsageLine: "environment",
470 Short: "environment variables",
471 Long: `
472
473 The go command and the tools it invokes consult environment variables
474 for configuration. If an environment variable is unset or empty, the go
475 command uses a sensible default setting. To see the effective setting of
476 the variable <NAME>, run 'go env <NAME>'. To change the default setting,
477 run 'go env -w <NAME>=<VALUE>'. Defaults changed using 'go env -w'
478 are recorded in a Go environment configuration file stored in the
479 per-user configuration directory, as reported by os.UserConfigDir.
480 The location of the configuration file can be changed by setting
481 the environment variable GOENV, and 'go env GOENV' prints the
482 effective location, but 'go env -w' cannot change the default location.
483 See 'go help env' for details.
484
485 General-purpose environment variables:
486
487 GO111MODULE
488 Controls whether the go command runs in module-aware mode or GOPATH mode.
489 May be "off", "on", or "auto".
490 See https://golang.org/ref/mod#mod-commands.
491 GCCGO
492 The gccgo command to run for 'go build -compiler=gccgo'.
493 GOARCH
494 The architecture, or processor, for which to compile code.
495 Examples are amd64, 386, arm, ppc64.
496 GOBIN
497 The directory where 'go install' will install a command.
498 GOCACHE
499 The directory where the go command will store cached
500 information for reuse in future builds.
501 GOMODCACHE
502 The directory where the go command will store downloaded modules.
503 GODEBUG
504 Enable various debugging facilities. See https://go.dev/doc/godebug
505 for details.
506 GOENV
507 The location of the Go environment configuration file.
508 Cannot be set using 'go env -w'.
509 Setting GOENV=off in the environment disables the use of the
510 default configuration file.
511 GOFLAGS
512 A space-separated list of -flag=value settings to apply
513 to go commands by default, when the given flag is known by
514 the current command. Each entry must be a standalone flag.
515 Because the entries are space-separated, flag values must
516 not contain spaces. Flags listed on the command line
517 are applied after this list and therefore override it.
518 GOINSECURE
519 Comma-separated list of glob patterns (in the syntax of Go's path.Match)
520 of module path prefixes that should always be fetched in an insecure
521 manner. Only applies to dependencies that are being fetched directly.
522 GOINSECURE does not disable checksum database validation. GOPRIVATE or
523 GONOSUMDB may be used to achieve that.
524 GOOS
525 The operating system for which to compile code.
526 Examples are linux, darwin, windows, netbsd.
527 GOPATH
528 Controls where various files are stored. See: 'go help gopath'.
529 GOPROXY
530 URL of Go module proxy. See https://golang.org/ref/mod#environment-variables
531 and https://golang.org/ref/mod#module-proxy for details.
532 GOPRIVATE, GONOPROXY, GONOSUMDB
533 Comma-separated list of glob patterns (in the syntax of Go's path.Match)
534 of module path prefixes that should always be fetched directly
535 or that should not be compared against the checksum database.
536 See https://golang.org/ref/mod#private-modules.
537 GOROOT
538 The root of the go tree.
539 GOSUMDB
540 The name of checksum database to use and optionally its public key and
541 URL. See https://golang.org/ref/mod#authenticating.
542 GOTOOLCHAIN
543 Controls which Go toolchain is used. See https://go.dev/doc/toolchain.
544 GOTMPDIR
545 The directory where the go command will write
546 temporary source files, packages, and binaries.
547 GOVCS
548 Lists version control commands that may be used with matching servers.
549 See 'go help vcs'.
550 GOWORK
551 In module aware mode, use the given go.work file as a workspace file.
552 By default or when GOWORK is "auto", the go command searches for a
553 file named go.work in the current directory and then containing directories
554 until one is found. If a valid go.work file is found, the modules
555 specified will collectively be used as the main modules. If GOWORK
556 is "off", or a go.work file is not found in "auto" mode, workspace
557 mode is disabled.
558
559 Environment variables for use with cgo:
560
561 AR
562 The command to use to manipulate library archives when
563 building with the gccgo compiler.
564 The default is 'ar'.
565 CC
566 The command to use to compile C code.
567 CGO_ENABLED
568 Whether the cgo command is supported. Either 0 or 1.
569 CGO_CFLAGS
570 Flags that cgo will pass to the compiler when compiling
571 C code.
572 CGO_CFLAGS_ALLOW
573 A regular expression specifying additional flags to allow
574 to appear in #cgo CFLAGS source code directives.
575 Does not apply to the CGO_CFLAGS environment variable.
576 CGO_CFLAGS_DISALLOW
577 A regular expression specifying flags that must be disallowed
578 from appearing in #cgo CFLAGS source code directives.
579 Does not apply to the CGO_CFLAGS environment variable.
580 CGO_CPPFLAGS, CGO_CPPFLAGS_ALLOW, CGO_CPPFLAGS_DISALLOW
581 Like CGO_CFLAGS, CGO_CFLAGS_ALLOW, and CGO_CFLAGS_DISALLOW,
582 but for the C preprocessor.
583 CGO_CXXFLAGS, CGO_CXXFLAGS_ALLOW, CGO_CXXFLAGS_DISALLOW
584 Like CGO_CFLAGS, CGO_CFLAGS_ALLOW, and CGO_CFLAGS_DISALLOW,
585 but for the C++ compiler.
586 CGO_FFLAGS, CGO_FFLAGS_ALLOW, CGO_FFLAGS_DISALLOW
587 Like CGO_CFLAGS, CGO_CFLAGS_ALLOW, and CGO_CFLAGS_DISALLOW,
588 but for the Fortran compiler.
589 CGO_LDFLAGS, CGO_LDFLAGS_ALLOW, CGO_LDFLAGS_DISALLOW
590 Like CGO_CFLAGS, CGO_CFLAGS_ALLOW, and CGO_CFLAGS_DISALLOW,
591 but for the linker.
592 CXX
593 The command to use to compile C++ code.
594 FC
595 The command to use to compile Fortran code.
596 PKG_CONFIG
597 Path to pkg-config tool.
598
599 Architecture-specific environment variables:
600
601 GOARM
602 For GOARCH=arm, the ARM architecture for which to compile.
603 Valid values are 5, 6, 7.
604 The value can be followed by an option specifying how to implement floating point instructions.
605 Valid options are ,softfloat (default for 5) and ,hardfloat (default for 6 and 7).
606 GO386
607 For GOARCH=386, how to implement floating point instructions.
608 Valid values are sse2 (default), softfloat.
609 GOAMD64
610 For GOARCH=amd64, the microarchitecture level for which to compile.
611 Valid values are v1 (default), v2, v3, v4.
612 See https://golang.org/wiki/MinimumRequirements#amd64
613 GOMIPS
614 For GOARCH=mips{,le}, whether to use floating point instructions.
615 Valid values are hardfloat (default), softfloat.
616 GOMIPS64
617 For GOARCH=mips64{,le}, whether to use floating point instructions.
618 Valid values are hardfloat (default), softfloat.
619 GOPPC64
620 For GOARCH=ppc64{,le}, the target ISA (Instruction Set Architecture).
621 Valid values are power8 (default), power9, power10.
622 GOWASM
623 For GOARCH=wasm, comma-separated list of experimental WebAssembly features to use.
624 Valid values are satconv, signext.
625
626 Environment variables for use with code coverage:
627
628 GOCOVERDIR
629 Directory into which to write code coverage data files
630 generated by running a "go build -cover" binary.
631 Requires that GOEXPERIMENT=coverageredesign is enabled.
632
633 Special-purpose environment variables:
634
635 GCCGOTOOLDIR
636 If set, where to find gccgo tools, such as cgo.
637 The default is based on how gccgo was configured.
638 GOEXPERIMENT
639 Comma-separated list of toolchain experiments to enable or disable.
640 The list of available experiments may change arbitrarily over time.
641 See src/internal/goexperiment/flags.go for currently valid values.
642 Warning: This variable is provided for the development and testing
643 of the Go toolchain itself. Use beyond that purpose is unsupported.
644 GOROOT_FINAL
645 The root of the installed Go tree, when it is
646 installed in a location other than where it is built.
647 File names in stack traces are rewritten from GOROOT to
648 GOROOT_FINAL.
649 GO_EXTLINK_ENABLED
650 Whether the linker should use external linking mode
651 when using -linkmode=auto with code that uses cgo.
652 Set to 0 to disable external linking mode, 1 to enable it.
653 GIT_ALLOW_PROTOCOL
654 Defined by Git. A colon-separated list of schemes that are allowed
655 to be used with git fetch/clone. If set, any scheme not explicitly
656 mentioned will be considered insecure by 'go get'.
657 Because the variable is defined by Git, the default value cannot
658 be set using 'go env -w'.
659
660 Additional information available from 'go env' but not read from the environment:
661
662 GOEXE
663 The executable file name suffix (".exe" on Windows, "" on other systems).
664 GOGCCFLAGS
665 A space-separated list of arguments supplied to the CC command.
666 GOHOSTARCH
667 The architecture (GOARCH) of the Go toolchain binaries.
668 GOHOSTOS
669 The operating system (GOOS) of the Go toolchain binaries.
670 GOMOD
671 The absolute path to the go.mod of the main module.
672 If module-aware mode is enabled, but there is no go.mod, GOMOD will be
673 os.DevNull ("/dev/null" on Unix-like systems, "NUL" on Windows).
674 If module-aware mode is disabled, GOMOD will be the empty string.
675 GOTOOLDIR
676 The directory where the go tools (compile, cover, doc, etc...) are installed.
677 GOVERSION
678 The version of the installed Go tree, as reported by runtime.Version.
679 `,
680 }
681
682 var HelpFileType = &base.Command{
683 UsageLine: "filetype",
684 Short: "file types",
685 Long: `
686 The go command examines the contents of a restricted set of files
687 in each directory. It identifies which files to examine based on
688 the extension of the file name. These extensions are:
689
690 .go
691 Go source files.
692 .c, .h
693 C source files.
694 If the package uses cgo or SWIG, these will be compiled with the
695 OS-native compiler (typically gcc); otherwise they will
696 trigger an error.
697 .cc, .cpp, .cxx, .hh, .hpp, .hxx
698 C++ source files. Only useful with cgo or SWIG, and always
699 compiled with the OS-native compiler.
700 .m
701 Objective-C source files. Only useful with cgo, and always
702 compiled with the OS-native compiler.
703 .s, .S, .sx
704 Assembler source files.
705 If the package uses cgo or SWIG, these will be assembled with the
706 OS-native assembler (typically gcc (sic)); otherwise they
707 will be assembled with the Go assembler.
708 .swig, .swigcxx
709 SWIG definition files.
710 .syso
711 System object files.
712
713 Files of each of these types except .syso may contain build
714 constraints, but the go command stops scanning for build constraints
715 at the first item in the file that is not a blank line or //-style
716 line comment. See the go/build package documentation for
717 more details.
718 `,
719 }
720
721 var HelpBuildmode = &base.Command{
722 UsageLine: "buildmode",
723 Short: "build modes",
724 Long: `
725 The 'go build' and 'go install' commands take a -buildmode argument which
726 indicates which kind of object file is to be built. Currently supported values
727 are:
728
729 -buildmode=archive
730 Build the listed non-main packages into .a files. Packages named
731 main are ignored.
732
733 -buildmode=c-archive
734 Build the listed main package, plus all packages it imports,
735 into a C archive file. The only callable symbols will be those
736 functions exported using a cgo //export comment. Requires
737 exactly one main package to be listed.
738
739 -buildmode=c-shared
740 Build the listed main package, plus all packages it imports,
741 into a C shared library. The only callable symbols will
742 be those functions exported using a cgo //export comment.
743 Requires exactly one main package to be listed.
744
745 -buildmode=default
746 Listed main packages are built into executables and listed
747 non-main packages are built into .a files (the default
748 behavior).
749
750 -buildmode=shared
751 Combine all the listed non-main packages into a single shared
752 library that will be used when building with the -linkshared
753 option. Packages named main are ignored.
754
755 -buildmode=exe
756 Build the listed main packages and everything they import into
757 executables. Packages not named main are ignored.
758
759 -buildmode=pie
760 Build the listed main packages and everything they import into
761 position independent executables (PIE). Packages not named
762 main are ignored.
763
764 -buildmode=plugin
765 Build the listed main packages, plus all packages that they
766 import, into a Go plugin. Packages not named main are ignored.
767
768 On AIX, when linking a C program that uses a Go archive built with
769 -buildmode=c-archive, you must pass -Wl,-bnoobjreorder to the C compiler.
770 `,
771 }
772
773 var HelpCache = &base.Command{
774 UsageLine: "cache",
775 Short: "build and test caching",
776 Long: `
777 The go command caches build outputs for reuse in future builds.
778 The default location for cache data is a subdirectory named go-build
779 in the standard user cache directory for the current operating system.
780 Setting the GOCACHE environment variable overrides this default,
781 and running 'go env GOCACHE' prints the current cache directory.
782
783 The go command periodically deletes cached data that has not been
784 used recently. Running 'go clean -cache' deletes all cached data.
785
786 The build cache correctly accounts for changes to Go source files,
787 compilers, compiler options, and so on: cleaning the cache explicitly
788 should not be necessary in typical use. However, the build cache
789 does not detect changes to C libraries imported with cgo.
790 If you have made changes to the C libraries on your system, you
791 will need to clean the cache explicitly or else use the -a build flag
792 (see 'go help build') to force rebuilding of packages that
793 depend on the updated C libraries.
794
795 The go command also caches successful package test results.
796 See 'go help test' for details. Running 'go clean -testcache' removes
797 all cached test results (but not cached build results).
798
799 The go command also caches values used in fuzzing with 'go test -fuzz',
800 specifically, values that expanded code coverage when passed to a
801 fuzz function. These values are not used for regular building and
802 testing, but they're stored in a subdirectory of the build cache.
803 Running 'go clean -fuzzcache' removes all cached fuzzing values.
804 This may make fuzzing less effective, temporarily.
805
806 The GODEBUG environment variable can enable printing of debugging
807 information about the state of the cache:
808
809 GODEBUG=gocacheverify=1 causes the go command to bypass the
810 use of any cache entries and instead rebuild everything and check
811 that the results match existing cache entries.
812
813 GODEBUG=gocachehash=1 causes the go command to print the inputs
814 for all of the content hashes it uses to construct cache lookup keys.
815 The output is voluminous but can be useful for debugging the cache.
816
817 GODEBUG=gocachetest=1 causes the go command to print details of its
818 decisions about whether to reuse a cached test result.
819 `,
820 }
821
822 var HelpBuildConstraint = &base.Command{
823 UsageLine: "buildconstraint",
824 Short: "build constraints",
825 Long: `
826 A build constraint, also known as a build tag, is a condition under which a
827 file should be included in the package. Build constraints are given by a
828 line comment that begins
829
830 //go:build
831
832 Constraints may appear in any kind of source file (not just Go), but
833 they must appear near the top of the file, preceded
834 only by blank lines and other comments. These rules mean that in Go
835 files a build constraint must appear before the package clause.
836
837 To distinguish build constraints from package documentation,
838 a build constraint should be followed by a blank line.
839
840 A build constraint comment is evaluated as an expression containing
841 build tags combined by ||, &&, and ! operators and parentheses.
842 Operators have the same meaning as in Go.
843
844 For example, the following build constraint constrains a file to
845 build when the "linux" and "386" constraints are satisfied, or when
846 "darwin" is satisfied and "cgo" is not:
847
848 //go:build (linux && 386) || (darwin && !cgo)
849
850 It is an error for a file to have more than one //go:build line.
851
852 During a particular build, the following build tags are satisfied:
853
854 - the target operating system, as spelled by runtime.GOOS, set with the
855 GOOS environment variable.
856 - the target architecture, as spelled by runtime.GOARCH, set with the
857 GOARCH environment variable.
858 - any architecture features, in the form GOARCH.feature
859 (for example, "amd64.v2"), as detailed below.
860 - "unix", if GOOS is a Unix or Unix-like system.
861 - the compiler being used, either "gc" or "gccgo"
862 - "cgo", if the cgo command is supported (see CGO_ENABLED in
863 'go help environment').
864 - a term for each Go major release, through the current version:
865 "go1.1" from Go version 1.1 onward, "go1.12" from Go 1.12, and so on.
866 - any additional tags given by the -tags flag (see 'go help build').
867
868 There are no separate build tags for beta or minor releases.
869
870 If a file's name, after stripping the extension and a possible _test suffix,
871 matches any of the following patterns:
872 *_GOOS
873 *_GOARCH
874 *_GOOS_GOARCH
875 (example: source_windows_amd64.go) where GOOS and GOARCH represent
876 any known operating system and architecture values respectively, then
877 the file is considered to have an implicit build constraint requiring
878 those terms (in addition to any explicit constraints in the file).
879
880 Using GOOS=android matches build tags and files as for GOOS=linux
881 in addition to android tags and files.
882
883 Using GOOS=illumos matches build tags and files as for GOOS=solaris
884 in addition to illumos tags and files.
885
886 Using GOOS=ios matches build tags and files as for GOOS=darwin
887 in addition to ios tags and files.
888
889 The defined architecture feature build tags are:
890
891 - For GOARCH=386, GO386=387 and GO386=sse2
892 set the 386.387 and 386.sse2 build tags, respectively.
893 - For GOARCH=amd64, GOAMD64=v1, v2, and v3
894 correspond to the amd64.v1, amd64.v2, and amd64.v3 feature build tags.
895 - For GOARCH=arm, GOARM=5, 6, and 7
896 correspond to the arm.5, arm.6, and arm.7 feature build tags.
897 - For GOARCH=mips or mipsle,
898 GOMIPS=hardfloat and softfloat
899 correspond to the mips.hardfloat and mips.softfloat
900 (or mipsle.hardfloat and mipsle.softfloat) feature build tags.
901 - For GOARCH=mips64 or mips64le,
902 GOMIPS64=hardfloat and softfloat
903 correspond to the mips64.hardfloat and mips64.softfloat
904 (or mips64le.hardfloat and mips64le.softfloat) feature build tags.
905 - For GOARCH=ppc64 or ppc64le,
906 GOPPC64=power8, power9, and power10 correspond to the
907 ppc64.power8, ppc64.power9, and ppc64.power10
908 (or ppc64le.power8, ppc64le.power9, and ppc64le.power10)
909 feature build tags.
910 - For GOARCH=wasm, GOWASM=satconv and signext
911 correspond to the wasm.satconv and wasm.signext feature build tags.
912
913 For GOARCH=amd64, arm, ppc64, and ppc64le, a particular feature level
914 sets the feature build tags for all previous levels as well.
915 For example, GOAMD64=v2 sets the amd64.v1 and amd64.v2 feature flags.
916 This ensures that code making use of v2 features continues to compile
917 when, say, GOAMD64=v4 is introduced.
918 Code handling the absence of a particular feature level
919 should use a negation:
920
921 //go:build !amd64.v2
922
923 To keep a file from being considered for any build:
924
925 //go:build ignore
926
927 (Any other unsatisfied word will work as well, but "ignore" is conventional.)
928
929 To build a file only when using cgo, and only on Linux and OS X:
930
931 //go:build cgo && (linux || darwin)
932
933 Such a file is usually paired with another file implementing the
934 default functionality for other systems, which in this case would
935 carry the constraint:
936
937 //go:build !(cgo && (linux || darwin))
938
939 Naming a file dns_windows.go will cause it to be included only when
940 building the package for Windows; similarly, math_386.s will be included
941 only when building the package for 32-bit x86.
942
943 Go versions 1.16 and earlier used a different syntax for build constraints,
944 with a "// +build" prefix. The gofmt command will add an equivalent //go:build
945 constraint when encountering the older syntax.
946 `,
947 }
948
View as plain text