30 하드웨어 — 레지스터, 인터럽트, 기계 명령

30.1 레지스터 지도#

module gpio_demo .
rem run: drive 0 [0,0,0,0,7,0,0,0,0,0,0,0]

build tier t1 .

struct gpio do
  mmio 0x40020000 .
  moder u32 rw .
  idr u32 ro .
  bsrr u32 wo .
end

unsafe proc drive
  input dev cap mmio .
  input regs mut slice u8 .
  output u32 .
  effects device unsafe .
do
  var g gpio be view gpio regs .
  write_volatile g moder 2 .
  write_volatile g bsrr 1 .
  return read_volatile g idr .
end

$ lowentc --run drive gpio.low 0 [0,0,0,0,7,0,0,0,0,0,0,0]
drive(0, [2,0,0,0,7,0,0,0,1,0,0,0]) = 7
  arg1 (written) = [2,0,0,0,7,0,0,0,1,0,0,0]

• struct gpio do mmio 0x40020000 . … end 는 장치의 지도다. mmio 뒤의 수가 시작 주소이고, 칸들이 차례로 레지스터가 된다. 새 낱말은 없다. 구조체에 절 하나가 붙었을 뿐이다.
• 칸 뒤의 rw·ro·wo 가 닿는 법이다.
• read_volatile·write_volatile 이 레지스터에 닿는다. 처리기는 이 접근을 합치거나 없애거나 차례를 바꾸지 않는다. 장치 레지스터는 읽는 행위 자체가 일이라서, 읽으면 상태가 바뀌기도 한다.
• 레지스터에 닿으려면 cap mmio 를 받고 effects device 를 적는다. 권한 없는 하드웨어 접근은 할당기에서 본 주변 권한과 정확히 같은 문제다.
• build tier t1 . 은 이 모듈이 작은 기계용이라는 선언이다(아래에서 다룬다).

VM 에서는 이것이 실제로 돈다. 장치 대신 호출자가 건넨 바이트 버퍼가 레지스터 자리가 되고, view gpio regs 가 그 위에 지도를 얹는다. 실행 결과의 인자 모습 [2,0,0,0,7,0,0,0,1,0,0,0] 에서 moder 에 2, bsrr 에 1 이 쓰였고 idr 의 7 이 읽혀 돌아온 것을 볼 수 있다. 실행 인자의 첫 0 은 cap mmio 자리를 채우는 자리표다.

지도와 버퍼를 겹쳐 그리면 이렇다. 칸이 선언 차례로 4 바이트씩 놓인다.

 주소         칸     닿는 법  VM 에서 (u32 하나 = 4 바이트)
 0x40020000   moder  rw       [ 2 0 0 0 ]  ◀── write_volatile g moder 2
 0x40020004   idr    ro       [ 7 0 0 0 ]  ──▶ read_volatile g idr = 7
 0x40020008   bsrr   wo       [ 1 0 0 0 ]  ◀── write_volatile g bsrr 1

30.2 닿는 법은 번역에서 강제된다#

읽기 전용 레지스터에 쓰면 거절된다.

module ro_write .
rem expect: E-MMIO-PERM

struct gpio do
  mmio 0x40020000 .
  moder u32 rw .
  idr u32 ro .
end

unsafe proc poke input dev cap mmio . input regs mut slice u8 . output u32 . effects device unsafe .
do
  var g gpio be view gpio regs .
  write_volatile g idr 1 .
  return 0 .
end

$ lowentc --check ro_write.low
ro_write.low:13:0 E-MMIO-PERM: this register is READ-ONLY (`ro`) — writing it is a compile error, not a runtime surprise (RFC-0042 D3). The device says what it will accept; the type says it back

쓰기 전용 레지스터를 읽는 것도 같다. 쓰기 전용 레지스터를 읽으면 쓰레기가 나오거나 읽는 행위가 장치를 움직인다. 그 읽기는 쓸모없는 것이 아니라 틀린 것이다. 장치가 무엇을 받아들이는지 말했으면 타입이 그것을 되말한다.

