Go Commands - build: Difference between revisions

From NovaOrdis Knowledge Base
Jump to navigation Jump to search
No edit summary
 
(17 intermediate revisions by the same user not shown)
Line 1: Line 1:
=Internal=
* [[Go Commands#Commands|Commands]]
=Overview=
=Overview=


Depending on the arguments, <tt>go build</tt> compiles packages or individual files, treating them as part of a single package.
Depending on the arguments, <tt>go build</tt> compiles packages or individual files, treating them as part of a single package.


=Syntax=
The artifacts are written into the current directory, unless the <tt>[[Go_Commands_-_build#-o|-o]]</tt> option is used.


<pre>
=TODO=
go build [-o output] [-i] [build flags] [packages]
</pre>


Build compiles the packages named by the [[Go_Keyword_import#import_path|import paths]], along with their dependencies, but it does not install the results.
<font color=red>


When compiling multiple packages or a single non-main package, build compiles the packages but discards the resulting object, serving only as a check that the packages can be built.


If the arguments to build are a list of .go files, build treats
'go tool compile'
them as a list of source files specifying a single package.


When compiling a single main package, build writes
'go tool link'  
the resulting executable to an output file named after
the first source file ('go build ed.go rx.go' writes 'ed' or 'ed.exe')
or the source code directory ('go build unix/sam' writes 'sam' or 'sam.exe').
The '.exe' suffix is added when writing a Windows executable.


When compiling multiple packages or a single non-main package,
<tt>go build</tt> builds the ''current package''.
build compiles the packages but discards the resulting object,
serving only as a check that the packages can be built.


The -o flag, only allowed when compiling a single package,
A specific package can be also built: <tt>go build <package-path-string-literal></tt> where the <tt><package-path-string-literal></tt> is the same literal used by the <tt>[[Go Keyword import|import]]</tt> statement.
forces build to write the resulting executable or object
to the named output file, instead of the default behavior described
in the last two paragraphs.


The -i flag installs the packages that are dependencies of the target.
Wildcards can be specified in the package specifiers. A three period indicates a pattern matching any string: <tt>go build something/...</tt>


The build flags are shared by the build, clean, get, install, list, run,
</font>
and test commands:


-a
=Syntax=
force rebuilding of packages that are already up-to-date.
-n
print the commands but do not run them.
-p n
the number of programs, such as build commands or
test binaries, that can be run in parallel.
The default is the number of CPUs available, except
on darwin/arm which defaults to 1.
-race
enable data race detection.
Supported only on linux/amd64, freebsd/amd64, darwin/amd64 and windows/amd64.
-msan
enable interoperation with memory sanitizer.
Supported only on linux/amd64,
and only with Clang/LLVM as the host C compiler.
-v
print the names of packages as they are compiled.
-work
print the name of the temporary work directory and
do not delete it when exiting.
-x
print the commands.


-asmflags 'flag list'
<pre>
arguments to pass on each go tool asm invocation.
go build [-o output] [-i] [build flags] [packages]
-buildmode mode
</pre>
build mode to use. See 'go help buildmode' for more.
-compiler name
name of compiler to use, as in runtime.Compiler (gccgo or gc).
-gccgoflags 'arg list'
arguments to pass on each gccgo compiler/linker invocation.
-gcflags 'arg list'
arguments to pass on each go tool compile invocation.
-installsuffix suffix
a suffix to use in the name of the package installation directory,
in order to keep output separate from default builds.
If using the -race flag, the install suffix is automatically set to race
or, if set explicitly, has _race appended to it.  Likewise for the -msan
flag.  Using a -buildmode option that requires non-default compile flags
has a similar effect.
-ldflags 'flag list'
arguments to pass on each go tool link invocation.
-linkshared
link against shared libraries previously created with
-buildmode=shared.
-pkgdir dir
install and load all packages from dir instead of the usual locations.
For example, when building with a non-standard configuration,
use -pkgdir to keep generated packages in a separate location.
-tags 'tag list'
a list of build tags to consider satisfied during the build.
For more information about build tags, see the description of
build constraints in the documentation for the go/build package.
-toolexec 'cmd args'
a program to use to invoke toolchain programs like vet and asm.
For example, instead of running asm, the go command will run
'cmd args /path/to/asm <arguments for asm>'.


The list flags accept a space-separated list of strings. To embed spaces
=Building an Executable=
in an element in the list, surround it with either single or double quotes.


For more about specifying packages, see 'go help packages'.
If the arguments are a list of .go files, <tt>build</tt> treats them as a list of source files specifying a single package.
For more about where packages and binaries are installed,
run 'go help gopath'.
For more about calling between Go and C/C++, run 'go help c'.


Note: Build adheres to certain conventions such as those described
If that package is "main", build writes the resulting executable to an output file named after the first source file ('go build a.go b.go' writes an "a" executable) or the source code directory ('go build a/b' writes 'b'). The output is overridden by <tt>[[Go_Commands_-_build#-o|-o]]</tt> flag.
by 'go help gopath'. Not all projects can follow these conventions,
however. Installations that have their own conventions or that use
a separate software build system may choose to use lower-level
invocations such as 'go tool compile' and 'go tool link' to avoid
some of the overheads and design decisions of the build tool.


See also: go install, go get, go clean.
Also see:  


</font>
<blockquote style="background-color: #f9f9f9; border: solid thin lightgrey;">
:[[Go Concepts - Runtime#Compiling_an_Executable|Building an Executable]]
</blockquote>
 
=Building a Library=


<pre>
If the arguments are a list of [[Go_Keyword_import#import_path|import paths]], <tt>build</tt> compiles the packages named by the import paths, along with their dependencies, but it does not install the results.
go build
</pre>


builds the ''current package''.
=<tt>-o</tt>=


A specific package can be also built:
<tt>-o</tt> flag can only be used when compiling a single package or building an executable. It forces <tt>build</tt> to write the executable or object file to the given file name, instead of the default behavior.


<pre>
=<tt>-i</tt>=
go build <package-path-string-literal>
</pre>


where the <tt><package-path-string-literal></tt> is the same literal used by the <tt>[[Go Keyword import|import]]</tt> statement.
The <tt>-i</tt> flag installs the packages that are dependencies of the target.


Wildcards can be specified in the package specifiers. A three period indicates a pattern matching any string:
=Finding a Race Condition=


<pre>
<pre>
go build something/...
go build -race ...
</pre>
</pre>
=Building an Executable=
<blockquote style="background-color: #f9f9f9; border: solid thin lightgrey;">
:[[Go Concepts - Runtime#Compiling_an_Executable|Building an Executable]]
</blockquote>

Latest revision as of 22:49, 26 September 2023

Overview

Depending on the arguments, go build compiles packages or individual files, treating them as part of a single package.

The artifacts are written into the current directory, unless the -o option is used.

TODO

When compiling multiple packages or a single non-main package, build compiles the packages but discards the resulting object, serving only as a check that the packages can be built.

'go tool compile'

'go tool link'

go build builds the current package.

A specific package can be also built: go build <package-path-string-literal> where the <package-path-string-literal> is the same literal used by the import statement.

Wildcards can be specified in the package specifiers. A three period indicates a pattern matching any string: go build something/...

Syntax

go build [-o output] [-i] [build flags] [packages]

Building an Executable

If the arguments are a list of .go files, build treats them as a list of source files specifying a single package.

If that package is "main", build writes the resulting executable to an output file named after the first source file ('go build a.go b.go' writes an "a" executable) or the source code directory ('go build a/b' writes 'b'). The output is overridden by -o flag.

Also see:

Building an Executable

Building a Library

If the arguments are a list of import paths, build compiles the packages named by the import paths, along with their dependencies, but it does not install the results.

-o

-o flag can only be used when compiling a single package or building an executable. It forces build to write the executable or object file to the given file name, instead of the default behavior.

-i

The -i flag installs the packages that are dependencies of the target.

Finding a Race Condition

go build -race ...
Retrieved from "https://kb.novaordis.com/index.php?title=Go_Commands_-_build&oldid=101515"