ir: 중간 표현을 정의한다

명령 12개와 종결자 4개. 함수 단위 기본 블록이고 임시값은 블록을 넘지 않아
phi 노드가 없다 -- 블록을 넘겨야 하는 값은 지역을 경유한다. 코드가 조금 더
생기지만 레지스터 할당기를 블록 단위로 유지해 준다.

Ferro 타입은 여기서 사라진다. 구조체·슬라이스·옵셔널·에러 유니온이 전부
mem<N> 이고 필드는 lowering 이 계산한 바이트 오프셋이다. 모노모피제이션이
프론트엔드에서 끝나므로 IR 에 제네릭이라는 개념도 없다.

덩어리는 언제나 주소로 오간다. 크기 임계값이 없어서 ISA 마다 다른 구조체 전달
규칙을 통째로 피해간다. trap 은 이유와 줄 번호만 남기고 파일 이름 문자열은
유닛당 하나를 공유한다.

IR.md 가 설명이고 ir.h/ir.c 가 그 형태다. 아직 아무도 만들지 않는다.

IR.md

@@ -0,0 +1,180 @@
+# Ferro IR
+
+`fec` 의 중간 표현. 이 문서는 IR 자체만 다룬다. 언어 규범은 `SPEC.md` 이고,
+Ferro 의미론이 어떻게 이 형태로 펴지는지는 lowering 이 담당한다.
+
+IR 을 두는 이유는 하나다. **검사가 끝난 AST 와 기계 사이의 거리가 너무 멀다.**
+`try` 하나가 분기 두 개와 임시값 하나로 펴지고, `defer` 는 함수의 모든 이탈
+경로에 복제되며, 배열 인덱스는 비교와 트랩을 낳는다. 그 전개를 명령어 선택과
+같은 자리에서 하면 둘 다 읽을 수 없게 된다.
+
+---
+
+## 1. 형태
+
+함수 단위다. 함수는 **기본 블록**의 목록이고, 블록은 **명령**의 목록과 하나의
+**종결자**로 끝난다. 블록 중간에서 분기하지 않고, 종결자 뒤에 명령이 없다.
+
+```
+fn @okid.test() -> i32 {
+  $0: i32                  ; 지역
+  b0:
+    %0 = const i32 7
+    store $0, %0
+    %1 = load i32 $0
+    ret %1
+}
+```
+
+### 슬롯
+
+| | | |
+|---|---|---|
+| `%n` | 임시값 | 한 번 정의되고 여러 번 쓰인다. 블록을 넘지 않는다 |
+| `$n` | 지역 | 주소를 가진 스택 자리. 함수 진입 시 전부 잡는다 |
+| `@name` | 전역·함수 | 링커가 보는 이름 |
+
+임시값이 블록을 넘지 않으므로 φ 노드가 없다. 블록을 넘겨야 하는 값은 지역에
+`store` 하고 다시 `load` 한다. 이것이 SSA 보다 코드를 조금 더 만들지만,
+**레지스터 할당기를 블록 단위로 유지**해 준다. v0.1 에서는 그 교환이 맞다.
+
+### 기계 타입
+
+```
+i8  i16  i32  ptr  mem<N>
+```
+
+Ferro 타입은 여기서 사라진다. 구조체·배열·슬라이스·옵셔널·에러 유니온은 전부
+`mem<N>` 이고, 필드 접근은 lowering 이 계산한 **바이트 오프셋**이다. IR 은
+`Box(i32)` 라는 것을 모른다 — 크기 N 바이트짜리 메모리만 안다.
+
+`ptr` 은 4바이트다. 세그먼트가 없으므로 포인터 종류도 하나뿐이다 (`SPEC.md` §2).
+
+`bool` 은 `i8`, `char` 는 `i8`, `usize` 는 `i32` 다.
+
+---
+
+## 2. 명령
+
+12개다.
+
+```
+%d = const <ty> <imm>          상수
+%d = load  <ty> <place>        메모리에서 읽는다
+     store <place>, %v         메모리에 쓴다
+%d = addr  <place>             주소를 뜬다
+%d = <op>  <ty> %a, %b         산술·비트 연산
+%d = <cmp> <ty> %a, %b         비교. 결과는 i8
+%d = cast  <from> <to> %a      정수 폭 변환
+%d = call  @f(%a, ...)         호출
+     copy  <place>, <place>, N  N바이트 복사
+```
+
+`<op>` — `add sub mul div mod and or xor shl shr`
+`<cmp>` — `eq ne lt le gt ge` (부호 있음/없음은 `<ty>` 가 정한다)
+
+### place
+
+`load`·`store`·`addr`·`copy` 의 피연산자다.
+
+```
+$n              지역
+@name           전역
+%p              포인터 임시값이 가리키는 곳
+%p + <imm>      상수 오프셋. 필드 접근이 여기로 온다
+```
+
+인덱스처럼 오프셋이 상수가 아니면 lowering 이 주소를 먼저 계산한다.
+
+```
+; a[i] 는
+%0 = load i32 $i
+%1 = const i32 4          ; 원소 크기
+%2 = mul i32 %0, %1
+%3 = addr $a
+%4 = add ptr %3, %2
+%5 = load i32 %4
+```
+
+### 덩어리
+
+**덩어리는 언제나 주소로 오간다.** 크기 임계값이 없다.
+
+```
+call @f(%p)          ; f 가 mem<N> 을 받으면 %p 는 그 주소다
+```
+
+반환도 같다. `mem<N>` 을 반환하는 함수는 **첫 인자로 결과를 쓸 주소를 받는다**.
+호출자가 자리를 잡고 넘긴다.
+
+이 규약을 고른 이유는 단순해서만이 아니다. ISA 마다 다른 "구조체를 언제
+레지스터로 넘기는가" 규칙을 통째로 피해간다. `extern "c"` 경계에서는 C ABI 로
+변환해야 하며 그것은 백엔드의 일이다.
+
+---
+
+## 3. 종결자
+
+4개다.
+
+```
+jmp  b<n>                      무조건 분기
+br   %c, b<t>, b<f>            %c 가 0이 아니면 b<t>
+ret  [%v]                      반환
+trap <reason> <line>           중단
+```
+
+`trap` 은 `fe_trap(reason, UNIT_FILE, line)` 이 된다. `reason` 은 작은 정수이고
+`UNIT_FILE` 은 **유닛당 하나뿐인 파일 이름 문자열**이다. 트랩 지점마다 문자열을
+두면 실행 파일이 부풀기 때문이다.
+
+`line` 은 컴파일 시점에 상수로 박힌다. 주소가 아니라 줄 번호를 남기는 방식은
+당대에 흔했고, 심볼 테이블 없이 실패 지점을 말할 수 있는 가장 싼 방법이다.
+
+reason 값:
+
+| | |
+|---|---|
+| 0 | 배열·슬라이스 경계 |
+| 1 | 정수 오버플로 |
+| 2 | 0으로 나눔 |
+| 3 | 도달할 수 없는 곳에 도달 (`@unreachable`) |
+| 4 | 명시적 `@trap()` |
+
+`--no-checks` 는 0·1·2 를 만드는 검사를 lowering 단계에서 생략한다. 3·4 는
+소스에 쓰인 것이므로 남는다.
+
+---
+
+## 4. 함수와 전역
+
+```
+fn @unit.name(<ty>, ...) -> <ty> { ... }
+extern fn @name(<ty>, ...) -> <ty>
+global @unit.name : mem<N> = <초기값 바이트>
+```
+
+이름은 `유닛.이름` 이다. 제네릭 인스턴스도 여기서는 그냥 함수 하나다 —
+모노모피제이션이 프론트엔드에서 끝나므로 **IR 에 제네릭이라는 개념이 없다.**
+
+---
+
+## 5. 이 IR 이 하지 않는 것
+
+- **최적화 없음.** 상수 접기도, 죽은 코드 제거도 없다. 나중에 붙일 자리는 있다
+- **φ 노드 없음.** 블록 간 값은 지역을 경유한다
+- **타입 검사 없음.** 검사는 프론트엔드에서 끝났다. IR 이 잘못되었다면 lowering 의 버그다
+- **예외·언와인딩 없음.** 에러는 값이고, `try` 는 분기다
+
+---
+
+## 6. 왜 이 크기인가
+
+명령 12개와 종결자 4개는 **i386 으로 직접 번역할 수 있는 최소 집합**이다.
+각각이 몇 개의 x86 명령으로 내려가고, 그 대응이 눈으로 확인된다. 이보다 높으면
+백엔드가 IR 을 다시 해석해야 하고, 이보다 낮으면 lowering 이 기계에 가까워져서
+다른 ISA 로 옮길 때 다시 써야 한다.
+
+같은 이유로 이 집합은 m68k·ARM·MIPS·RV32 에도 그대로 내려간다. 평평한 주소
+공간과 정수 연산만 쓰기 때문이다. 백엔드를 하나 더 만드는 비용은 명령 선택과
+레지스터 할당이지 IR 재설계가 아니다.

