Program Counter

The program counter (PC), also called the instruction pointer, is a pointer that tracks the current instruction being executed in a virtual machine. It’s one of the core components of a VM execution frame.

What is the Program Counter?

The PC points to the next instruction to execute in an instruction sequence:

Instruction Sequence:
┌────────┬─────────────────┐
│ Index  │  Instruction    │
├────────┼─────────────────┤
│   0    │  putnil         │
│   1    │  putobject 42   │
│   2    │  putstring "hi" │ ← PC points here
│   3    │  add            │
│   4    │  return         │
└────────┴─────────────────┘

After each instruction executes, the PC advances to the next position. It’s the VM’s way of knowing “what to do next.”

How It Works

Sequential Execution:

# Ruby code:
a = 1
b = 2
c = a + b
 
# YARV execution:
PC = 0: putobject 1    # PC → 1
PC = 1: setlocal a     # PC → 2
PC = 2: putobject 2    # PC → 3
PC = 3: setlocal b     # PC → 4
PC = 4: getlocal a     # PC → 5
PC = 5: getlocal b     # PC → 6
PC = 6: add            # PC → 7
PC = 7: setlocal c     # PC → 8

The PC increments automatically after most instructions.

Non-Sequential Jumps

The PC doesn’t always increment by one. Control flow instructions modify it:

Conditional Branches:

if condition
  do_something
end
 
# YARV (simplified):
PC = 0: getlocal condition
PC = 1: branchunless 5      # If false, PC → 5 (skip block)
PC = 2: do_something        # If true, PC → 3 (execute block)
PC = 3: ...
PC = 4: ...
PC = 5: ...                 # Continue here

Loops:

3.times { puts "hi" }
 
# YARV (simplified):
PC = 0: putobject 3
PC = 1: ...
PC = 2: puts "hi"
PC = 3: jump -2             # PC → 1 (back to loop start)

Method Calls:

def foo
  bar()  # PC saved, jumps to bar's instruction sequence
end

PC in YARV Frames

Each frame has its own PC:

def outer
  a = 1        # Frame A, PC advancing through outer's instructions
  inner()      # Frame A, PC saved; create Frame B
  a = 2        # Frame A, PC resumes here after inner returns
end
 
def inner
  b = 10       # Frame B, PC advancing through inner's instructions
end

Frame stack with PCs:

┌──────────────────────────┐
│  Frame B (inner)         │
│  PC → instruction 2 of 5 │
├──────────────────────────┤
│  Frame A (outer)         │
│  PC → instruction 4 of 8 │
│  (saved during call)     │
└──────────────────────────┘

When inner returns, Frame B is destroyed and Frame A’s PC resumes execution.

PC and Stack Pointer Coordination

The PC works closely with the stack pointer (SP):

# Computing 2 + 3
PC = 0: putobject 2    # SP moves up (pushed value)
PC = 1: putobject 3    # SP moves up (pushed value)
PC = 2: add            # SP moves down (popped 2, pushed 1)
PC = 3: ...            # Continue with result on stack

The PC determines which instruction executes, while the SP tracks where values are on the stack data structure.

Exception Handling

When exceptions occur, the PC is used to unwind the call stack:

begin
  dangerous_operation  # Exception thrown here
rescue => e
  handle_error        # PC jumps here
end
 
# YARV:
PC = 0: dangerous_operation
PC = 1: ...
# Exception! Search exception table...
# Jump PC to rescue handler
PC = 10: handle_error

YARV maintains exception tables mapping PC ranges to handler locations. See virtual machine architecture for exception mechanisms.

Debugging and Tracepoints

The PC enables debugging features:

# Ruby's TracePoint uses PC information
trace = TracePoint.new(:line) do |tp|
  puts "#{tp.path}:#{tp.lineno}"  # Derived from PC position
end
trace.enable

YARV’s tracepoint system publishes events based on PC positions, allowing debuggers and profilers to track execution.

Performance Implications

PC operations are performance-critical:

Fast Operations:

• PC increment (simple addition)
• Sequential execution
• Direct jumps (branch to known offset)

Slower Operations:

• Method dispatch (lookup + PC jump)
• Exception handling (search exception tables)
• Dynamic jumps (computed PC targets)

JIT compilers optimize PC management by compiling away the instruction dispatch loop.

PC vs Physical CPU

The program counter in a VM mirrors the instruction pointer in physical CPUs:

Physical CPU:

• Hardware register (e.g., RIP on x86-64)
• Points to machine code instruction
• Updates on every CPU cycle

Virtual Machine:

• Software variable in the VM
• Points to bytecode instruction
• Updates on every VM instruction execution

The YARV interpreter maintains a PC in software that mimics what hardware does naturally.

Implementation Example

Simplified VM with PC:

class SimpleVM
  def initialize(instructions)
    @instructions = instructions
    @pc = 0
    @stack = []
  end
 
  def run
    while @pc < @instructions.length
      instruction = @instructions[@pc]
 
      case instruction[:type]
      when :push
        @stack.push(instruction[:value])
        @pc += 1  # Advance PC
 
      when :add
        b = @stack.pop
        a = @stack.pop
        @stack.push(a + b)
        @pc += 1  # Advance PC
 
      when :jump
        @pc = instruction[:target]  # Jump to target PC
 
      when :branch_if
        condition = @stack.pop
        @pc = condition ? instruction[:target] : @pc + 1
      end
    end
 
    @stack.last
  end
end