Class 25 - Internal Memory Deep Dive: Compilation & Execution Phases


✨ Topics Covered

This class focused on the internal workings of a Go program with a spotlight on what happens under the hood during:

  • Compilation Phase
  • Execution Phase
  • How Go builds a binary with go build
  • What gets stored in that binary (functions, constants, globals, etc.)
  • How function expressions (e.g., add := func(...)) are treated in memory

👍 Key Concepts

ConceptExplanation
Compilation PhaseParses and compiles source code into a binary executable. No code runs yet.
Execution PhaseRuns the compiled binary, starting from init() and then main().
Code SegmentWhere compiled functions (like main, call, and anonymous functions) live.
Data SegmentHolds global variables and constants (like p and a).
Function ExpressionsTreated as runtime function objects, stored in code segment.

📋 Code Used in Class 25

package main

import "fmt"

const a = 10 // constant
var p = 100

func call() {
	add := func(x int, y int) {
		z := x + y
		fmt.Println(z)
	}

	add(5, 6)
	add(p, a)
}

func main() {
	call()
	fmt.Println(a)
}

func init() {
	fmt.Println("Hello")
}

🔄 Compilation Phase Visualized

go build main.go

  • Parser/Compiler checks for syntax, scope, and dependencies.
  • Stores:
    • Constants: a = 10
    • Globals: p = 100
    • Functions: init, main, call, and the anonymous add function inside call
  • Generates a binary that includes all necessary machine code + metadata.

Binary includes:

  • Code Segment: main, call, anonymous function
  • Data Segment: const a, var p
  • No execution happens here.

⏱ Execution Phase Visualized

   1. init()            => "Hello"
   2. main()            => calls call()
   3. call()            => declares and invokes add()
       - add(5, 6)      => 11
       - add(100, 10)   => 110
   4. fmt.Println(a)    => 10

🧠 Memory Layout

┌─────────────────────────────┐
│       Code Segment          │
│-----------------------------│
│ main, call, init, add-func  │
└─────────────────────────────┘
          ↓
┌─────────────────────────────┐
│       Data Segment          │
│-----------------------------│
│ const a = 10                │
│ var p = 100                 │
└─────────────────────────────┘
          ↓
┌─────────────────────────────┐
│           Stack             │
│-----------------------------│
│ call() frame → add func     │
│   x=5,y=6,z=11               │
│   x=100,y=10,z=110           │
└─────────────────────────────┘

🔹 Summary

  • Go runs in two phases: Compilation and Execution.
  • During compilation, Go prepares memory layout, compiles functions and expressions.
  • In execution, it runs init() and then main().
  • Function expressions like add := func(...) are first-class values and live in the code segment.
  • The resulting binary from go build holds everything: code, data, metadata.