Go Nil Pointer Dereference — Optimize¶

Instructions¶

Each exercise focuses on the cost of nil checks, opportunities the compiler takes to eliminate them, and patterns that minimize both panic risk and runtime cost. Difficulty: Easy, Medium, Hard.

Exercise 1 (Easy) — Cost of an Explicit Nil Check¶

Problem:

func get(p *int) int {
    if p == nil {
        return 0
    }
    return *p
}

Question: How does the compiler implement the nil check? What is the cost?

TESTQ AX, AX        ; sets ZF if AX (the pointer) is zero
JE    nil_branch
MOVQ  (AX), AX
RET
nil_branch:
XOR   AX, AX
RET

go build -gcflags="-S" main.go 2>&1 | grep -A 10 "main.get"

Exercise 2 (Easy) — Implicit Nil Check on Field Access¶

Problem:

type T struct {
    field int
}

func read(t *T) int {
    return t.field
}

Question: Does the compiler insert an explicit nil check?

MOVQ (AX), AX     ; loads t.field; if t is nil, this faults
RET

go build -gcflags="-d=nil -S" main.go 2>&1 | head -50

Exercise 3 (Easy) — Redundant Check Elimination¶

Problem:

func work(p *T) int {
    if p == nil {
        return 0
    }
    return p.a + p.b + p.c // three field accesses
}

Question: How many nil checks does the compiler emit?

TESTQ AX, AX
JE    return_zero
MOVQ  (AX), CX     ; p.a — no implicit check needed (proven non-nil)
ADDQ  8(AX), CX    ; p.b
ADDQ  16(AX), CX   ; p.c
MOVQ  CX, AX
RET
return_zero:
XOR   AX, AX
RET

go build -gcflags="-d=nil" main.go 2>&1 | grep "nil check"

Exercise 4 (Medium) — When Manual Check Beats Compiler¶

Problem:

func process(items []*Item) {
    for _, it := range items {
        // do work using it
        sum += it.Value
        sum += it.Count
        sum += it.Total
    }
}

Question: Could the slice contain nil entries? Should you check?

for _, it := range items {
    if it == nil {
        continue
    }
    sum += it.Value
    sum += it.Count
    sum += it.Total
}

items = filterNils(items) // once
// then loop without checking

Exercise 5 (Medium) — Nil-Safe Method vs Caller Check¶

Problem:

type Logger struct{ w io.Writer }
func (l *Logger) Log(s string) {
    if l == nil { return }
    fmt.Fprintln(l.w, s)
}

vs

func (l *Logger) Log(s string) {
    fmt.Fprintln(l.w, s) // requires non-nil
}
// Caller does the check.

Question: Which is faster? Which is better?

Exercise 6 (Medium) — Inline Allocation vs Pointer¶

Problem:

type Container struct {
    item *Item
}

func process(c *Container) int {
    if c.item == nil {
        return 0
    }
    return c.item.value
}

vs

type Container struct {
    item    Item
    hasItem bool
}

func process(c *Container) int {
    if !c.hasItem {
        return 0
    }
    return c.item.value
}

Question: Which is more efficient? Memory layout?

Exercise 7 (Medium) — Avoiding Nil Slices in Hot Paths¶

Problem:

func sum(xs []int) int {
    if xs == nil {
        return 0
    }
    total := 0
    for _, x := range xs {
        total += x
    }
    return total
}

Question: Is the nil check needed?

func sum(xs []int) int {
    total := 0
    for _, x := range xs {
        total += x
    }
    return total
}

Exercise 8 (Hard) — Recover Cost in Hot Path¶

Problem:

func safeProcess(p *T) (result int, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("panic: %v", r)
        }
    }()
    return p.Compute(), nil
}

Question: What is the cost of the deferred recover? When does it dominate?

func process(p *T) (int, error) {
    if p == nil {
        return 0, errors.New("nil")
    }
    return p.Compute(), nil
}

func batch(ps []*T) (results []int, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("batch: %v", r)
        }
    }()
    for _, p := range ps {
        results = append(results, p.Compute())
    }
    return
}

Exercise 9 (Hard) — Compiler-Inserted Check at Large Offset¶

Problem:

type Big struct {
    pad  [70 * 1024]byte // 70 KB
    last int
}

func read(b *Big) int {
    return b.last // offset > 64 KB
}

Question: Why does this case need an explicit nil check?

TESTQ AX, AX
JE    panic_branch
MOVQ  (offset)(AX), AX
RET
panic_branch:
CALL runtime.panicmem(SB)

go build -gcflags="-d=nil -S" main.go 2>&1 | grep -A 10 "main.read"

Exercise 10 (Hard) — Cache-Friendly Nil Filtering¶

Problem:

func sumValues(items []*Item) int {
    sum := 0
    for _, it := range items {
        if it != nil {
            sum += it.Value
        }
    }
    return sum
}

Question: How can you optimize for branch-prediction with mostly-non-nil data?

items = items[:0:cap(items)]
for _, it := range source {
    if it != nil {
        items = append(items, it)
    }
}
// Now sum without checks
sum := 0
for _, it := range items {
    sum += it.Value
}

type Item struct {
    Value int
}
var zero Item

// In source, replace nils with &zero before storing:
if item == nil {
    item = &zero
}
// Sum: no nil check needed; zero contributes 0.

type Item struct {
    Value int
    Valid bool
}
items := []Item{...} // no pointers; nil unrepresentable

Bonus Exercise (Hard) — Profile and Tune Nil-Heavy Code¶

Problem: A service shows high CPU in functions doing chained pointer access. How do you investigate and improve?

go test -cpuprofile=cpu.prof -bench=BenchmarkChain
go tool pprof cpu.prof

go build -gcflags="-d=nil" main.go 2>&1 | grep "generated nil check"

go test -bench=BenchmarkChain -benchmem

go build -gcflags="-S" 2>asm.txt
grep -A 50 "main.hot" asm.txt

Bonus Exercise 2 (Hard) — nilcheck.go Deep Dive¶

Problem: Read cmd/compile/internal/ssa/nilcheck.go in the Go source. What invariants does it preserve?

GOSSAFUNC=read go build .
# opens ssa.html in browser; navigate to "nilcheckelim" pass