컴파일러와 인터프리터: 코드가 실행되는 원리 — 개발자가 알아야 할 언어 처리의 모든 것

소스코드 → [렉서] → 토큰 → [파서] → AST → [의미 분석] → IR → [최적화] → [코드 생성] → 실행

# 입력: "let x = 42 + y;"
# 출력 토큰:
# [LET, "let"] [IDENT, "x"] [ASSIGN, "="] [NUMBER, "42"]
# [PLUS, "+"] [IDENT, "y"] [SEMICOLON, ";"]

import re
from enum import Enum, auto
from dataclasses import dataclass
from typing import List

class TokenType(Enum):
    NUMBER = auto()
    PLUS = auto()
    MINUS = auto()
    STAR = auto()
    SLASH = auto()
    LPAREN = auto()
    RPAREN = auto()
    IDENT = auto()
    ASSIGN = auto()
    LET = auto()
    EOF = auto()

@dataclass
class Token:
    type: TokenType
    value: str
    line: int
    col: int

KEYWORDS = {"let": TokenType.LET}

TOKEN_PATTERNS = [
    (r'\d+(\.\d+)?', TokenType.NUMBER),
    (r'[a-zA-Z_]\w*', TokenType.IDENT),
    (r'\+', TokenType.PLUS),
    (r'-', TokenType.MINUS),
    (r'\*', TokenType.STAR),
    (r'/', TokenType.SLASH),
    (r'\(', TokenType.LPAREN),
    (r'\)', TokenType.RPAREN),
    (r'=', TokenType.ASSIGN),
]

def tokenize(source: str) -> List[Token]:
    tokens = []
    pos = 0
    line = 1
    col = 1

    while pos < len(source):
        # 공백 건너뛰기
        if source[pos] in ' \t':
            pos += 1
            col += 1
            continue
        if source[pos] == '\n':
            pos += 1
            line += 1
            col = 1
            continue

        matched = False
        for pattern, token_type in TOKEN_PATTERNS:
            regex = re.compile(pattern)
            match = regex.match(source, pos)
            if match:
                value = match.group()
                # 키워드 확인
                actual_type = KEYWORDS.get(value, token_type)
                tokens.append(Token(actual_type, value, line, col))
                pos = match.end()
                col += len(value)
                matched = True
                break

        if not matched:
            raise SyntaxError(
                f"Unexpected char '{source[pos]}' at {line}:{col}"
            )

    tokens.append(Token(TokenType.EOF, "", line, col))
    return tokens

# 테스트
source = "let x = 42 + y"
for tok in tokenize(source):
    print(f"{tok.type.name:8} | {tok.value}")

LET      | let
IDENT    | x
ASSIGN   | =
NUMBER   | 42
PLUS     | +
IDENT    | y
EOF      |

@dataclass
class NumberNode:
    value: float

@dataclass
class BinaryOpNode:
    left: any
    op: str
    right: any

@dataclass
class AssignNode:
    name: str
    value: any

class Parser:
    def __init__(self, tokens: List[Token]):
        self.tokens = tokens
        self.pos = 0

    def current(self) -> Token:
        return self.tokens[self.pos]

    def eat(self, token_type: TokenType) -> Token:
        token = self.current()
        if token.type != token_type:
            raise SyntaxError(
                f"Expected {token_type}, got {token.type}"
            )
        self.pos += 1
        return token

    def parse_expression(self):
        left = self.parse_term()
        while self.current().type in (TokenType.PLUS, TokenType.MINUS):
            op = self.eat(self.current().type).value
            right = self.parse_term()
            left = BinaryOpNode(left, op, right)
        return left

    def parse_term(self):
        left = self.parse_factor()
        while self.current().type in (TokenType.STAR, TokenType.SLASH):
            op = self.eat(self.current().type).value
            right = self.parse_factor()
            left = BinaryOpNode(left, op, right)
        return left

    def parse_factor(self):
        token = self.current()
        if token.type == TokenType.NUMBER:
            self.eat(TokenType.NUMBER)
            return NumberNode(float(token.value))
        elif token.type == TokenType.LPAREN:
            self.eat(TokenType.LPAREN)
            node = self.parse_expression()
            self.eat(TokenType.RPAREN)
            return node
        elif token.type == TokenType.IDENT:
            self.eat(TokenType.IDENT)
            return token.value
        raise SyntaxError(f"Unexpected token: {token}")

    AssignNode
    ├── name: "x"
    └── value: BinaryOpNode(+)
              ├── NumberNode(42)
              └── BinaryOpNode(*)
                        ├── "y"
                        └── NumberNode(2)