장치를 값으로 받을 수도 없다.

module byvalue .
rem expect: E-MMIO-BYVALUE

struct gpio do
  mmio 0x40020000 .
  moder u32 rw .
end

unsafe proc setup input dev cap mmio . input g gpio . output u32 . effects device unsafe .
do
  write_volatile g moder 2 .
  return 0 .
end

$ lowentc --check byvalue.low
9:0 E-MMIO-BYVALUE: an `mmio` register block cannot be a by-value parameter. A struct parameter is COPIED, and copying a device means reading EVERY register at once — including the `wo` ones, whose reads D3 promises to reject at compile time, at a moment the program never wrote. A register block is a DEVICE, not a value: pass the view instead (RFC-0042 D3 · §8-4)

구조체 매개변수는 복사된다. 장치를 복사한다는 것은 쓰기 전용까지 포함한 모든 레지스터를 한꺼번에 읽는다는 뜻이고, 복사본에 쓰는 일은 장치에 닿지 않는다. 그렇게 쓰인 프로그램은 아무 일도 하지 않으면서 아무 말도 하지 않는다. 그래서 번역에서 막는다. 레지스터 묶음은 슬라이스에 view 로 얹어 다룬다. 운영체제가 있는 기계에서 절대 주소를 열려고 하면 E-MMIO-NOHOST 로 거절된다 — 그 주소는 장치가 아니다.

30.3 인터럽트 처리기#

op 에 vector <번호> . 절을 붙이면 그 op 은 인터럽트 처리기가 된다. 급함은 priority <수> . 로 적는다.

module isr .
rem flags: --target cortex_m

proc on_exti
  vector 6 .
  priority 2 .
  output void .
  effects device .
do
  return .
end

$ lowentc --check isr.low
== check: ok ==

이 예제는 --target cortex_m 으로 검사한다. 인터럽트 처리기는 기계가 부르므로 넷을 지킨다.

module isr_called .
rem expect: E-ISR-CALLED

proc on_exti
  vector 6 .
  output void .
  effects device .
do
  return .
end

proc impatient output void . effects device .
do
  on_exti .
end

$ lowentc --check isr_called.low
isr_called.low:14:0 E-ISR-CALLED: nobody calls an interrupt handler — the HARDWARE does. Calling it from Lowent code runs it on the wrong stack, at the wrong priority, with interrupts in the wrong state (RFC-0042 D5)

인터럽트 처리기와 보통 코드가 나누어 쓰는 상태는 우선순위와 큐의 규율로 오간다. 그 규율은 언어가 아니라 라이브러리의 일이다. 락 없이 한 생산자와 한 소비자가 값을 넘기는 spsc 링 버퍼가 그 자리에 쓰인다(34장).

30.4 기계가 감당하는 것 — build tier#

build tier <이름> . 은 이 기계가 무엇을 감당하는가를 말한다. 등급마다 쓸 수 있는 효과가 정해져 있다.

module tier .
rem expect: E-TIER-EFFECT

build tier t1 .

proc scratch input al cap allocator . output u64 . effects alloc .
do
  let g option mut slice u8 be alloc_bytes al capacity 16 .
  guard is_some g . else return 0 .
  return len (some_value g) .
end

$ lowentc --check tier.low
tier.low:6:0 E-TIER-EFFECT: this effect is not available at the declared concurrency TIER. The tier says what the HARDWARE CAN CARRY — a thread pool on an ATtiny is not a runtime problem, it is a COMPILE ERROR (RFC-0039 D4). And because effects PROPAGATE along the call chain, the refusal lands where you CALL it, not at link time

t1 기계에서 할당(alloc)은 감당하지 못한다고 선언했으므로 거절된다. 이것은 실행 중에 느려지는 문제가 아니라 애초에 그 기계에 실을 수 없는 것이다. 효과는 부르는 사슬을 따라 올라오므로, 거절은 효과가 처음 생긴 자리가 아니라 부르는 자리에서도 난다. 등급을 적지 않으면 t3 이고 아무것도 막지 않는다.