TODO.md

@@ -1,38 +1,31 @@
 # TODO
 
-현재: **150/188** (`uv run python tests/run.py`)
+현재: **188/188** (`uv run python tests/run.py`)
 
-컴파일러는 프론트엔드뿐이다. IR·lowering·백엔드는 없다.
+프론트엔드는 끝났다. 목표는 **i386 백엔드 + stdlib 으로 Windows 11 용 컴파일러를
+완성하는 것**이다. 아직 실행된 Ferro 프로그램은 하나도 없다.
 
 ---
 
-## 프론트엔드 마무리
+## 남은 일
-
-| # | 일 | 규모 | fixture | 비고 |
-|---|---|---|---|---|
-| 1 | cross-unit 이름 해석 | 중 | units 8 | `util.answer()` 가 다른 유닛 선언을 보게. `check.c` 가 import binding 을 심볼로 알아야 함 |
-| 2 | 가시성 `pub`/private | 중 | units 4 | `privfn` `privfld` `dotpriv` `pubpriv` |
-| 3 | nominal error identity | 중 | units 3 | `errsame` `errdet` `errnom` |
-| 4 | **제네릭 실체화** | 대 | generic 25 | worklist 엔진. **IR 설계에 직접 영향 — 분기점** |
-| 5 | 마커 없는 fixture 37개 판정 | 중 | — | 개당 판단 필요. 아래 참조 |
-
-## 백엔드
 
 | # | 일 | 규모 | 비고 |
 |---|---|---|---|
