How to Eliminate Unused Code from Go Binaries at Compile Time?

How to Remove Unused Code at Compile Time in Go?

When creating a Go package used by multiple entities and imported using the standard method, it's observed that all utilities, including the small ones, result in large binaries at compile time. Investigating the issue reveals that the entire package is compiled into each utility, even functions that are not utilized.

To delver into the issue further, consider the following code:

main.go:

package main

import "play/subplay"

func main() {
    subplay.A()
}

play/subplay.go:

package subplay

func A() {
    fmt.Printf("this is function A()")
}

func B() {
    fmt.Printf("secret string")
}

Despite Function B() not being called, its string value, "secret string," appears in the compiled binary main.exe. This behavior raises the question of how to eliminate unused code from Go programs at compile time.

The answer lies in the fact that the Go compiler already handles this task. In the compilation process, the compiler packages code into archive files (.a) and only includes essential components in the executable binary. It excludes items that are identifiable as unreachable.

It's crucial to note that if an imported package imports other packages, this filtering process must be applied recursively. For instance, importing a package that imports additional packages will cause those dependent packages to be included as well.

Here are a few illustrative examples:

Importing a package without using any functionality:

package main

import _ "play/subplay"

func main() {
}

In this case, the resulting binary will be approximately 1 MB. However, if the imported package imports net/http:

package subplay

import _ "net/http"

func A() {}

And you still don't use net/http within your code, the binary size will increase significantly to approximately 5 MB due to net/http importing 39 other packages.

And when you start using net/http but don't call subplay.A() in the main package, the executable size remains the same.

package subplay

import "net/http"

func A() {
    http.ListenAndServe("", nil)
}

It's only when you make a call to subplay.A() from the main package that the binary size increases further:

package main

import "play/subplay"

func main() {
    subplay.A()
}

The takeaway is that the code included in the executable binary is directly influenced by the functions and modules you call from imported packages.

Moreover, it's essential to remember that Go is a statically linked language, meaning the executable binary must contain everything it requires to run.

The above is the detailed content of How to Eliminate Unused Code from Go Binaries at Compile Time?. For more information, please follow other related articles on the PHP Chinese website!