break Statement — Professional Level (Internals, Compiler, Assembly)¶

// go/ast package
type BranchStmt struct {
    TokPos token.Pos   // position of Tok
    Tok    token.Token // keyword token (BREAK, CONTINUE, GOTO, FALLTHROUGH)
    Label  *Ident      // label name; or nil
}

// For: break
// Tok = token.BREAK, Label = nil

// For: break OuterLoop
// Tok = token.BREAK, Label = &ast.Ident{Name: "OuterLoop"}

// Source:
for i := 0; i < 10; i++ {
    if i == 5 { break }
    use(i)
}
after()

// SSA (simplified):
b0: (entry)
    v1 = 0              ; i = 0
    Jump b1

b1: (loop header)
    v2 = phi v1 v5      ; i at start of each iteration
    v3 = Less v2 10     ; i < 10
    If v3 → b2 else b4  ; if false: exit

b2: (body)
    v4 = Eq v2 5        ; i == 5
    If v4 → b4 else b3  ; if true: break (jump to b4)

b3: (continue body)
    call use(v2)
    v5 = Add v2 1       ; i++
    Jump b1

b4: (after loop) ← both break and loop exhaustion jump here
    call after()

package main

func findFive(s []int) int {
    for i, v := range s {
        if v == 5 { return i }
    }
    return -1
}

func findIn2D(m [][]int, target int) (int, int, bool) {
Outer:
    for i, row := range m {
        for j, v := range row {
            if v == target {
                return i, j, true // labeled break equivalent
            }
        }
    }
    return -1, -1, false
}

for _, v := range s {
    break
    use(v) // dead code — never emitted in output
}

func classify(n int) string {
    switch n {
    case 1: return "one"
    case 2: return "two"
    case 3: return "three"
    default: return "other"
    }
}

func process() *int {
    var result *int
    for _, v := range items {
        if predicate(v) {
            x := v
            result = &x // x escapes to heap here
            break
        }
    }
    return result // result refers to heap-allocated x
}

func example() {
    defer fmt.Println("function exiting") // runs only when function returns

    for i := 0; i < 10; i++ {
        defer fmt.Println("deferred:", i) // all deferred at function exit
        if i == 3 {
            break // does NOT trigger any defers
        }
    }
    fmt.Println("after loop") // runs after break
}
// Output order:
// after loop
// deferred: 3
// deferred: 2
// deferred: 1
// deferred: 0
// function exiting

// Original:
for _, v := range s {
    if debugMode {  // constant at compile time
        break
    }
    process(v)
}

// Compiler may generate:
if !debugMode {
    for _, v := range s {
        process(v)
    }
}
// The break condition is hoisted, avoiding per-iteration check

// A goroutine stuck in a loop without break:
go func() {
    for {
        doWork() // never breaks
    }
}()

// Stack trace (from SIGQUIT or runtime.Stack):
// goroutine 18 [running]:
// main.main.func1()
//     /path/to/main.go:5 +0x20  <- in the loop body

//go:build gofuzz
package mypackage

import "testing"

func FuzzFindFirst(f *testing.F) {
    f.Add([]byte{1, 2, 3, 4, 5}, byte(3))
    f.Fuzz(func(t *testing.T, data []byte, target byte) {
        found := false
        for _, b := range data {
            if b == target {
                found = true
                break // early break must not cause panic
            }
        }
        // Verify: if target in data, found must be true
        for _, b := range data {
            if b == target && !found {
                t.Errorf("break caused false negative: target=%d data=%v", target, data)
            }
        }
    })
}

package main

import "testing"

// Measure cost of early break at position 0, n/2, and n-1
func benchmarkBreakAt(b *testing.B, n, breakAt int) {
    data := make([]int, n)
    data[breakAt] = -1 // sentinel for break

    b.ResetTimer()
    for iter := 0; iter < b.N; iter++ {
        for i, v := range data {
            if v == -1 {
                _ = i
                break
            }
        }
    }
}

func BenchmarkBreakFirst(b *testing.B) { benchmarkBreakAt(b, 10000, 0) }
func BenchmarkBreakMid(b *testing.B)   { benchmarkBreakAt(b, 10000, 5000) }
func BenchmarkBreakLast(b *testing.B)  { benchmarkBreakAt(b, 10000, 9999) }
func BenchmarkNoBreak(b *testing.B)    { benchmarkBreakAt(b, 10000, -1) } // never breaks

// Typical results:
// BenchmarkBreakFirst: ~2 ns/op (1 iteration)
// BenchmarkBreakMid:   ~5 μs/op (5000 iterations)
// BenchmarkBreakLast:  ~10 μs/op (10000 iterations)
// BenchmarkNoBreak:    ~10 μs/op (same as BenchmarkBreakLast — no element found)