-| 6 | IR 정의 | 중 | 초안 있음. 4번이 정해져야 확정 |
+| 1 | **IR 정의** | 중 | 3-address, 기본 블록, 함수 단위. 명령 12 + 종결자 4 |
-| 7 | **lowering** | 대 | `try`/`catch`/`defer`/drop/`for`/메서드/경계검사 전개. **프로젝트 무게중심** |
+| 2 | **lowering** | 대 | `try`/`catch`/`orelse`/`defer`/drop/`for`/메서드/경계검사/옵셔널·에러유니온 구성/제네릭 인스턴스 전개. **프로젝트 무게중심** |
-| 8 | i386 백엔드 | 대 | IR → x86 asm → `wasm` → `wlink`. W11 에서 실행 검증 |
+| 3 | i386 백엔드 | 대 | IR → x86 asm → `wasm` → `wlink` → PE. 명령 선택, 레지스터 할당, 호출 규약 |
-| 9 | 런타임 최소 세트 | 소~중 | 시작 스텁, `fe_trap`, `malloc`/`free` |
+| 4 | 런타임 | 소~중 | 시작 스텁, `fe_trap(reason, file, line)`, 할당, 종료 |
-| 10 | `pending-backend/` 3개 복귀 | 소 | bounds trap, `--no-checks` 차등, 소유권 drop |
+| 5 | `pending-backend/` 4개 복귀 | 소 | bounds trap, `--no-checks` 차등, 소유권 drop. **처음으로 실행이 검증됨** |
+| 6 | stdlib 명세 | 중 | SPEC §10 이 플레이스홀더. 시그니처·오류·경계 동작 미정 |
+| 7 | stdlib 구현 | 대 | `core` `mem` `fmt` `io` `sys`, 그리고 제네릭이 생겼으니 `list` `map` |
 
 ## 그 이후
 
-| # | 일 | 규모 | 비고 |
+| | | |
-|---|---|---|---|
+|---|---|---|
-| 11 | stdlib | 대 | 현재 49줄, 본문 있는 함수 2개. `List`/`Map` 은 4번에 의존 |
+| 셀프호스팅 | 대 | `fec` 을 Ferro 로. 여기까지 오면 언어가 자기 무게를 견딘다는 증거 |
-| 12 | bits16 백엔드 | 대 | `DX:AX` 32비트 산술, 세그먼트. 제일 어려움. 마지막 |
+| 인터럽트·공유 상태 | 중 | `interrupt` `shared` `atomic` `critical` — 파싱만 되고 의미 없음. SPEC §11 에서 v0.2 |
-| 13 | 타깃 의존 구문 | 중 | `far` `asm` `interrupt` `atomic` `critical` `shared` — 파싱만 되고 의미 없음. fixture 도 없음 |
+| 다른 32비트 타깃 | 대 | m68k / ARM / MIPS / RV32. IR 결정은 전부 ISA 중립이라 백엔드만 붙이면 됨 |
 
 ---
 
@@ -40,27 +33,32 @@
 
 | | 내용 | 언제 |
 |---|---|---|
-| 덩어리 전달 규약 | 정함 (전부 주소로). 8번 착수 전 재확인 | 8 전 |
+| 덩어리 전달 규약 | 정함 (전부 주소로). 3번 착수 전 재확인 | 3 전 |
-| `extern` C 상호운용 | 위 규약이 C ABI 와 안 맞음. 경계 변환 필요 | 8 전 |
+| `extern` C 상호운용 | 위 규약이 C ABI 와 안 맞음. 경계 변환 필요 | 3 전 |
-| 주 타깃 | i386/W11 로 기울었으나 SPEC §1.2 는 아직 "640KB 셀프호스팅" | 아무 때나 |
+| 엔디안 | 리틀엔디안 가정. `packed struct` 가 바이트 배치를 약속하므로, 빅엔디안 타깃(m68k·MIPS·POWER)이 생기면 타깃 파라미터가 된다 | 다른 타깃 전 |
-| stdlib 명세 | SPEC §10 이 플레이스홀더. 시그니처·오류·경계 동작 미정 | 11 전 |
+| stdlib 명세 | SPEC §10 이 플레이스홀더 | 6 |
-| `far` 의 거취 | IR 에 안 두기로 함. 언어에서 뺄지 bits16 전용으로 둘지는 미정 | 12 전 |
+
+## 정해진 것
+
+| | |
+|---|---|
+| 타깃 | **i386 하나.** 세그먼트 없음, `far` 영구 제외 (SPEC §2) |
+| `usize`/`isize` | **타깃의 포인터 폭.** 비트 수를 약속하지 않으므로 64비트 문이 닫히지 않음 |
+| 제네릭 | 모노모피제이션. 순수 프론트엔드 기능이라 IR 에 제네릭 개념이 없음 |
+| 덩어리 전달 | 전부 주소로. 크기 임계값 없음 — ISA 마다 다른 구조체 전달 ABI 를 피해감 |
+| 트랩 | `trap <reason> <line>` → `fe_trap(reason, UNIT_FILE, line)`. 유닛당 파일 문자열 하나 |
+| 셀프호스팅 | 640KB 목표 아님. 32비트 보호모드에서 돈다 (SPEC §2.1) |
 
 ---
 
 ## 순서
 
 ```
-1 → 2 → 3        프론트엔드 유닛 완성
+1 → 2            IR + lowering
-4                제네릭.  ← 여기서 IR 형태가 결정됨
+3 → 4 → 5        i386 백엔드, 런타임, 실행 검증 복귀   ← 여기서 처음 실행됨
-6 → 7            IR + lowering
+6 → 7            stdlib
-8 → 9 → 10       i386 백엔드, 실행 검증 복귀
-11               stdlib
-12 → 13          DOS 고유
 ```
 