PRECEDENCE = {
    TokenType.PLUS: 10,
    TokenType.MINUS: 10,
    TokenType.STAR: 20,
    TokenType.SLASH: 20,
}

def pratt_parse(parser, min_bp=0):
    # prefix (숫자, 식별자)
    left = parser.parse_factor()

    while True:
        op = parser.current()
        bp = PRECEDENCE.get(op.type, 0)
        if bp <= min_bp:
            break
        parser.eat(op.type)
        right = pratt_parse(parser, bp)
        left = BinaryOpNode(left, op.value, right)

    return left

JavaScript 소스
    ↓
  파서 → AST
    ↓
  Ignition (바이트코드 인터프리터)
    ↓ (프로파일링 데이터 수집)
  TurboFan (최적화 JIT 컴파일러)
    ↓
  최적화된 기계어
    ↓ (Deoptimization — 가정 깨지면 되돌림)
  Ignition으로 복귀

// 좋은 패턴 — 같은 Hidden Class 공유
function Point(x, y) {
  this.x = x;  // Hidden Class C0 → C1
  this.y = y;  // Hidden Class C1 → C2
}
const p1 = new Point(1, 2);  // Shape: C2
const p2 = new Point(3, 4);  // Shape: C2 (동일!)

// 나쁜 패턴 — Hidden Class 불일치
const a = {};
a.x = 1;
a.y = 2;  // Shape: S1

const b = {};
b.y = 2;  // 순서 다름!
b.x = 1;  // Shape: S2 (다른 Shape!)

function getX(obj) {
  return obj.x;  // Inline Cache가 여기에 생성
}

// Monomorphic (1개 Shape) — 가장 빠름
getX(p1);  // Shape C2로 캐시
getX(p2);  // Shape C2 — 캐시 히트!

// Polymorphic (2-4개 Shape) — 약간 느림
// Megamorphic (5개 이상 Shape) — 느림, 일반 경로 사용

import dis

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

# 바이트코드 확인
dis.dis(fibonacci)

  2           0 LOAD_FAST                0 (n)
              2 LOAD_CONST               1 (1)
              4 COMPARE_OP               1 (<=)
              6 POP_JUMP_IF_FALSE       12

  3           8 LOAD_FAST                0 (n)
             10 RETURN_VALUE

  4     >>   12 LOAD_GLOBAL              0 (fibonacci)
             14 LOAD_FAST                0 (n)
             16 LOAD_CONST               2 (1)
             18 BINARY_SUBTRACT
             20 CALL_FUNCTION            1
             ...

# GIL 때문에 CPU-bound 작업에서 멀티스레딩이 비효율적
import threading
import time

def cpu_bound(n):
    count = 0
    for i in range(n):
        count += i
    return count

# 싱글 스레드
start = time.time()
cpu_bound(50_000_000)
cpu_bound(50_000_000)
print(f"Single: {time.time() - start:.2f}s")

# 멀티 스레드 (GIL 때문에 더 느릴 수 있음)
start = time.time()
t1 = threading.Thread(target=cpu_bound, args=(50_000_000,))
t2 = threading.Thread(target=cpu_bound, args=(50_000_000,))
t1.start(); t2.start()
t1.join(); t2.join()
print(f"Multi:  {time.time() - start:.2f}s")

# 해결책: multiprocessing 사용
from multiprocessing import Pool
start = time.time()
with Pool(2) as p:
    p.map(cpu_bound, [50_000_000, 50_000_000])
print(f"Multi-process: {time.time() - start:.2f}s")

CPython:  fibonacci(35) → ~4.5초
PyPy:     fibonacci(35) → ~0.3초 (약 15배 빠름)

// Hello.java
public class Hello {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 0; i < 1000; i++) {
            sum += i;
        }
        System.out.println(sum);
    }
}

# 컴파일
javac Hello.java

# 바이트코드 확인
javap -c Hello.class

public static void main(java.lang.String[]);
  Code:
     0: iconst_0
     1: istore_1        // sum = 0
     2: iconst_0
     3: istore_2        // i = 0
     4: iload_2
     5: sipush  1000
     8: if_icmpge  21   // if i >= 1000 goto 21
    11: iload_1
    12: iload_2
    13: iadd
    14: istore_1        // sum += i
    15: iinc    2, 1    // i++
    18: goto    4
    21: ...             // println

