Strings in Go — Professional Level (Internals)¶

// src/internal/abi/type.go
// A string at runtime is a StringHeader:
type StringHeader struct {
    Data uintptr
    Len  int
}

// In the compiler's IR (Intermediate Representation):
// a string value is a two-element structure: (ptr, len)
// Both fields are pointer-sized (8 bytes on amd64)

// String literal: stored in read-only data section
s := "hello"
// Compiler emits:
// .rodata section: 68 65 6c 6c 6f  (h e l l o)
// Stack variable s: [ptr to .rodata, len=5]

// Runtime string: heap-allocated
s := strings.Repeat("a", 1000)
// Runtime allocates 1000 bytes on heap
// Stack variable s: [ptr to heap, len=1000]

// Source:
s := "hello"
fmt.Println(len(s))

// Source:
s := a + b

// The GC mask for a string type encodes:
// byte 0: bit 0 = 1 (Data is a pointer), bit 1 = 0 (Len is not a pointer)
// This tells the GC scanner which fields to follow

// Source: src/strings/builder.go
type Builder struct {
    addr *Builder // of receiver, to detect copies by value
    buf  []byte
}

func (b *Builder) WriteString(s string) (int, error) {
    b.copyCheck()
    b.buf = append(b.buf, s...)
    return len(s), nil
}

func (b *Builder) String() string {
    // unsafe conversion: no copy!
    // This is safe because Builder.buf won't be modified in a way
    // that would affect the returned string's safety — the Builder
    // only appends, never modifies existing bytes
    return unsafe.String(unsafe.SliceData(b.buf), len(b.buf))
}

func (b *Builder) Grow(n int) {
    if n < 0 {
        panic("strings.Builder.Grow: negative count")
    }
    if cap(b.buf)-len(b.buf) < n {
        b.grow(n)
    }
}

func (b *Builder) grow(n int) {
    buf := make([]byte, len(b.buf), 2*cap(b.buf)+n)
    copy(buf, b.buf)
    b.buf = buf
}

// concatstrings creates a new string from multiple strings
func concatstrings(buf *tmpBuf, a []string) string {
    idx := 0
    l := 0
    count := 0
    for i, x := range a {
        n := len(x)
        if n == 0 {
            continue
        }
        if l+n < l { // overflow
            throw("string concatenation too long")
        }
        l += n
        count++
        idx = i
    }
    if count == 0 {
        return ""
    }
    // Single non-empty string: return it directly (no copy)
    if count == 1 && (buf != nil || !stringDataOnStack(a[idx])) {
        return a[idx]
    }
    s, b := rawstringtmp(buf, l)
    for _, x := range a {
        n := copy(b, x)
        b = b[n:]
    }
    return s
}

// rawstringtmp allocates a new string using the temporary buffer
// if the string fits, otherwise heap-allocates
func rawstringtmp(buf *tmpBuf, l int) (s string, b []byte) {
    if buf != nil && l <= len(buf) {
        b = buf[:l]
        s = slicebytetostringtmp(&b[0], l)
    } else {
        s, b = rawstring(l)
    }
    return
}

// Stack buffer passed to concatstrings:
type tmpBuf [tmpStringBufSize]byte
const tmpStringBufSize = 32

// runtime/string.go: stringtoslicebyte
func stringtoslicebyte(buf *tmpBuf, s string) []byte {
    var b []byte
    if buf != nil && len(s) <= len(buf) {
        *buf = tmpBuf{}
        b = buf[:len(s)]
    } else {
        b = rawbyteslice(len(s))
    }
    copy(b, s)
    return b
}

// runtime/string.go: slicebytetostring
func slicebytetostring(buf *tmpBuf, ptr *byte, n int) string {
    if n == 0 {
        return ""
    }
    if raceenabled {
        racereadrangepc(...)
    }
    if msanenabled {
        msanread(...)
    }
    if asanenabled {
        asanread(...)
    }
    if n == 1 {
        p := unsafe.Pointer(&staticuint64s[*ptr]) // singleton bytes!
        // ...
    }
    var p unsafe.Pointer
    if buf != nil && n <= len(buf) {
        p = unsafe.Pointer(buf)
    } else {
        p = mallocgc(uintptr(n), nil, false)
    }
    memmove(p, unsafe.Pointer(ptr), uintptr(n))
    return unsafe.String((*byte)(p), n)
}

// The range loop decodes UTF-8 using:
func DecodeRuneInString(s string) (r rune, size int) {
    n := len(s)
    if n < 1 {
        return RuneError, 0
    }
    s0 := s[0]
    x := first[s0]
    if x >= as {
        // single-byte rune: x == xx
        mask := rune(x) << 31 >> 31 // Create 0x0000 or 0xFFFF
        return rune(s0)&^mask | RuneError&mask, 1
    }
    sz := int(x & 7)
    accept := acceptRanges[x>>4]
    if n < sz {
        return RuneError, 1
    }
    s1 := s[1]
    if s1 < accept.lo || accept.hi < s1 {
        return RuneError, 1
    }
    // ... continues for 3 and 4 byte cases
}

// When using a string as a map key, the compiler generates
// inline hash computation using FNV-like algorithm (aeshash on modern CPUs)

// On CPUs with AES support:
// AESENC and AESENCLAST instructions provide very fast hashing
// This is why string map lookups are fast in Go

// Pattern 1: []byte conversion used only for read (no modification)
m := make(map[string]int)
b := []byte("key")
_ = m[string(b)] // compiler may avoid allocating string(b)

// Pattern 2: string comparison using []byte
b := []byte("hello")
if string(b) == "hello" { // compiler may avoid allocation
}

// Pattern 3: switch on string([]byte)
switch string(b) {
case "GET", "POST": // compiler may avoid allocation
}

import "reflect"

// reflect.StringHeader is the Go-accessible version of the internal string struct
// (deprecated in Go 1.20 in favor of unsafe.String/unsafe.StringData)
type StringHeader struct {
    Data uintptr
    Len  int
}

// Modern approach (Go 1.20+):
s := "hello"
ptr := unsafe.StringData(s)  // *byte pointing to first byte
// OR
sh := (*[2]uintptr)(unsafe.Pointer(&s))
// sh[0] = data pointer, sh[1] = length

// 1. String literals: identical literals share the same .rodata location
//    (though the compiler doesn't guarantee this)

// 2. Small integer conversions: string(rune(r)) for common runes
//    uses a table of pre-computed strings

// 3. HTTP/2: header names are interned by the http2 package
//    (using the hpack package)

// 4. JSON: the encoding/json package interns struct field names
//    to avoid per-request allocation