-5번은 독립적이라 아무 때나 끼워 넣는다.
-
 ---
 
 ## 위임 정책
@@ -73,43 +71,12 @@
 
 **위임 불가** — 언어 의미론 판단이 섞인 것
 
-- 마커 판정, cross-unit 해석, 가시성, 제네릭, IR/lowering/백엔드
+- 마커 판정, IR/lowering/백엔드, stdlib 명세
 
 ---
 
-## 5번에 대하여 (마커 없는 fixture 37개)
+## 미뤄둔 정리 작업
 
-거부 fixture 76개 중 **37개에 `// ERROR:` 마커가 없다.** 마커가 없으면 러너는
+fixture 122개 이름이 아직 DOS 8.3 시절 잔재라 무엇을 검사하는지 이름만으로는
-"거부되기만 하면 통과" 로 판정한다. 즉 **엉뚱한 이유로 거부돼도 초록이다.**
+알 수 없다. 마커가 전부 붙었으므로 `bad`/`ok` 접두사는 이제 기대값이 아니고,
-
+자유롭게 이름을 지을 수 있다. 급하지 않다.
-```
-format  10    own  8    types  19
-```
-
-마커를 붙이려면 fixture 마다 "지금 나오는 진단이 옳은가" 를 판정해야 하고,
-그 판정은 세 갈래로 갈린다. 오늘 5건을 조사했을 때 실제로 셋 다 나왔다:
-
-| 결론 | 예 | 조치 |
-|---|---|---|
-| 마커가 틀렸다 | `badbrmov` 한 줄 밀림 | 마커 수정 |
-| 마커가 언어를 오해했다 | `badloop` — 루프 안에서 이미 걸림 | 마커 수정 |
-| **진단이 부실하다** | `badweak` — "type mismatch" 로만 나옴 | **컴파일러 수정** |
-
-세 번째 때문에 위임이 위험하다. 실제 출력을 마커에 그대로 베끼면 전부 초록이
-되지만 **컴파일러가 틀린 곳까지 정답으로 굳는다.**
-
-### 병렬화
-
-판정 자체는 **fixture 간 독립**이라 병렬 가능하다. 다만 **판정을 위임하면 안 된다.**
-쓸 수 있는 형태는 증거 수집과 판정을 나누는 것이다:
-
-```
-위임:  fixture 를 열고 → fec 를 돌리고 → 다음을 보고
-         파일 경로 / 검사하려는 것으로 보이는 규칙 / 실제 진단 전문(줄·문구)
-       마커는 만들지 않는다
-
-직접:  보고를 읽고 세 갈래 중 무엇인지 판정 → 마커를 쓰거나 컴파일러를 고침
-```
-
-이러면 37개를 디렉터리별로 병렬로 뿌려 증거를 모으고, 판정만 직접 하면 된다.
-느린 부분(파일 읽기·실행·정리)이 병렬화되고 위험한 부분은 남는다.

fec/src/ir.c