바이트코드 실행 (인터프리터)
    ↓ (메서드 실행 횟수 카운트)
  C1 컴파일러 (빠른 컴파일, 기본 최적화)
    ↓ (더 많이 실행되면)
  C2 컴파일러 (느린 컴파일, 공격적 최적화)
    ↓
  최적화된 기계어

# GraalVM Native Image — AOT 컴파일
native-image -jar myapp.jar -o myapp

# 결과: 기동 시간 수십 밀리초의 네이티브 바이너리
# JVM: ~2초 시작 → GraalVM Native: ~20ms 시작

프론트엔드           미들엔드              백엔드
(언어별)            (공통)               (타겟별)
                                    ┌→ x86_64
Clang ─┐         ┌→ 최적화 패스 ─┤→ ARM
       ├→ LLVM IR ┤              └→ WASM
rustc ─┤         └→ 분석 패스
       │
swiftc ┘

; 함수: add(a, b) = a + b
define i32 @add(i32 %a, i32 %b) {
entry:
  %result = add i32 %a, %b
  ret i32 %result
}

; 함수: factorial(n)
define i64 @factorial(i64 %n) {
entry:
  %cmp = icmp sle i64 %n, 1
  br i1 %cmp, label %base, label %recurse

base:
  ret i64 1

recurse:
  %n_minus_1 = sub i64 %n, 1
  %sub_result = call i64 @factorial(i64 %n_minus_1)
  %result = mul i64 %n, %sub_result
  ret i64 %result
}

# LLVM 최적화 패스 적용
opt -O2 input.ll -o optimized.ll

# 주요 최적화 패스:
# -mem2reg     : 메모리 접근을 레지스터로 승격
# -inline      : 함수 인라이닝
# -gvn         : Global Value Numbering (중복 계산 제거)
# -licm        : Loop Invariant Code Motion (루프 밖으로 이동)
# -loop-unroll : 루프 언롤링
# -sccp        : Sparse Conditional Constant Propagation
# -dce         : Dead Code Elimination

// 최적화 전
int x = 3 + 4;
int y = x * 2;

// 상수 폴딩 후
int x = 7;
int y = 14;

1. Mark 단계: 루트에서 도달 가능한 모든 객체를 마킹
2. Sweep 단계: 마킹되지 않은 객체의 메모리 해제

루트(Root):
  - 전역 변수
  - 스택의 지역 변수
  - 레지스터

[A] → [B] → [C]
       ↓
      [D]

[E] → [F]  (루트에서 도달 불가 → 수집 대상)

Young Generation (Minor GC — 자주, 빠르게)
  ├── Eden Space (새 객체 할당)
  ├── Survivor 0
  └── Survivor 1

Old Generation (Major GC — 드물게, 느리게)
  └── 오래 살아남은 객체들

GC 과정:
1. 새 객체 → Eden에 할당
2. Eden이 가득 차면 Minor GC
3. 살아남은 객체 → Survivor로 이동
4. N번 살아남으면 → Old Generation으로 승격
5. Old Generation이 가득 차면 Major GC

전통적 GC:       Stop-the-World → Mark → Compact → Resume
                 (긴 중단 시간)

ZGC:             애플리케이션 실행과 GC가 동시에 수행
                 (포인터 컬러링 + 로드 배리어로 일관성 유지)

포인터 컬러링:
  64비트 포인터의 상위 비트를 GC 메타데이터로 사용
  [metadata bits][actual address bits]

  - Marked0 비트: 첫 번째 마킹 사이클
  - Marked1 비트: 두 번째 마킹 사이클
  - Remapped 비트: 객체가 재배치됨
  - Finalizable 비트: 파이널라이저 보류 중

// 입력: ES2022+
const greet = (name) => `Hello, ${name}!`;
const items = [1, 2, 3];
const doubled = items.map(x => x * 2);

// Babel 변환 후: ES5
"use strict";
var greet = function greet(name) {
  return "Hello, " + name + "!";
};
var items = [1, 2, 3];
var doubled = items.map(function (x) {
  return x * 2;
});

TypeScript 소스
    ↓
  파서 → AST
    ↓
  바인더(Binder) → 심볼 테이블
    ↓
  타입 체커(Type Checker) → 타입 에러 보고
    ↓
  이미터(Emitter) → JavaScript + .d.ts + .map

# esbuild 벤치마크 예시
# 10,000개 모듈 번들링:
# Webpack:   40초
# esbuild:    0.4초