등급(무엇을 감당하는가)과 프로파일(25장 — 어떤 동시성 짜임을 쓰는가)은 다른 축이다. 운영체제가 있는 작은 기계도 있고, 없는 큰 기계도 있다.

30.5 기계 명령 — asm#

특권 명령, 시스템 호출, 정확한 사이클 수처럼 이식 가능한 코드로 닿지 못하는 것이 있다. 그 자리에서 op 의 몸을 기계 명령으로 쓴다.

module asm_add .

unsafe proc add_native
  input k cap machine .
  input a u64 .
  input b u64 .
  output u64 .
  effects unsafe .
  asm x86_64 .
    reg a .
    reg b .
    out reg r .
    clobber flags .
    options pure nomem nostack .
do
  text ASM
    mov {a}, {r}
    add {b}, {r}
  ASM
end

$ lowentc --check asm.low
== check: ok ==

• asm x86_64 . 절이 기계를 정한다. 지금 짓는 기계와 다른 기계의 어셈블리는 거절된다. 처리기는 이식되는 척하지 않는다.
• reg a . 는 입력 a 를 레지스터에 싣고, out reg r . 은 결과를 받는다. clobber flags . 는 망가뜨리는 것을, options … 는 처리기에게 주는 약속을 적는다.
• 몸은 text ASM … ASM 이음글 하나다. 어셈블리와 보통 코드를 섞을 수 없다.
• 가둠은 넷이다 — unsafe 표시, cap machine, effects unsafe, 기계 이름.

처리기는 템플릿 안을 읽지 못한다. 그러나 피연산자 목록과 템플릿의 {이름} 은 같은 것을 말하는 두 표현이므로 양쪽으로 맞대어 검사한다.

module asm_unbound .
rem expect: E-ASM-UNBOUND

unsafe proc add_native
  input k cap machine .
  input a u64 .
  input b u64 .
  output u64 .
  effects unsafe .
  asm x86_64 .
    reg a .
    reg b .
    out reg r .
    clobber flags .
do
  text ASM
    mov {a}, {r}
    add {c}, {r}
  ASM
end

$ lowentc --check asm_unbound.low
asm_unbound.low:4:0 E-ASM-UNBOUND: the template names an operand the `asm` clause never declared — the assembler would either reject it or, worse, read WHATEVER register happens to be there

선언하지 않은 {c} 를 템플릿이 부르면 어셈블러는 그것을 거절하거나, 더 나쁘게는 그 자리에 있던 레지스터를 그냥 읽는다. 반대로 선언한 피연산자를 템플릿이 쓰지 않아도 거절된다(E-ASM-UNUSED). options pure 는 “곁효과가 없다” 는 약속이라 처리기가 그것을 믿고 호출을 지우거나 합칠 수 있는데, 효과 줄이 입출력이나 장치를 만진다고 말하면 둘 다 참일 수 없으므로 거절된다 (E-ASM-OPTLIE). VM 은 기계 명령을 돌리지 못하고 못 돌린다고 말한다(E-VM-ASM). 네이티브에서만 돈다.

30.6 흡수 경계 — unsafe 가 멈추는 자리#

앞 절의 가둠 넷에는 대가가 하나 딸려 온다. effects unsafe 는 부름을 따라 끝까지 번진다. 어셈블리 잎을 한 줄 쓰면 그것을 부른 op 도, 그 op 을 부른 op 도 차례로 unsafe 를 적어야 한다. 표준 라이브러리에서 기계 명령이 한 번도 안 쓰인 까닭이 그것이다(2026-09-23 실측: lib/ 예순네 모듈에서 asm 사용 0).

번짐 자체는 옳다. 처리기가 못 보는 일을 부르는 쪽이 모르면 효과 줄은 거짓말이 된다. 빠진 것은 책임을 넘겨받는 자리였다.