@@ -0,0 +1,408 @@
+#include "ir.h"
+#include <string.h>
+
+void fe_ir_module_init(FeIrModule *m)
+{
+    fe_arena_init(&m->arena, 16384);
+    m->unit_file = "";
+    m->funcs = 0;
+    m->last_func = 0;
+    m->globals = 0;
+    m->last_global = 0;
+}
+
+void fe_ir_module_destroy(FeIrModule *m)
+{
+    fe_arena_destroy(&m->arena);
+    m->funcs = 0;
+    m->last_func = 0;
+    m->globals = 0;
+    m->last_global = 0;
+}
+
+static void *ir_alloc(FeIrModule *m, unsigned long size)
+{
+    return fe_arena_alloc(&m->arena, (size_t)size);
+}
+
+FeIrFunc *fe_ir_func(FeIrModule *m, const char *name, FeIrType ret,
+                     unsigned long ret_size)
+{
+    FeIrFunc *f = (FeIrFunc *)ir_alloc(m, sizeof(FeIrFunc));
+    if (!f) return 0;
+    memset(f, 0, sizeof *f);
+    f->name = name;
+    f->ret = ret;
+    f->ret_size = ret_size;
+    /* An aggregate result is written through a hidden first parameter, so the
+       caller owns the storage and no size threshold has to be agreed on. */
+    f->returns_by_address = ret == FE_IR_MEM;
+    if (m->last_func) m->last_func->next = f;
+    else m->funcs = f;
+    m->last_func = f;
+    return f;
+}
+
+unsigned fe_ir_local(FeIrModule *m, FeIrFunc *f, FeIrType type,
+                     unsigned long size, unsigned align, const char *name)
+{
+    if (f->local_count == f->local_capacity) {
+        unsigned cap = f->local_capacity ? f->local_capacity * 2U : 8U;
+        FeIrLocal *grown = (FeIrLocal *)ir_alloc(m, cap * sizeof(FeIrLocal));
+        if (!grown) return 0;
+        if (f->locals)
+            memcpy(grown, f->locals, f->local_count * sizeof(FeIrLocal));
+        f->locals = grown;
+        f->local_capacity = cap;
+    }
+    f->locals[f->local_count].type = type;
+    f->locals[f->local_count].size = size;
+    f->locals[f->local_count].align = align ? align : 1U;
+    f->locals[f->local_count].name = name;
+    return f->local_count++;
+}
+
+unsigned fe_ir_temp(FeIrFunc *f)
+{
+    return f->temp_count++;
+}
+
+FeIrBlock *fe_ir_block(FeIrModule *m, FeIrFunc *f)
+{
+    FeIrBlock *b = (FeIrBlock *)ir_alloc(m, sizeof(FeIrBlock));
+    if (!b) return 0;
+    memset(b, 0, sizeof *b);
+    b->id = f->block_count++;
+    b->func = f;
+    /* Until something says otherwise a block falls off the end, which is only
+       correct for a void function; lowering always sets a real terminator. */
+    b->term = FE_IR_RET;
+    if (f->last) f->last->next = b;
+    else f->first = b;
+    f->last = b;
+    return b;
+}
+
+FeIrPlace fe_ir_at_local(unsigned index, long offset)
+{
+    FeIrPlace p;
+    p.base = FE_PLACE_LOCAL; p.index = index; p.name = 0; p.offset = offset;
+    return p;
+}
+
+FeIrPlace fe_ir_at_global(const char *name, long offset)
+{
+    FeIrPlace p;
+    p.base = FE_PLACE_GLOBAL; p.index = 0; p.name = name; p.offset = offset;
+    return p;
+}
+
+FeIrPlace fe_ir_at_temp(unsigned temp, long offset)
+{
+    FeIrPlace p;
+    p.base = FE_PLACE_TEMP; p.index = temp; p.name = 0; p.offset = offset;
+    return p;
+}
+
+static FeIrValue *emit(FeIrModule *m, FeIrBlock *b, FeIrOp op, FeIrType t)
+{
+    FeIrValue *v = (FeIrValue *)ir_alloc(m, sizeof(FeIrValue));
+    if (!v) return 0;
+    memset(v, 0, sizeof *v);
+    v->op = op;
+    v->type = t;
+    if (b->last) b->last->next = v;
+    else b->first = v;
+    b->last = v;
+    return v;
+}
+
+/* A result needs a fresh temporary, and the counter lives on the function, so
+   a block carries the function it is being built in. */
+static unsigned result(FeIrModule *m, FeIrBlock *b, FeIrValue *v)
+{
+    (void)m;
+    v->has_dest = 1;
+    v->dest = fe_ir_temp(b->func);
+    return v->dest;
+}
+
+unsigned fe_ir_const(FeIrModule *m, FeIrBlock *b, FeIrType t, long value)
+{
+    FeIrValue *v = emit(m, b, FE_IR_CONST, t);
+    if (!v) return 0;
+    v->imm = value;
+    return result(m, b, v);
+}
+
+unsigned fe_ir_load(FeIrModule *m, FeIrBlock *b, FeIrType t, FeIrPlace p)
+{
+    FeIrValue *v = emit(m, b, FE_IR_LOAD, t);
+    if (!v) return 0;
+    v->place = p;
+    return result(m, b, v);
+}
+
+void fe_ir_store(FeIrModule *m, FeIrBlock *b, FeIrPlace p, unsigned value)
+{
+    FeIrValue *v = emit(m, b, FE_IR_STORE, FE_IR_VOID);
+    if (!v) return;
+    v->place = p;
+    v->a = value;
+}
+
+unsigned fe_ir_addr(FeIrModule *m, FeIrBlock *b, FeIrPlace p)
+{
+    FeIrValue *v = emit(m, b, FE_IR_ADDR, FE_IR_PTR);
+    if (!v) return 0;
+    v->place = p;
+    return result(m, b, v);
+}
+
+unsigned fe_ir_binary(FeIrModule *m, FeIrBlock *b, FeIrOp op, FeIrType t,
+                      unsigned a, unsigned c, int is_unsigned)
+{
+    FeIrValue *v;
+    int is_cmp = op >= FE_IR_EQ && op <= FE_IR_GE;
+    v = emit(m, b, op, is_cmp ? FE_IR_I8 : t);
+    if (!v) return 0;
+    v->a = a;
+    v->b = c;
+    v->is_unsigned = is_unsigned;
+    /* A comparison reports i8 but reads its operands at `t`, so the width has
+       to survive somewhere the backend can see it. */
+    if (is_cmp) v->imm = (long)t;
+    return result(m, b, v);
+}
+
+unsigned fe_ir_cast(FeIrModule *m, FeIrBlock *b, FeIrType from, FeIrType to,
+                    unsigned a, int is_unsigned)
+{
+    FeIrValue *v = emit(m, b, FE_IR_CAST, to);
+    if (!v) return 0;
+    v->a = a;
+    v->imm = (long)from;
+    v->is_unsigned = is_unsigned;
+    return result(m, b, v);
+}
+
+unsigned fe_ir_call(FeIrModule *m, FeIrBlock *b, FeIrType ret,
+                    const char *callee, unsigned *args, unsigned count)
+{
+    FeIrValue *v = emit(m, b, FE_IR_CALL, ret);
+    unsigned i;
+    if (!v) return 0;
+    v->callee = callee;
+    v->arg_count = count;
+    if (count) {
+        v->args = (unsigned *)ir_alloc(m, count * sizeof(unsigned));
+        if (v->args) for (i = 0; i < count; ++i) v->args[i] = args[i];
+        else v->arg_count = 0;
+    }
+    if (ret == FE_IR_VOID) return 0;
+    return result(m, b, v);
+}
+
+void fe_ir_copy(FeIrModule *m, FeIrBlock *b, FeIrPlace dst, FeIrPlace src,
+                unsigned long size)
+{
+    FeIrValue *v = emit(m, b, FE_IR_COPY, FE_IR_VOID);
+    if (!v) return;
+    v->place = dst;
+    v->place2 = src;
+    v->imm = (long)size;
+}
+
+void fe_ir_jmp(FeIrBlock *b, unsigned target)
+{
+    b->term = FE_IR_JMP;
+    b->target = target;
+}
+
+void fe_ir_br(FeIrBlock *b, unsigned cond, unsigned t, unsigned f)
+{
+    b->term = FE_IR_BR;
+    b->cond = cond;
+    b->target = t;
+    b->target_else = f;
+}
+
+void fe_ir_ret(FeIrBlock *b, unsigned value, int has_value)
+{
+    b->term = FE_IR_RET;
+    b->ret_value = value;
+    b->has_ret_value = has_value;
+}
+
+void fe_ir_trap(FeIrBlock *b, FeIrTrap reason, unsigned long line)
+{
+    b->term = FE_IR_TRAP;
+    b->trap = reason;
+    b->trap_line = line;
+}
+
+const char *fe_ir_type_name(FeIrType t)
+{
+    switch (t) {
+    case FE_IR_VOID: return "void";
+    case FE_IR_I8:   return "i8";
+    case FE_IR_I16:  return "i16";
+    case FE_IR_I32:  return "i32";
+    case FE_IR_PTR:  return "ptr";
+    case FE_IR_MEM:  return "mem";
+    }
+    return "?";
+}
+
+const char *fe_ir_op_name(FeIrOp op)
+{
+    switch (op) {
+    case FE_IR_CONST: return "const";
+    case FE_IR_LOAD:  return "load";
+    case FE_IR_STORE: return "store";
+    case FE_IR_ADDR:  return "addr";
+    case FE_IR_ADD:   return "add";
+    case FE_IR_SUB:   return "sub";
+    case FE_IR_MUL:   return "mul";
+    case FE_IR_DIV:   return "div";
+    case FE_IR_MOD:   return "mod";
+    case FE_IR_AND:   return "and";
+    case FE_IR_OR:    return "or";
+    case FE_IR_XOR:   return "xor";
+    case FE_IR_SHL:   return "shl";
+    case FE_IR_SHR:   return "shr";
+    case FE_IR_EQ:    return "eq";
+    case FE_IR_NE:    return "ne";
+    case FE_IR_LT:    return "lt";
+    case FE_IR_LE:    return "le";
+    case FE_IR_GT:    return "gt";
+    case FE_IR_GE:    return "ge";
+    case FE_IR_CAST:  return "cast";
+    case FE_IR_CALL:  return "call";
+    case FE_IR_COPY:  return "copy";
+    }
+    return "?";
+}
+
+static const char *trap_name(FeIrTrap t)
+{
+    switch (t) {
+    case FE_TRAP_BOUNDS:      return "bounds";
+    case FE_TRAP_OVERFLOW:    return "overflow";
+    case FE_TRAP_DIVIDE:      return "divide";
+    case FE_TRAP_UNREACHABLE: return "unreachable";
+    case FE_TRAP_EXPLICIT:    return "trap";
+    }
+    return "?";
+}
+
+static void dump_place(const FeIrPlace *p, FILE *out)
+{
+    switch (p->base) {
+    case FE_PLACE_LOCAL:  fprintf(out, "$%u", p->index); break;
+    case FE_PLACE_GLOBAL: fprintf(out, "@%s", p->name ? p->name : "?"); break;
+    case FE_PLACE_TEMP:   fprintf(out, "%%%u", p->index); break;
+    }
+    if (p->offset) fprintf(out, " + %ld", p->offset);
+}
+
+static void dump_value(const FeIrValue *v, FILE *out)
+{
+    unsigned i;
+    fputs("    ", out);
+    if (v->has_dest) fprintf(out, "%%%u = ", v->dest);
+    switch (v->op) {
+    case FE_IR_CONST:
+        fprintf(out, "const %s %ld", fe_ir_type_name(v->type), v->imm);
+        break;
+    case FE_IR_LOAD:
+        fprintf(out, "load %s ", fe_ir_type_name(v->type));
+        dump_place(&v->place, out);
+        break;
+    case FE_IR_STORE:
+        fputs("store ", out);
+        dump_place(&v->place, out);
+        fprintf(out, ", %%%u", v->a);
+        break;
+    case FE_IR_ADDR:
+        fputs("addr ", out);
+        dump_place(&v->place, out);
+        break;
+    case FE_IR_CAST:
+        fprintf(out, "cast %s %s %%%u",
+                fe_ir_type_name((FeIrType)v->imm),
+                fe_ir_type_name(v->type), v->a);
+        break;
+    case FE_IR_CALL:
+        fprintf(out, "call @%s(", v->callee ? v->callee : "?");
+        for (i = 0; i < v->arg_count; ++i)
+            fprintf(out, "%s%%%u", i ? ", " : "", v->args[i]);
+        fputc(')', out);
+        break;
+    case FE_IR_COPY:
+        fputs("copy ", out);
+        dump_place(&v->place, out);
+        fputs(", ", out);
+        dump_place(&v->place2, out);
+        fprintf(out, ", %ld", v->imm);
+        break;
+    default:
+        fprintf(out, "%s %s %%%u, %%%u", fe_ir_op_name(v->op),
+                fe_ir_type_name(v->op >= FE_IR_EQ && v->op <= FE_IR_GE ?
+                                (FeIrType)v->imm : v->type), v->a, v->b);
+        if (v->is_unsigned) fputs(" u", out);
+        break;
+    }
+    fputc('\n', out);
+}
+
+void fe_ir_dump(const FeIrModule *m, FILE *out)
+{
+    const FeIrFunc *f;
+    const FeIrBlock *b;
+    const FeIrValue *v;
+    const FeIrGlobal *g;
+    unsigned i;
+    if (m->unit_file && m->unit_file[0])
+        fprintf(out, "; unit file %s\n", m->unit_file);
+    for (g = m->globals; g; g = g->next)
+        fprintf(out, "global @%s : %s %lu\n", g->name,
+                fe_ir_type_name(g->type), g->size);
+    for (f = m->funcs; f; f = f->next) {
+        if (f->is_extern) {
+            fprintf(out, "extern fn @%s -> %s\n", f->name,
+                    fe_ir_type_name(f->ret));
+            continue;
+        }
+        fprintf(out, "fn @%s -> %s%s {\n", f->name, fe_ir_type_name(f->ret),
+                f->returns_by_address ? " (by address)" : "");
+        for (i = 0; i < f->local_count; ++i) {
+            fprintf(out, "  $%u: %s", i, fe_ir_type_name(f->locals[i].type));
+            if (f->locals[i].type == FE_IR_MEM)
+                fprintf(out, "<%lu>", f->locals[i].size);
+            if (i < f->param_count) fputs("  ; parameter", out);
+            if (f->locals[i].name) fprintf(out, "  ; %s", f->locals[i].name);
+            fputc('\n', out);
+        }
+        for (b = f->first; b; b = b->next) {
+            fprintf(out, "  b%u:\n", b->id);
+            for (v = b->first; v; v = v->next) dump_value(v, out);
+            switch (b->term) {
+            case FE_IR_JMP:
+                fprintf(out, "    jmp b%u\n", b->target); break;
+            case FE_IR_BR:
+                fprintf(out, "    br %%%u, b%u, b%u\n", b->cond, b->target,
+                        b->target_else); break;
+            case FE_IR_RET:
+                if (b->has_ret_value) fprintf(out, "    ret %%%u\n", b->ret_value);
+                else fputs("    ret\n", out);
+                break;
+            case FE_IR_TRAP:
+                fprintf(out, "    trap %s %lu\n", trap_name(b->trap),
+                        b->trap_line);
+                break;
+            }
+        }
+        fputs("}\n", out);
+    }
+}

