diff --git a/IR.md b/IR.md new file mode 100644 index 0000000..856e1be --- /dev/null +++ b/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 +``` + +Ferro 타입은 여기서 사라진다. 구조체·배열·슬라이스·옵셔널·에러 유니온은 전부 +`mem` 이고, 필드 접근은 lowering 이 계산한 **바이트 오프셋**이다. IR 은 +`Box(i32)` 라는 것을 모른다 — 크기 N 바이트짜리 메모리만 안다. + +`ptr` 은 4바이트다. 세그먼트가 없으므로 포인터 종류도 하나뿐이다 (`SPEC.md` §2). + +`bool` 은 `i8`, `char` 는 `i8`, `usize` 는 `i32` 다. + +--- + +## 2. 명령 + +12개다. + +``` +%d = const 상수 +%d = load 메모리에서 읽는다 + store , %v 메모리에 쓴다 +%d = addr 주소를 뜬다 +%d = %a, %b 산술·비트 연산 +%d = %a, %b 비교. 결과는 i8 +%d = cast %a 정수 폭 변환 +%d = call @f(%a, ...) 호출 + copy , , N N바이트 복사 +``` + +`` — `add sub mul div mod and or xor shl shr` +`` — `eq ne lt le gt ge` (부호 있음/없음은 `` 가 정한다) + +### place + +`load`·`store`·`addr`·`copy` 의 피연산자다. + +``` +$n 지역 +@name 전역 +%p 포인터 임시값이 가리키는 곳 +%p + 상수 오프셋. 필드 접근이 여기로 온다 +``` + +인덱스처럼 오프셋이 상수가 아니면 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 을 받으면 %p 는 그 주소다 +``` + +반환도 같다. `mem` 을 반환하는 함수는 **첫 인자로 결과를 쓸 주소를 받는다**. +호출자가 자리를 잡고 넘긴다. + +이 규약을 고른 이유는 단순해서만이 아니다. ISA 마다 다른 "구조체를 언제 +레지스터로 넘기는가" 규칙을 통째로 피해간다. `extern "c"` 경계에서는 C ABI 로 +변환해야 하며 그것은 백엔드의 일이다. + +--- + +## 3. 종결자 + +4개다. + +``` +jmp b 무조건 분기 +br %c, b, b %c 가 0이 아니면 b +ret [%v] 반환 +trap 중단 +``` + +`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(, ...) -> { ... } +extern fn @name(, ...) -> +global @unit.name : mem = <초기값 바이트> +``` + +이름은 `유닛.이름` 이다. 제네릭 인스턴스도 여기서는 그냥 함수 하나다 — +모노모피제이션이 프론트엔드에서 끝나므로 **IR 에 제네릭이라는 개념이 없다.** + +--- + +## 5. 이 IR 이 하지 않는 것 + +- **최적화 없음.** 상수 접기도, 죽은 코드 제거도 없다. 나중에 붙일 자리는 있다 +- **φ 노드 없음.** 블록 간 값은 지역을 경유한다 +- **타입 검사 없음.** 검사는 프론트엔드에서 끝났다. IR 이 잘못되었다면 lowering 의 버그다 +- **예외·언와인딩 없음.** 에러는 값이고, `try` 는 분기다 + +--- + +## 6. 왜 이 크기인가 + +명령 12개와 종결자 4개는 **i386 으로 직접 번역할 수 있는 최소 집합**이다. +각각이 몇 개의 x86 명령으로 내려가고, 그 대응이 눈으로 확인된다. 이보다 높으면 +백엔드가 IR 을 다시 해석해야 하고, 이보다 낮으면 lowering 이 기계에 가까워져서 +다른 ISA 로 옮길 때 다시 써야 한다. + +같은 이유로 이 집합은 m68k·ARM·MIPS·RV32 에도 그대로 내려간다. 평평한 주소 +공간과 정수 연산만 쓰기 때문이다. 백엔드를 하나 더 만드는 비용은 명령 선택과 +레지스터 할당이지 IR 재설계가 아니다. diff --git a/TODO.md b/TODO.md index 828d202..0d5f8d3 100644 --- a/TODO.md +++ b/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번이 정해져야 확정 | -| 7 | **lowering** | 대 | `try`/`catch`/`defer`/drop/`for`/메서드/경계검사 전개. **프로젝트 무게중심** | -| 8 | i386 백엔드 | 대 | IR → x86 asm → `wasm` → `wlink`. W11 에서 실행 검증 | -| 9 | 런타임 최소 세트 | 소~중 | 시작 스텁, `fe_trap`, `malloc`/`free` | -| 10 | `pending-backend/` 3개 복귀 | 소 | bounds trap, `--no-checks` 차등, 소유권 drop | +| 1 | **IR 정의** | 중 | 3-address, 기본 블록, 함수 단위. 명령 12 + 종결자 4 | +| 2 | **lowering** | 대 | `try`/`catch`/`orelse`/`defer`/drop/`for`/메서드/경계검사/옵셔널·에러유니온 구성/제네릭 인스턴스 전개. **프로젝트 무게중심** | +| 3 | i386 백엔드 | 대 | IR → x86 asm → `wasm` → `wlink` → PE. 명령 선택, 레지스터 할당, 호출 규약 | +| 4 | 런타임 | 소~중 | 시작 스텁, `fe_trap(reason, file, line)`, 할당, 종료 | +| 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번에 의존 | -| 12 | bits16 백엔드 | 대 | `DX:AX` 32비트 산술, 세그먼트. 제일 어려움. 마지막 | -| 13 | 타깃 의존 구문 | 중 | `far` `asm` `interrupt` `atomic` `critical` `shared` — 파싱만 되고 의미 없음. fixture 도 없음 | +| | | | +|---|---|---| +| 셀프호스팅 | 대 | `fec` 을 Ferro 로. 여기까지 오면 언어가 자기 무게를 견딘다는 증거 | +| 인터럽트·공유 상태 | 중 | `interrupt` `shared` `atomic` `critical` — 파싱만 되고 의미 없음. SPEC §11 에서 v0.2 | +| 다른 32비트 타깃 | 대 | m68k / ARM / MIPS / RV32. IR 결정은 전부 ISA 중립이라 백엔드만 붙이면 됨 | --- @@ -40,27 +33,32 @@ | | 내용 | 언제 | |---|---|---| -| 덩어리 전달 규약 | 정함 (전부 주소로). 8번 착수 전 재확인 | 8 전 | -| `extern` C 상호운용 | 위 규약이 C ABI 와 안 맞음. 경계 변환 필요 | 8 전 | -| 주 타깃 | i386/W11 로 기울었으나 SPEC §1.2 는 아직 "640KB 셀프호스팅" | 아무 때나 | -| stdlib 명세 | SPEC §10 이 플레이스홀더. 시그니처·오류·경계 동작 미정 | 11 전 | -| `far` 의 거취 | IR 에 안 두기로 함. 언어에서 뺄지 bits16 전용으로 둘지는 미정 | 12 전 | +| 덩어리 전달 규약 | 정함 (전부 주소로). 3번 착수 전 재확인 | 3 전 | +| `extern` C 상호운용 | 위 규약이 C ABI 와 안 맞음. 경계 변환 필요 | 3 전 | +| 엔디안 | 리틀엔디안 가정. `packed struct` 가 바이트 배치를 약속하므로, 빅엔디안 타깃(m68k·MIPS·POWER)이 생기면 타깃 파라미터가 된다 | 다른 타깃 전 | +| stdlib 명세 | SPEC §10 이 플레이스홀더 | 6 | + +## 정해진 것 + +| | | +|---|---| +| 타깃 | **i386 하나.** 세그먼트 없음, `far` 영구 제외 (SPEC §2) | +| `usize`/`isize` | **타깃의 포인터 폭.** 비트 수를 약속하지 않으므로 64비트 문이 닫히지 않음 | +| 제네릭 | 모노모피제이션. 순수 프론트엔드 기능이라 IR 에 제네릭 개념이 없음 | +| 덩어리 전달 | 전부 주소로. 크기 임계값 없음 — ISA 마다 다른 구조체 전달 ABI 를 피해감 | +| 트랩 | `trap ` → `fe_trap(reason, UNIT_FILE, line)`. 유닛당 파일 문자열 하나 | +| 셀프호스팅 | 640KB 목표 아님. 32비트 보호모드에서 돈다 (SPEC §2.1) | --- ## 순서 ``` -1 → 2 → 3 프론트엔드 유닛 완성 -4 제네릭. ← 여기서 IR 형태가 결정됨 -6 → 7 IR + lowering -8 → 9 → 10 i386 백엔드, 실행 검증 복귀 -11 stdlib -12 → 13 DOS 고유 +1 → 2 IR + lowering +3 → 4 → 5 i386 백엔드, 런타임, 실행 검증 복귀 ← 여기서 처음 실행됨 +6 → 7 stdlib ``` -5번은 독립적이라 아무 때나 끼워 넣는다. - --- ## 위임 정책 @@ -73,43 +71,12 @@ **위임 불가** — 언어 의미론 판단이 섞인 것 -- 마커 판정, cross-unit 해석, 가시성, 제네릭, IR/lowering/백엔드 +- 마커 판정, IR/lowering/백엔드, stdlib 명세 --- -## 5번에 대하여 (마커 없는 fixture 37개) +## 미뤄둔 정리 작업 -거부 fixture 76개 중 **37개에 `// ERROR:` 마커가 없다.** 마커가 없으면 러너는 -"거부되기만 하면 통과" 로 판정한다. 즉 **엉뚱한 이유로 거부돼도 초록이다.** - -``` -format 10 own 8 types 19 -``` - -마커를 붙이려면 fixture 마다 "지금 나오는 진단이 옳은가" 를 판정해야 하고, -그 판정은 세 갈래로 갈린다. 오늘 5건을 조사했을 때 실제로 셋 다 나왔다: - -| 결론 | 예 | 조치 | -|---|---|---| -| 마커가 틀렸다 | `badbrmov` 한 줄 밀림 | 마커 수정 | -| 마커가 언어를 오해했다 | `badloop` — 루프 안에서 이미 걸림 | 마커 수정 | -| **진단이 부실하다** | `badweak` — "type mismatch" 로만 나옴 | **컴파일러 수정** | - -세 번째 때문에 위임이 위험하다. 실제 출력을 마커에 그대로 베끼면 전부 초록이 -되지만 **컴파일러가 틀린 곳까지 정답으로 굳는다.** - -### 병렬화 - -판정 자체는 **fixture 간 독립**이라 병렬 가능하다. 다만 **판정을 위임하면 안 된다.** -쓸 수 있는 형태는 증거 수집과 판정을 나누는 것이다: - -``` -위임: fixture 를 열고 → fec 를 돌리고 → 다음을 보고 - 파일 경로 / 검사하려는 것으로 보이는 규칙 / 실제 진단 전문(줄·문구) - 마커는 만들지 않는다 - -직접: 보고를 읽고 세 갈래 중 무엇인지 판정 → 마커를 쓰거나 컴파일러를 고침 -``` - -이러면 37개를 디렉터리별로 병렬로 뿌려 증거를 모으고, 판정만 직접 하면 된다. -느린 부분(파일 읽기·실행·정리)이 병렬화되고 위험한 부분은 남는다. +fixture 122개 이름이 아직 DOS 8.3 시절 잔재라 무엇을 검사하는지 이름만으로는 +알 수 없다. 마커가 전부 붙었으므로 `bad`/`ok` 접두사는 이제 기대값이 아니고, +자유롭게 이름을 지을 수 있다. 급하지 않다. diff --git a/fec/src/ir.c b/fec/src/ir.c new file mode 100644 index 0000000..bff4452 --- /dev/null +++ b/fec/src/ir.c @@ -0,0 +1,408 @@ +#include "ir.h" +#include + +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); + } +} diff --git a/fec/src/ir.h b/fec/src/ir.h new file mode 100644 index 0000000..9f10834 --- /dev/null +++ b/fec/src/ir.h @@ -0,0 +1,177 @@ +#ifndef FE_IR_H +#define FE_IR_H + +#include "arena.h" +#include + +/* 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`, 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 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 diff --git a/tests/run.py b/tests/run.py index ff66496..aa53325 100644 --- a/tests/run.py +++ b/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"