How Go’s Compiler Shrinks Binaries with Dead Code Elimination

In software development, reducing executable size is an eternal topic. For Go, its compiler excels at generating compact binaries. This article delves into how the Go compiler achieves this through optimizations such as dead code elimination.

Understanding Dead Code Elimination

Dead Code Elimination (DCE) is a compiler optimization technique that removes code which does not affect the program’s runtime result. Such code is typically unreachable or has no observable effect.

The Go compiler performs DCE during compilation, identifying and discarding this useless code, thereby effectively reducing the final executable size.

Dead Code Elimination in Go: Practice and Analysis

To illustrate how the Go compiler carries out DCE, consider the following simple example.

Example code:

<code>// main.go
package main

import (
    "fmt"
    "demo/pkga"
)

func main() {
    result := pkga.Foo()
    fmt.Println(result)
}
</code>

<code>// pkga/pkga.go
package pkga

import (
    "fmt"
)

func Foo() string {
    return "Hello from Foo!"
}

func Bar() {
    fmt.Println("This is Bar.")
}
</code>

In this example, the main function calls the Foo function from the pkga package, while the Bar function is never invoked.

Compilation and analysis:

After building the program with the Go compiler, we can use go tool nm to inspect the symbol table of the resulting binary.

<code>$ go build
$ go tool nm demo | grep demo
</code>

Analyzing the output shows that pkga.Foo is present in the binary, whereas pkga.Bar is absent. This is because the compiler recognized that Bar is never called, treated it as dead code, and eliminated it.

How Go Compiler Implements Dead Code Elimination

The Go compiler uses static code analysis to perform DCE, following these main steps:

Build call graph: The compiler analyzes the source to construct a call graph that describes which functions invoke which others.

Mark reachable code: Starting from entry points such as main , the compiler traverses the call graph and marks all reachable functions as “live”.

Identify and eliminate dead code: Functions and code blocks not marked as live are considered dead and are removed from the final binary.

Factors Influencing Dead Code Elimination

Several factors can affect how effectively Go’s DCE works:

Code complexity: More complex code makes static analysis harder, potentially leaving some dead code undiscovered.

Compiler options: Flags such as -ldflags="-s -w" can further shrink binaries but may impact debugging information.

Reflection: Go’s reflection allows runtime discovery of functions, which the compiler cannot fully resolve at compile time, possibly limiting DCE.

Summary

The Go compiler reduces executable size by applying dead code elimination and other optimizations, making Go well‑suited for building lightweight, low‑resource applications.

However, DCE alone does not solve all size‑related issues; developers must still write clean, non‑redundant code to achieve the smallest possible binaries.