export proc add2 input a u64 . input b u64 . output u64 . effects none .
  absorbs machine k .          rem 여기서 멈춘다. `k` 가 이 몸 안의 `cap machine` 이다
  reference add2_soft .        rem 같은 답을 내야 하는 순수한 판
  why "레지스터 둘을 더할 뿐 메모리를 만지지 않는다(options pure nomem nostack)." .
  requires ge a 0 .
do
  return asm_add2 k a b .
end

• 이 op 을 부르는 쪽은 아무것도 적지 않는다. 그것이 흡수의 값이다.
• absorbs machine <이름> 은 그 이름을 몸 안의 cap machine 으로 만든다. 그 권한이 태어나는 자리가 여기다 — 시작점이 받는 권한 목록에 machine 은 없다.
• 흡수할 수 있는 것은 machine 하나뿐이다. 입출력·씨·무더기처럼 세상에 닿는 권한은 흡수하지 못한다(E-ABSORB-SCOPE). 그런 권한을 만들어 내면 부르는 쪽이 못 본 권위가 생긴다.

부름 사슬로 그리면 차이가 이렇다.

 흡수 없이                                 흡수와 함께
 main      effects unsafe  ▲               main      (적을 것 없음)
 add2      effects unsafe  │ 위로 번진다   add2      absorbs machine k ◀ 여기서 멈춘다
 asm_add2  effects unsafe  │               asm_add2  effects unsafe

갖추지 않으면 거절된다. 효과 줄이 none 이 아니면 E-ABSORB-IMPURE, 참조 구현이 없으면 E-ABSORB-NOREF, 계약(requires)이 없으면 E-ABSORB-NOCONTRACT, 근거(why)가 비었으면 E-ABSORB-NOWHY 다.

누가 흡수해도 되는가는 매니페스트가 정한다. 흡수는 «사람이 보증한다» 는 말이므로, 그 권리를 원하는 소스가 스스로에게 줄 수 없다. pkg.low 에 build absorb <모듈> . 로 적힌 모듈만 쓸 수 있고, 적히지 않으면 E-ABSORB-PLACE 다. 매니페스트가 아예 없으면 아무도 흡수하지 못한다.

도구가 그 자리를 말한다. lowentc --absorbs f.low 는 어느 op 이 무엇을 흡수했고 근거가 무엇인지 한 줄씩 낸다. 못 보는 구역은 숨기는 것이 아니라 보이게 둔다.

  add2                      absorbs machine as `k`  ref=add2_soft  line 40
      why: 레지스터 둘을 더할 뿐 메모리를 만지지 않는다…
absorbs: 1 op(s) stop `unsafe` here

타이밍은 적어 두는 것이다. 값에 따라 시간이 달라지는지는 도구가 확인하지 못한다. 그래서 흡수 장부의 타이밍 칸에 사람이 적고, 비워 두면 검사가 통과시키지 않는다 — «모른다» 도 답이다.

30.7 기계가 가진 것을 쓸까 — --hw#

기계 명령을 쓸지는 짓는 사람이 정한다.

담는 것은 셈을 대신하는 명령만이 아니다. sse2 · avx2 가 주는 것은 폭이다 — 서로 독립인 일 넷·여덟을 한 레지스터에 나란히 싣는 자리이고, ChaCha20 의 블록들이 바로 그런 모양이다. 규칙은 같다: 답은 같고, 없는 기계에는 담지 못하며, VM 은 언제나 평범한 코드로 돈다.

• 어느 쪽을 고르든 답은 같다. 다른 것은 빠르기와 타이밍 성질뿐이다 — 표를 읽는 셈은 읽는 자리가 값에 달렸고, 이 명령들은 그렇지 않다.
• 기계에 없는 명령을 담으라고 적으면 번역이 거절된다(E-HW-TARGET). 조용히 평범한 코드로 바꾸지 않는다 — 무엇이 돌지 짓는 사람이 알아야 한다.
• VM 은 언제나 평범한 코드로 돈다. 그래서 «VM 과 네이티브가 같은 답인가» 라는 이 저장소의 오라클이 곧 기계 경로의 시험이 된다.