fec/src/ir.h

@@ -0,0 +1,177 @@
+#ifndef FE_IR_H
+#define FE_IR_H
+
+#include "arena.h"
+#include <stdio.h>
+
+/* The intermediate representation. `IR.md` is the description; this is the
+   shape it takes in memory.
+
+   Ferro types do not survive into here. A struct, a slice, an optional and an
+   error union are all `mem<N>`, and a field is a byte offset that lowering
+   worked out. The machine types are what a register can hold plus a size. */
+
+typedef enum FeIrType {
+    FE_IR_VOID,
+    FE_IR_I8, FE_IR_I16, FE_IR_I32,
+    FE_IR_PTR,
+    FE_IR_MEM          /* size lives on the value or slot */
+} FeIrType;
+
+typedef enum FeIrOp {
+    FE_IR_CONST, FE_IR_LOAD, FE_IR_STORE, FE_IR_ADDR,
+    FE_IR_ADD, FE_IR_SUB, FE_IR_MUL, FE_IR_DIV, FE_IR_MOD,
+    FE_IR_AND, FE_IR_OR, FE_IR_XOR, FE_IR_SHL, FE_IR_SHR,
+    FE_IR_EQ, FE_IR_NE, FE_IR_LT, FE_IR_LE, FE_IR_GT, FE_IR_GE,
+    FE_IR_CAST, FE_IR_CALL, FE_IR_COPY
+} FeIrOp;
+
+typedef enum FeIrTerm {
+    FE_IR_JMP, FE_IR_BR, FE_IR_RET, FE_IR_TRAP
+} FeIrTerm;
+
+/* Why a program stopped. Kept small and stable: it is a number in the
+   executable, and the runtime turns it back into words. */
+typedef enum FeIrTrap {
+    FE_TRAP_BOUNDS = 0,
+    FE_TRAP_OVERFLOW = 1,
+    FE_TRAP_DIVIDE = 2,
+    FE_TRAP_UNREACHABLE = 3,
+    FE_TRAP_EXPLICIT = 4
+} FeIrTrap;
+
+/* Where an instruction reads or writes. A place is a base plus a constant
+   offset; anything computed goes through a pointer temporary instead. */
+typedef enum FeIrBase {
+    FE_PLACE_LOCAL,    /* $n     */
+    FE_PLACE_GLOBAL,   /* @name  */
+    FE_PLACE_TEMP      /* %p     */
+} FeIrBase;
+
+typedef struct FeIrPlace {
+    FeIrBase base;
+    unsigned index;          /* local or temp number */
+    const char *name;        /* global name */
+    long offset;
+} FeIrPlace;
+
+typedef struct FeIrValue {
+    FeIrOp op;
+    FeIrType type;
+    unsigned dest;           /* %dest, or 0 when the op has no result */
+    int has_dest;
+    /* operands, by role -- only the ones the op uses are set */
+    unsigned a, b;           /* temporaries */
+    long imm;                /* const, cast width, copy size */
+    FeIrPlace place;         /* load / store / addr / copy destination */
+    FeIrPlace place2;        /* copy source */
+    const char *callee;
+    unsigned *args;
+    unsigned arg_count;
+    int is_unsigned;         /* picks the signed or unsigned instruction */
+    unsigned long line;      /* for diagnostics that survive into the backend */
+    struct FeIrValue *next;
+} FeIrValue;
+
+typedef struct FeIrFunc FeIrFunc;
+
+typedef struct FeIrBlock {
+    unsigned id;
+    FeIrFunc *func;          /* the function this block is being built in */
+    FeIrValue *first;
+    FeIrValue *last;
+    FeIrTerm term;
+    unsigned cond;           /* br */
+    unsigned target;         /* jmp, br true */
+    unsigned target_else;    /* br false */
+    unsigned ret_value;      /* ret */
+    int has_ret_value;
+    FeIrTrap trap;
+    unsigned long trap_line;
+    struct FeIrBlock *next;
+} FeIrBlock;
+
+typedef struct FeIrLocal {
+    FeIrType type;
+    unsigned long size;      /* for FE_IR_MEM */
+    unsigned align;
+    const char *name;        /* the Ferro name, for reading the dump */
+} FeIrLocal;
+
+struct FeIrFunc {
+    const char *name;        /* unit.name */
+    FeIrType ret;
+    unsigned long ret_size;  /* when ret is FE_IR_MEM */
+    /* A function returning mem<N> takes the address to write as a hidden
+       first parameter, so the caller owns the storage. */
+    int returns_by_address;
+    FeIrLocal *locals;
+    unsigned local_count;
+    unsigned local_capacity;
+    unsigned param_count;    /* the first `param_count` locals are parameters */
+    unsigned temp_count;
+    FeIrBlock *first;
+    FeIrBlock *last;
+    unsigned block_count;
+    int is_extern;
+    struct FeIrFunc *next;
+};
+
+typedef struct FeIrGlobal {
+    const char *name;
+    FeIrType type;
+    unsigned long size;
+    unsigned align;
+    const unsigned char *init;   /* size bytes, or null for zero */
+    struct FeIrGlobal *next;
+} FeIrGlobal;
+
+typedef struct FeIrModule {
+    FeArena arena;
+    const char *unit_file;   /* the one file-name string a unit's traps share */
+    FeIrFunc *funcs;
+    FeIrFunc *last_func;
+    FeIrGlobal *globals;
+    FeIrGlobal *last_global;
+} FeIrModule;
+
+void fe_ir_module_init(FeIrModule *m);
+void fe_ir_module_destroy(FeIrModule *m);
+
+FeIrFunc *fe_ir_func(FeIrModule *m, const char *name, FeIrType ret,
+                     unsigned long ret_size);
+unsigned fe_ir_local(FeIrModule *m, FeIrFunc *f, FeIrType type,
+                     unsigned long size, unsigned align, const char *name);
+unsigned fe_ir_temp(FeIrFunc *f);
+FeIrBlock *fe_ir_block(FeIrModule *m, FeIrFunc *f);
+
+/* Places */
+FeIrPlace fe_ir_at_local(unsigned index, long offset);
+FeIrPlace fe_ir_at_global(const char *name, long offset);
+FeIrPlace fe_ir_at_temp(unsigned temp, long offset);
+
+/* Instructions. Each returns the destination temporary where there is one. */
+unsigned fe_ir_const(FeIrModule *m, FeIrBlock *b, FeIrType t, long v);
+unsigned fe_ir_load(FeIrModule *m, FeIrBlock *b, FeIrType t, FeIrPlace p);
+void     fe_ir_store(FeIrModule *m, FeIrBlock *b, FeIrPlace p, unsigned v);
+unsigned fe_ir_addr(FeIrModule *m, FeIrBlock *b, FeIrPlace p);
+unsigned fe_ir_binary(FeIrModule *m, FeIrBlock *b, FeIrOp op, FeIrType t,
+                      unsigned a, unsigned c, int is_unsigned);
+unsigned fe_ir_cast(FeIrModule *m, FeIrBlock *b, FeIrType from, FeIrType to,
+                    unsigned a, int is_unsigned);
+unsigned fe_ir_call(FeIrModule *m, FeIrBlock *b, FeIrType ret,
+                    const char *callee, unsigned *args, unsigned count);
+void     fe_ir_copy(FeIrModule *m, FeIrBlock *b, FeIrPlace dst, FeIrPlace src,
+                    unsigned long size);
+
+/* Terminators */
+void fe_ir_jmp(FeIrBlock *b, unsigned target);
+void fe_ir_br(FeIrBlock *b, unsigned cond, unsigned t, unsigned f);
+void fe_ir_ret(FeIrBlock *b, unsigned value, int has_value);
+void fe_ir_trap(FeIrBlock *b, FeIrTrap reason, unsigned long line);
+
+void fe_ir_dump(const FeIrModule *m, FILE *out);
+const char *fe_ir_type_name(FeIrType t);
+const char *fe_ir_op_name(FeIrOp op);
+
+#endif

tests/run.py

@@ -34,7 +34,7 @@ ROOT = Path(__file__).resolve().parent.parent
 FIXTURES = ROOT / "fec" / "tests"
 WATCOM = ROOT / ".dosboxx" / "watcom"
 SOURCES = ("arena", "diag", "lexer", "ast", "parser", "types", "m7", "own",
-           "check", "resolve", "driver")
+           "check", "resolve", "ir", "driver")
 # Fixtures live here until there is a code generator to run them against.
 QUARANTINE = "pending-backend"