how to check whether golang binary is compiled with --ldflags="-s -w"

Question

i know --ldflags="-s -w" will make Go binary size smaller, but without comparing to the one without ldflags, how do we know whether Go binary compiled with or without ldflags="-s -w" ?

Answer 1

Disclaimer first: I'm no expert of compilation toolchains and executable file formats. I'll try not to say stupid things, but correct me if you see any mistake !

I ran those tests on an ArchLinux laptop, with x86_64 architecture. Go version is 1.8.1.

First, we need to know where those flags are actually used:

$ go help build
...
-ldflags 'flag list'
    arguments to pass on each go tool link invocation
...

Apparently, flags are merely passed to the go tool link invocation. Looking at the help, we have a bit more information:

$ go tool link
...
-s  disable symbol table
...
-w  disable DWARF generation
...

Taken from the short introduction to ELF that I found here, here is the header text concerning the Symbol Table:

An object file’s symbol table holds information needed to locate and relocate a program’s symbolic definitions and references.

As for DWARF, this is a format for debugging data.

From there, how do we know if a binary has a symbol table, or DWARF enabled ? The answer lies in ELF sections. There are probably other ways, but it is the one I found and is easy to check for. Here are the rules that I've used to determine if a Golang binary has been compiled with -ldflags='-s' or -ldflags='-w':

• If a Go binary has a symbol table, the section .symtab is present
• If a Go binary has DWARF debug, the section .debug_info is present. This section is not the only one to be present, but serves as an indicator.

On Linux, there are some tools which can read section names to extract those informations. readelf and nm are examples, yet probably more exist.

It also turns out that Go provide a debug/elf package which can be used to get those informations. Here is a sample program that does this job:

package main

import "fmt"
import "os"
import "debug/elf"

func main() {
    fileName := "path/to/main"
    fp, err := elf.Open(fileName)
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }

    symtab := fp.Section(".symtab")
    if symtab == nil {
        fmt.Println("No Symbol Table : compiled with -ldflags='-s'")
    }

    debugInfo := fp.Section(".debug_info")
    if debugInfo == nil {
        fmt.Println("No DWARF data : compiled with -ldflags='-w'")
    }
}

I tested this program against the basic Golang Hello World, using no flags, only the -s flag, only the -w flag and both -s -w flags. I noted that while compiling with -s only, it also removed DWARF data, but I did not search why. Aside from that, the results were as expected.

Though ELF was the focus format, the same method can be applied for Windows executables (there is a debug/pe package in Golang).