30.8 흔한 실수#

module mistake_woread .
rem expect: E-MMIO-PERM

struct gpio do
  mmio 0x40020000 .
  moder u32 rw .
  idr u32 ro .
  bsrr u32 wo .
end

unsafe proc last_set input dev cap mmio . input regs mut slice u8 . output u32 . effects device unsafe .
do
  var g gpio be view gpio regs .
  rem ✘ 방금 무엇을 썼는지 확인하려고 쓰기 전용 레지스터를 읽는다
  return read_volatile g bsrr .
end

$ lowentc --check mistake_woread.low
mistake_woread.low:15:0 E-MMIO-PERM: this register is WRITE-ONLY (`wo`) — reading it is a compile error. A wo register often reads as garbage (or has a read side effect), so the read is not merely useless: it is wrong

module mistake_isrparams .
rem flags: --target cortex_m
rem expect: E-ISR-PARAMS

rem ✘ 몇 번 핀이 울렸는지 인자로 받으려 한다 --- 기계는 인자를 건네지 않는다
proc on_exti
  vector 6 .
  input pin u32 .
  output void .
  effects device .
do
  return .
end

$ lowentc --check --target cortex_m mistake_isrparams.low
mistake_isrparams.low:6:0 E-ISR-PARAMS: an interrupt handler takes NO parameters — the HARDWARE calls it, and hardware does not pass arguments. Shared state goes through the priority/queue discipline (RFC-0039 D1c), not through a parameter list

module mistake_isreffect .
rem flags: --target cortex_m
rem expect: E-ISR-EFFECT

rem ✘ 할 일이 아직 없어 효과 줄을 비웠다
proc on_exti
  vector 6 .
  output void .
do
  return .
end

$ lowentc --check --target cortex_m mistake_isreffect.low
mistake_isreffect.low:6:0 E-ISR-EFFECT: an interrupt handler must declare `effects device` — it exists because the device asked for it

module mistake_asmtarget .
rem expect: E-ASM-TARGET-UNKNOWN

unsafe proc add_native
  input k cap machine .
  input a u64 .
  input b u64 .
  output u64 .
  effects unsafe .
  rem ✘ 기계 이름을 다른 도구의 철자(`aarch64`)로 적었다 --- 이 처리기의 이름은 `arm64` 다
  asm aarch64 .
    reg a .
    reg b .
    out reg r .
do
  text ASM
    add {r}, {a}, {b}
  ASM
end

$ lowentc --check mistake_asmtarget.low
mistake_asmtarget.low:4:0 E-ASM-TARGET-UNKNOWN: this `asm` clause names something that is not a build target. The names are a CLOSED set — the target table is the authority (x86_64 · arm64 · cortex_m · riscv64 · mips_be). A name outside it matches NO build, so the op would be silently dropped or silently mis-built; both are what this RFC exists to prevent

module mistake_plainfield .
rem expect: E-MMIO-PLAIN

struct gpio do
  mmio 0x40020000 .
  moder u32 rw .
  idr u32 ro .
  bsrr u32 wo .
end

unsafe proc drive input dev cap mmio . input regs mut slice u8 . output u32 . effects device unsafe .
do
  var g gpio be view gpio regs .
  rem ✘ 레지스터를 보통 칸처럼 쓰고 읽는다 --- 합치거나 지워도 되는 접근으로 읽힌다
  set (field g moder) 2 .
  return field g idr .
end

$ lowentc --check mistake_plainfield.low
mistake_plainfield.low:15:0 E-MMIO-PLAIN: this is a DEVICE register, and this reads/writes it like ordinary memory. An ordinary access is one the translator may merge or delete (two reads of the same field become one; a store nothing reads goes away) — for a device the access ITSELF is the work, so deleting it makes the hardware do the wrong thing. Write `read_volatile <block> <reg>` or `write_volatile <block> <reg> <value>`, which say exactly once, in the written order (RFC-0042 D1). The `ro`/`wo` permission is checked there too

30.9 이 장의 문법 한눈에#