mie: implement block dominance calculation using lengauer-tarjan algorithm

the new rewriter interface supports running patterns over an Op's children
matching Ops that conform to a pattern, and rewriting Ops in arbitrary ways.

.clang-format

@@ -0,0 +1,60 @@
+BasedOnStyle: WebKit
+IndentWidth: 8
+---
+Language: Cpp
+DerivePointerAlignment: false
+PointerAlignment: Right
+ColumnLimit: 80
+AlignAfterOpenBracket: AlwaysBreak
+AlignConsecutiveAssignments: None
+AlignConsecutiveBitFields: None
+AlignConsecutiveDeclarations: None
+AlignConsecutiveMacros: AcrossEmptyLinesAndComments
+AlignEscapedNewlines: Right
+AlignOperands: AlignAfterOperator
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: false
+AllowAllConstructorInitializersOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: Empty
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLambdasOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: Yes
+BinPackArguments: true
+BinPackParameters: true
+ExperimentalAutoDetectBinPacking: false
+BitFieldColonSpacing: Both
+BreakBeforeBraces: Linux
+BreakBeforeBinaryOperators: All
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: BeforeComma
+BreakInheritanceList: BeforeComma
+BreakStringLiterals: true
+ContinuationIndentWidth: 8
+Cpp11BracedListStyle: true
+IncludeBlocks: Regroup
+SortIncludes: true
+IndentRequires: true
+NamespaceIndentation: Inner
+ReflowComments: true
+SpacesBeforeTrailingComments: 3
+TabWidth: 8
+UseTab: AlignWithSpaces
+PenaltyReturnTypeOnItsOwnLine: 1000000
+PenaltyExcessCharacter: 5
+PenaltyBreakOpenParenthesis: 5
+PenaltyBreakBeforeFirstCallParameter: 5
+PenaltyIndentedWhitespace: 0
+AttributeMacros:
+  - BLUELIB_API
+ForEachMacros:
+  - b_btree_foreach
+  - b_queue_foreach
+MacroBlockBegin: "MIE_.*_BEGIN"
+MacroBlockEnd: "MIE_.*_END"

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.14)
 project(mie C)
 
 if (WIN32)

doc/sample/for-loop-3.mie

@@ -1,19 +0,0 @@
-*func.func(%buffer, %lb, %ub, %step) ({
-	; Initial sum set to 0.
-	%sum.0 = *arith.constant() {value = 0.0 : f32} : () -> f32
-
-	; iter_args binds initial values to the loop's region arguments.
-	%sum = *scf.for(%lb, %ub, %step) -> (f32) {
-	^for.entry(%iv: index, %sum.iter: f32):
-		%t = *memref.load(%buffer, %iv) : (memref<1024*f32>, index) -> f32
-		%sum.next = *arith.addf(%sum.iter, %t) : (f32, f32) -> f32
-		; Yield current iteration sum to next iteration %sum.iter or to %sum
-		; if final iteration.
-		%iv.next = *arith.addi(%iv, %step) : (index, index) -> index
-		%stop = *arith.cmpi(%iv.next, %ub) {predicate = 9 : i64} : (index, index) -> i1
-		*cf.br-cond(%stop) [ ^for.end, ^for.entry:(%iv.next: index, %sum.next: f32) ] : () -> ()
-	}
-^for.end:
-	*func.return(%sum) : (f32) -> ()
-}) {sym_name = "reduce"} : (memref<1024*i32>, index, index, index) -> f32
-

doc/sample/for-loop-4.mie

@@ -1,25 +0,0 @@
-*func.func(%buffer, %lb, %ub, %step) ({
-	; Initial sum set to 0.
-	%sum.0 = *arith.constant() {value = 0.0 : f32} : () -> f32
-
-	; iter_args binds initial values to the loop's region arguments.
-	;%sum = "scf.for"(%lb, %ub, %step) -> (f32) {
-	*cf.br [ ^for.entry(%lb: index, %sum.0: f32) ] : () -> ()
-
-^for.entry(%iv: index, %sum.iter: f32):
-	%t = *memref.load(%buffer, %iv) : (memref<1024*f32>, index) -> f32
-	%sum.next = *arith.addf(%sum.iter, %t) : (f32, f32) -> f32
-
-	*cf.br [ ^for.cond:(%iv: index, %sum.next: f32) ] : () -> ()
-
-^for.cond(%iv: index, %sum.next: f32):
-	; Yield current iteration sum to next iteration %sum.iter or to %sum
-	; if final iteration.
-	%iv.next = *arith.addi(%iv, %step) : (index, index) -> index
-	%stop = *arith.cmpi(%iv.next, %ub) {predicate = 9 : i64} : (index, index) -> i1
-	*cf.br-cond(%stop) [ ^for.end, ^for.entry:(%iv.next: index, %sum.next: f32) ] : () -> ()
-
-^for.end(%sum: f32):
-	*func.return(%sum) : (f32) -> ()
-}) {sym_name = "reduce"} : (memref<1024*f32.abc>, index, index, index) -> f32
-

doc/sample/graph/1.mie

@@ -0,0 +1,38 @@
+select.graph {
+	%entry = +select.entry -> !select.chain
+
+	%0 = +select.register @0 : i32 -> !select.register
+	%1 = +select.register @1 : i32 -> !select.register
+
+	%v.0, %c.0 = +select.register.read %entry, %0 \
+		: (!select.chain, !select.register) \
+		-> (i32, !select.chain)
+
+	%v.1, %c.1 = +select.register.read %entry, %1 \
+		: (!select.chain, !select.register) \
+		-> (i32, !select.chain)
+
+	%2 = +select.register @2 : i32
+
+	%v.2, %c.2 = +select.register.read %entry, %2 \
+		: (!select.chain, !select.register) \
+		-> (!select.register, !select.chain)
+
+	%v.3 = arith.build-pair %v.0, %v.1 : (i32, i32) -> i64
+
+	%v.4 = arith.truncate %v.2 : i64 -> i32
+
+	%v.5 = arith.mul %v.4, %v.3 : (i32, i32) -> i32
+
+	%x0 = +select.mach-register @x0 : i32 -> !select.register
+
+	%c.3, %g.0 = +select.register.write %entry, %x0, %v.5 \
+		: (!select.chain, !select.register, i32) \
+		-> (!select.chain, !select.glue)
+
+	%c.4 = *risc-v.RET %c.3, %x0, %g.0 \
+		: (!select.chain, !select.register, !select.glue) \
+		-> !select.chain
+
+	+select.graph-root %c.4 : !select.chain
+}

doc/sample/graph/2.mie

@@ -0,0 +1,33 @@
+select.graph {
+	%entry = +select.entry -> !select.chain
+
+	%N1 = ptr.alloca i32 -> ptr
+
+	%N2 = i32.constant 3 -> i32
+
+	%N3.c = +ptr.store %entry, %N2, %N1 : (!select.chain, i32, ptr) -> !select.chain
+
+	%N4 = ptr.alloca i32 -> ptr
+
+	%N5 = i32.constant 0 -> i32
+
+	%N6.c = +ptr.store %entry, %N5, %N4 : (!select.chain, i32, ptr) -> !select.chain
+
+	%N7, %N7.c = +ptr.load %N6.c, %N1 : (!select.chain, ptr) -> (!ivy.id, !select.chain)
+
+	%N8 = i32.constant 10 -> i32
+
+	%N9 = arith.cmp gt %N7, %N8 : (!ivy.id, i32) -> i1
+
+	%N10.c = +select.chain-group %N7.c, %N6.c : (!select.chain, !select.chain) -> !select.chain
+
+	%N11 = +select.block-ref @if.true -> !select.block
+
+	%N12.c = +cf.br-cond %N10.c, %N9, %N11 : (!select.chain, i1, !select.block) -> !select.chain
+
+	%N13 = +select.block-ref @if.false -> !select.block
+
+	%N14.c = cf.br %N12.c, %N13
+
+	%N15 = +select.root %N14.c
+}

doc/sample/ir/Person.2.mie

@@ -0,0 +1,530 @@
+meta.source-filename "Person.im"
+
+ivy.package-scope "net.doorstuck.test"
+
+ivy.package-ref "std.io"
+
+ivy.module {
+	%cout = ivy.global-ref @cout -> ptr
+	%StringBuilder = ivy.global-ref @StringBuilder : ptr
+
+	ivy.class @Person {
+		%self.name = ivy.object-var @name : #ivy.id -> ptr
+		%self.age = ivy.object-var @age : #ivy.id -> ptr
+		%self.val = ivy.object-var @val : #ivy.id -> ptr
+		%self.__example-property-4 = ivy.object-var @val : #ivy.id -> ptr
+		%self.__example-property-5 = ivy.object-var @val : #ivy.id -> ptr
+
+		%lambda.0 = ivy.lambda.body <%env> (%i: #ivy.id) -> void {
+			%StringBuilder = ivy.global-ref @StringBuilder -> ptr
+			%0 = ivy.msg.send to %StringBuilder, new -> #ivy.id
+
+			%1 = ivy.str.constant "Count is "
+			ivy.msg.send to %0, append:%1 -> void
+
+			ivy.msg.send to %0, append:%i -> void
+
+			%2 = ivy.msg.send to %0, to-string -> #ivy.id
+
+			%cout = ivy.global-ref @cout -> ptr
+			%3 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %3, put:%2 -> void
+
+			func.return : ()
+		}
+
+		%lambda.1 = ivy.lambda.body <%env> () -> void {
+			%env.q = ivy.pkg.get %env[@q] : #ivy.id -> #ivy.id
+
+			%StringBuilder = ivy.global-ref @StringBuilder -> ptr
+			%0 = ivy.msg.send to %StringBuilder, new -> #ivy.id
+
+			%1 = ivy.str.constant "Value of q is "
+			ivy.msg.send to %0, append:%1 -> void
+
+			ivy.msg.send to %0, append:%env.q -> void
+
+			%2 = ivy.msg.send to %0, to-string -> #ivy.id
+
+			%cout = ivy.global-ref @cout -> ptr
+			%3 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %3, put:%2 -> void
+		}
+
+		ivy.method init(name:%name, age:%age) -> void {
+			ptr.store %name, %self.name : #ivy.id, ptr
+			ptr.store %age, %self.age : #ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.method test(param:%data, _:%extra) -> void {
+			%0 = ptr.load %StringBuilder : ptr -> #ivy.id
+			%1 = ivy.msg.send to %0, new -> #ivy.id
+
+			%2 = ivy.str.constant "Received "
+			ivy.msg.send to %1, append:%2 -> void
+
+			ivy.msg.send to %1, append:%data -> void
+
+			%3 = ivy.str.constant ", "
+			ivy.msg.send to %1, append:%3 -> void
+
+			ivy.msg.send to %1, append:%extra -> void
+
+			%4 = ivy.msg.send to %1, to-string -> #ivy.id
+
+			%5 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %5, put:%4 -> void
+			func.return : ()
+		}
+
+		ivy.method name -> #ivy.id {
+			%0 = ptr.load %self.name : ptr -> #ivy.id
+			func.return %0 : #ivy.id
+		}
+
+		ivy.method age -> #ivy.id {
+			%0 = ptr.load %self.age : ptr -> #ivy.id
+			func.return %0 : #ivy.id
+		}
+
+		ivy.method age-in-months -> #ivy.id {
+			%0 = ptr.load %self.age : ptr -> #ivy.id
+			%1 = i32.constant 12
+			%multmp = ivy.mul %0, %1 : (#ivy.id, i32) -> #ivy.id
+			func.return %multmp : #ivy.id
+		}
+
+		ivy.method set-name:%name -> void {
+			ptr.store %name, %self.name : #ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.method set-age:%age -> void {
+			ptr.store %age, %self.age : #ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.method set-age:%age in-units:%units -> void {
+		^switch.cond.0:
+				%0 = ivy.atom "years"
+				%cmptmp.0 = ivy.cmp eq %age, %0 : (#ivy.id, #ivy.atom) -> i1
+				cf.br-cond %cmptmp.0, ^switch.body.0, ^switch.cond.1
+
+		^switch.body.0:
+				ptr.store %age, %self.age : #ivy.id, ptr
+				cf.br ^switch.end.0
+
+		^switch.cond.1:
+				%1 = ivy.atom "months"
+				%cmptmp.1 = ivy.cmp eq %age, %1 : (#ivy.id, #ivy.atom) -> i1
+				cf.br-cond %cmptmp.1, ^switch.body.1, ^switch.cond.2
+
+		^switch.body.1:
+				%d0 = i32.constant 12
+				%divtmp.0 = ivy.div %age, %d0 : (#ivy.id, i32) -> #ivy.id
+				ptr.store %divtmp.0, %self.age : #ivy.id, ptr
+				cf.br ^switch.end.0
+
+		^switch.cond.2:
+				%2 = ivy.atom "days"
+				%cmptmp.2 = ivy.cmp eq %age, %2 : (#ivy.id, #ivy.atom) -> i1
+				cf.br-cond %cmptmp.2, ^switch.body.2, ^switch.default
+
+		^switch.body.2:
+				%d1 = i32.constant 365
+				%divtmp.1 = ivy.div %age, %d1 : (#ivy.id, i32) -> #ivy.id
+				ptr.store %divtmp.1, %self.age : #ivy.id, ptr
+				cf.br ^switch.end.0
+
+		^switch.default:
+				%d2 = i32.constant 0
+				cf.br ^switch.end.0
+
+		^switch.end:
+			func.return : ()
+		}
+
+		ivy.method get-age-in-units:%units -> #ivy.id {
+		^switch.cond.0:
+			%0 = ivy.atom "years"
+			%cmptmp.0 = ivy.cmp eq %age, %0 : (#ivy.id, #ivy.atom) -> i1
+			cf.br-cond %cmptmp.0, ^switch.body.0, ^switch.cond.1
+
+		^switch.body.0:
+			%v0 = ptr.load %self.age : ptr -> #ivy.id
+			cf.br ^switch.end(%v0: #ivy.id)
+
+		^switch.cond.0:
+			%1 = ivy.atom "months"
+			%cmptmp.1 = ivy.cmp eq %age, %1 : (#ivy.id, #ivy.atom) -> i1
+			cf.br-cond %cmptmp.1, ^switch.body.1, ^switch.cond.2
+
+		^switch.body.0:
+			%v0 = ptr.load %self.age : ptr -> #ivy.id
+			%d0 = i32.constant 12
+			%divtmp.0 = ivy.div %v0, %d0 : (#ivy.id, i32) -> #ivy.id
+			cf.br ^switch.end(%divtmp.0: #ivy.id)
+
+		^switch.cond.0:
+			%2 = ivy.atom "days"
+			%cmptmp.2 = ivy.cmp eq %age, %2 : (#ivy.id, #ivy.atom) -> i1
+			cf.br-cond %cmptmp.2, ^switch.body.2, ^switch.default
+
+		^switch.body.0:
+			%v1 = ptr.load %self.age : ptr -> #ivy.id
+			%d1 = i32.constant 365
+			%divtmp.1 = ivy.div %v1, %d1 : (#ivy.id, i32) -> #ivy.id
+			cf.br ^switch.end(%divtmp.1: #ivy.id)
+
+		^switch.default:
+			%d2 = i32.constant 0
+			cf.br ^switch.end(%d2.1: i32)
+
+		^switch.end(%result: #ivy.id):
+			func.return %result : #ivy.id
+		}
+
+		ivy.object-prop example-property
+		get {
+			%0 = ptr.load %self.val : ptr -> #ivy.id
+			func.return %0 : #ivy.id
+		}
+		set (%value: #ivy.id) {
+			ptr.store %value, %self.val : #ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.object-prop example-property-2 get {
+			%0 = ptr.load %self.val : ptr -> #ivy.id
+			func.return %0 : #ivy.id
+		} set (%x: #ivy.id) {
+			ptr.store %x, %self.val : #ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.object-prop example-property-3 get {
+			%0 = i32.constant 42
+			func.return %0 : i32
+		}
+
+		ivy.object-prop example-property-4 get {
+			%0 = ptr.load %self.p-example-property-4 : ptr -> #ivy.id
+			func.return %0 : #ivy.id
+		} set (%0: #ivy.id) {
+			ptr.store %0, %self.p-example-property-4 : #ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.object-prop example-property-5 get {
+			%0 = ptr.load %self.p-example-property-5 : ptr -> #ivy.id
+			func.return %0 : #ivy.id
+		}
+	}
+
+	ivy.init-text {
+		; p1 = Person new(name:'John Doe', age:34).
+		%Person = ivy.global-ref @Person : ptr
+		%0 = ivy.str.constant "John Doe"
+		%1 = i32.constant 34
+
+		%2 = ivy.msg.send to %Person, new(name:%0, age:%1) -> #ivy.id
+
+		%p1 = ptr.alloca #ivy.id -> ptr
+		ptr.store %2, %p1 : #ivy.id, ptr
+
+		; p1 set-age:100 in-unit:$months.
+		%3 = ptr.load %p1 : ptr -> #ivy.id
+		%4 = i32.constant 100
+		%5 = ivy.atom "months"
+		ivy.msg.send to %3, set-age:%4 in-units:%5 -> void
+
+		; p1 test(param:'Hello', 'World').
+		%6 = ptr.load %p1 : ptr -> #ivy.id
+		%7 = ivy.str.constant "Hello"
+		%8 = ivy.str.constant "World"
+		ivy.msg.send to %6, test(param:%7, _:%8) -> void
+
+		; i = 0.
+		%i = ptr.alloca i32 -> ptr
+		%9 = i32.constant 0
+		ptr.store %9, %i : i32, ptr
+
+		; while i < 100 do
+	^while.cond:
+		; i < 100
+		%10 = ptr.load %i : ptr -> i32
+		%11 = i32.constant 100
+		%cmptmp = ivy.cmp lt %10, %11 : (i32, i32) -> i1
+		scf.condition(%cmptmp)
+		cf.br-cond %cmptmp, ^while.body, ^while.end
+
+	^while.body:
+		; cout put:'Count is {i}'.
+		%12 = ivy.msg.send to %StringBuilder, new -> #ivy.id
+
+		%13 = ivy.str.constant "Count is "
+		ivy.msg.send to %12, append:%13 -> void
+
+		%14 = ptr.load %i : ptr -> i32
+		ivy.msg.send to %12, append:14 -> void
+
+		%15 = ivy.msg.send to %12, to-string -> #ivy.id
+
+		%16 = ptr.load %cout : ptr -> #ivy.id
+		ivy.msg.send to %16, put:%15 -> void
+
+		; i += 2
+		%17 = ptr.load %i : ptr -> i32
+		%18 = i32.constant 2
+		%addtmp = ivy.add %17, %18 : (i32, i32) -> i32
+		ptr.store %addtmp, %i : i32, ptr
+		cf.br ^while.cond
+
+	^while.end:
+		; 0 to:100 step:2
+		%19 = i32.constant 0
+		%20 = i32.constant 100
+		%21 = i32.constant 2
+		%22 = ivy.msg.send to %19, to:%20 step:%21 -> #ivy.id
+
+		%for.iv.0 = ivy.msg.send to %22, value -> #ivy.id
+		cf.br ^for.cond(%for.iv.0: #ivy.id)
+
+	^for.step:
+		ivy.msg.send to %22, move-next -> void
+		%for.iv.next = ivy.msg.send to %22, value -> #ivy.id
+		cf.br ^for.cond(%for.iv.next: #ivy.id)
+
+	^for.cond(%iv: #ivy.id):
+		%for.valid = ivy.is-null-ref %iv : #ivy.id -> i1
+		cf.br-cond %for.valid, ^for.body(%iv: #ivy.id), ^for.end
+
+	^for.body(%x: #ivy.id):
+		; for x in 0 to:100 step:2 do
+		%23 = ivy.msg.send to %StringBuilder, new -> #ivy.id
+
+		; 'Count is {x}'
+		%24 = ivy.str.constant "Count is "
+		ivy.msg.send to %23, append:%24 -> void
+
+		ivy.msg.send to %23, append:%x -> void
+
+		%25 = ivy.msg.send to %23, to-string -> #ivy.id
+
+		; cout put:"Count is {x}"
+		%26 = ptr.load %cout : ptr -> #ivy.id
+		ivy.msg.send to %26, put:%25 -> void
+
+		cf.br ^for.step
+
+	^for.end:
+		; 0 to:100 step:2 do:...
+		%27 = i32.constant 0
+		%28 = i32.constant 100
+		%29 = i32.constant 2
+		; [ :i | cout put:'Count: {i}' ]
+		%30 = ivy.lambda.create %lambda.0 -> #ivy.id
+
+		; 0 to:100 step:2 do:[ :i | cout put:'Count: {i}' ].
+		ivy.msg.send to %27, to:%28 step:%29 do:%30
+
+		; q = 32.
+		%q = ptr.alloca i32 -> ptr
+		%31 = i32.constant 32
+		ptr.store %31, %q : i32, ptr
+
+		; l = [ cout put:'Value of q is {q}' ].
+		%l = ptr.alloca #ivy.id
+		%32 = ptr.load %q : ptr -> i32
+		%lambda.env = ivy.pkg.create -> #ivy.id
+		ivy.pkg.put %lambda.env[@q] = %32 : (#ivy.id, #ivy.id)
+
+		%33 = ivy.lambda.create <%lambda.env> %lambda.1 -> #ivy.id
+
+		ptr.store %33, %l : #ivy.id, ptr
+
+		; q = 64.
+		%34 = i32.constant 64
+		ptr.store %34, %q : i32, ptr
+
+		; l call.
+		%35 = ptr.load %l : ptr -> #ivy.id
+		ivy.msg.send to %35, call -> void
+
+		%j = ptr.alloca i32 -> ptr
+
+		%36 = i32.constant 32
+		ptr.store %36, %j : i32, ptr
+
+		%37 = ptr.load %i : ptr -> i32
+		%38 = ptr.load %j : ptr -> i32
+
+		%cmptmp = arith.cmp lt %37, %38 : (i32, i32) -> i1
+
+		%39 = ivy.lambda : () -> void {
+			%cout = ivy.global-ref @cout -> ptr
+			%0 = ivy.str.constant "True!"
+			%1 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %1, put:%0 -> void
+		}
+
+		%40 = ivy.lambda : () -> void {
+			%cout = ivy.global-ref @cout -> ptr
+			%0 = ivy.str.constant "False!"
+			%1 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %1, put:%0 -> void
+		}
+
+		ivy.msg.send to %cmptmp, if:%39 else:%40 -> void
+
+		%41 = ptr.load %i : ptr -> i32
+		%42 = ptr.load %j : ptr -> i32
+
+		%cmptmp.0 = arith.cmp lt %41, %42 : (i32, i32) -> i1
+
+		scf.if %cmptmp.0 -> void {
+			%43 = ivy.str.constant "True!"
+			%44 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %44, put:%43 -> void
+		}
+
+		; pkg = {}.
+		%pkg = ptr.alloca #ivy.id -> ptr
+
+
+		%45 = ivy.pkg.create -> #ivy.id
+		ptr.store %45, %pkg : #ivy.id, ptr
+
+		; pkg[0] = 16.
+		%46 = ptr.load %pkg : ptr -> #ivy.id
+		%47 = i32.constant 0
+		%48 = i32.constant 16
+
+		ivy.msg.send to %46, at:%47 put:%48 -> void
+
+		; tuple = (32, 'a string')
+		%tuple = ptr.alloca #ivy.id -> ptr
+
+		%49 = i32.constant 32
+		%50 = ivy.str.constant "a string"
+
+		%51 = ivy.tuple.create %49, %50 : (i32, #ivy.id) -> #ivy.id
+
+		ptr.store %51, %tuple : #ivy.id, ptr
+
+		%52 = ptr.load %tuple : ptr -> #ivy.id
+		%53 = ivy.msg.send to %52, get-iterator -> #ivy.id
+
+		ivy.for %54 in %53 -> void {
+			%key = ivy.tuple.get-item %54[0] : #ivy.id -> #ivy.id
+			%val = ivy.tuple.get-item %54[1] : #ivy.id -> #ivy.id
+
+			; '{key} -> {val}'
+			%55 = ivy.msg.send to %StringBuilder, new -> #ivy.id
+
+			ivy.msg.send to %55, append:%key -> void
+
+			%56 = ivy.str.constant " -> "
+			ivy.msg.send to %55, append:%56 -> void
+
+			ivy.msg.send to %55, append:%val -> void
+
+			%57 = ivy.msg.send to %23, to-string -> #ivy.id
+
+			; cout put:'{key} -> {val}'
+			%58 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %58, put:%57 -> void
+		}
+
+		; _ = 3 * 2.
+		%59 = i32.constant 3
+		%60 = i32.constant 2
+		%multmp = arith.mul %59, %60 : (i32, i32) -> i32
+
+		; a = (32, 64).
+		%a = ptr.alloca #ivy.id -> ptr
+
+		%61 = i32.constant 32
+		%62 = i32.constant 64
+		%63 = ivy.tuple.create %61, %62 : (i32, i32) -> #ivy.id
+
+		ptr.store %63, %a : #ivy.id, ptr
+
+		%v = ptr.alloca #ivy.id -> ptr
+
+		%64 = ptr.load %a : ptr -> #ivy.id
+		%65 = ivy.tuple.get-item %64[1] : #ivy.id -> #ivy.id
+
+		ptr.store %65, %v : #ivy.id, ptr
+
+		%66 = ivy.atom "err:number-format"
+
+		ivy.try -> void {
+
+		} catch (%ex = %66), %data {
+
+		} catch-all %ex, %data {
+
+		}
+
+		%67 = ivy.lambda : () -> void {
+			%v = ptr.alloca #ivy.id -> ptr
+			%Int = ivy.global-ref @Int -> ptr
+			%0 = ivy.str.constant "342"
+
+			%1 = ivy.msg.send to %Int, parse:%0
+
+			ptr.store %1, %v : #ivy.id, ptr
+		}
+
+		%68 = ivy.lambda %err, %data : (#ivy.id, #ivy.id) -> void {
+			%0 = ivy.msg.send to %StringBuilder, new -> #ivy.id
+
+			ivy.msg.send to %0, append:%key -> void
+
+			%1 = ivy.str.constant "Cannot parse integer string ("
+			ivy.msg.send to %0, append:%1 -> void
+
+			ivy.msg.send to %0, append:%err -> void
+
+			%2 = ivy.str.constant ")"
+			ivy.msg.send to %0, append:%2 -> void
+
+			%3 = ivy.msg.send to %0, to-string -> #ivy.id
+
+			; cout put:'{key} -> {val}'
+			%4 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %4, put:%3 -> void
+		}
+
+		%69 = ivy.lambda %err, %data : (#ivy.id, #ivy.id) -> void {
+			%0 = ivy.msg.send to %StringBuilder, new -> #ivy.id
+
+			ivy.msg.send to %0, append:%key -> void
+
+			%1 = ivy.str.constant "Error "
+			ivy.msg.send to %0, append:%1 -> void
+
+			ivy.msg.send to %0, append:%err -> void
+
+			%2 = ivy.str.constant " occurred ("
+			ivy.msg.send to %0, append:%2 -> void
+
+			ivy.msg.send to %0, append:%data -> void
+
+			%3 = ivy.str.constant ")"
+
+			%4 = ivy.msg.send to %0, to-string -> #ivy.id
+
+			; cout put:'{key} -> {val}'
+			%5 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %5, put:%4 -> void
+		}
+
+		%70 = ivy.atom "err:number-format"
+		ivy.msg.send to %67, on:%70 do:%68 -> #ivy.id
+		ivy.msg.send to %67, on-error:%69 -> void
+		ivy.msg.send to %67, call -> void
+	}
+}

doc/sample/ir/Person.3.mie

@@ -0,0 +1,535 @@
+meta.source-filename "Person.im"
+
+ivy.package-scope "net.doorstuck.test"
+
+ivy.package-ref "std.io"
+
+ivy.module {
+	%cout = ivy.global-ref @cout -> ptr
+	%StringBuilder = ivy.global-ref @StringBuilder : ptr
+
+	ivy.class @Person {
+		%self.name = ivy.object-var @name : #ivy.id -> ptr
+		%self.age = ivy.object-var @age : #ivy.id -> ptr
+		%self.val = ivy.object-var @val : #ivy.id -> ptr
+		%self.__example-property-4 = ivy.object-var @val : #ivy.id -> ptr
+		%self.__example-property-5 = ivy.object-var @val : #ivy.id -> ptr
+
+		%lambda.0 = ivy.lambda.body <%env> (%i: #ivy.id) -> void {
+			%StringBuilder = ivy.global-ref @StringBuilder -> ptr
+			%0 = ivy.msg.send to %StringBuilder, new -> #ivy.id
+
+			%1 = ivy.str.constant "Count is "
+			ivy.msg.send to %0, append:%1 -> void
+
+			ivy.msg.send to %0, append:%i -> void
+
+			%2 = ivy.msg.send to %0, to-string -> #ivy.id
+
+			%cout = ivy.global-ref @cout -> ptr
+			%3 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %3, put:%2 -> void
+
+			func.return : ()
+		}
+
+		%lambda.1 = ivy.lambda.body <%env> () -> void {
+			%env.q = ivy.pkg.get %env[@q] : #ivy.id -> #ivy.id
+
+			%StringBuilder = ivy.global-ref @StringBuilder -> ptr
+			%0 = ivy.msg.send to %StringBuilder, new -> #ivy.id
+
+			%1 = ivy.str.constant "Value of q is "
+			ivy.msg.send to %0, append:%1 -> void
+
+			ivy.msg.send to %0, append:%env.q -> void
+
+			%2 = ivy.msg.send to %0, to-string -> #ivy.id
+
+			%cout = ivy.global-ref @cout -> ptr
+			%3 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %3, put:%2 -> void
+		}
+
+		ivy.object.func init(name:%name, age:%age) -> void {
+			ptr.store %name, %self.name : #ivy.id, ptr
+			ptr.store %age, %self.age : #ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.object.func test(param:%data, _:%extra) -> void {
+			%0 = ptr.load %StringBuilder : ptr -> #ivy.id
+			%1 = ivy.msg.send to %0, new -> #ivy.id
+
+			%2 = ivy.str.constant "Received "
+			ivy.msg.send to %1, append:%2 -> void
+
+			ivy.msg.send to %1, append:%data -> void
+
+			%3 = ivy.str.constant ", "
+			ivy.msg.send to %1, append:%3 -> void
+
+			ivy.msg.send to %1, append:%extra -> void
+
+			%4 = ivy.msg.send to %1, to-string -> #ivy.id
+
+			%5 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %5, put:%4 -> void
+			func.return : ()
+		}
+
+		ivy.object.func name -> #ivy.id {
+			%0 = ptr.load %self.name : ptr -> #ivy.id
+			func.return %0 : #ivy.id
+		}
+
+		ivy.object.func age -> #ivy.id {
+			%0 = ptr.load %self.age : ptr -> #ivy.id
+			func.return %0 : #ivy.id
+		}
+
+		ivy.object.func age-in-months -> #ivy.id {
+			%0 = ptr.load %self.age : ptr -> #ivy.id
+			%1 = i32.constant 12
+			%multmp = ivy.mul %0, %1 : (#ivy.id, i32) -> #ivy.id
+			func.return %multmp : #ivy.id
+		}
+
+		ivy.object.func set-name:%name -> void {
+			ptr.store %name, %self.name : #ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.object.func set-age:%age -> void {
+			ptr.store %age, %self.age : #ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.object.func set-age:%age in-units:%units -> void {
+		^switch.cond.0:
+				%0 = ivy.atom "years"
+				%cmptmp.0 = ivy.cmp eq %age, %0 : (#ivy.id, #ivy.atom) -> i1
+				cf.br-cond %cmptmp.0, ^switch.body.0, ^switch.cond.1
+
+		^switch.body.0:
+				ptr.store %age, %self.age : #ivy.id, ptr
+				cf.br ^switch.end.0
+
+		^switch.cond.1:
+				%1 = ivy.atom "months"
+				%cmptmp.1 = ivy.cmp eq %age, %1 : (#ivy.id, #ivy.atom) -> i1
+				cf.br-cond %cmptmp.1, ^switch.body.1, ^switch.cond.2
+
+		^switch.body.1:
+				%d0 = i32.constant 12
+				%divtmp.0 = ivy.div %age, %d0 : (#ivy.id, i32) -> #ivy.id
+				ptr.store %divtmp.0, %self.age : #ivy.id, ptr
+				cf.br ^switch.end.0
+
+		^switch.cond.2:
+				%2 = ivy.atom "days"
+				%cmptmp.2 = ivy.cmp eq %age, %2 : (#ivy.id, #ivy.atom) -> i1
+				cf.br-cond %cmptmp.2, ^switch.body.2, ^switch.default
+
+		^switch.body.2:
+				%d1 = i32.constant 365
+				%divtmp.1 = ivy.div %age, %d1 : (#ivy.id, i32) -> #ivy.id
+				ptr.store %divtmp.1, %self.age : #ivy.id, ptr
+				cf.br ^switch.end.0
+
+		^switch.default:
+				%d2 = i32.constant 0
+				ptr.store %d2, %self.age : #ivy.id, ptr
+				cf.br ^switch.end.0
+
+		^switch.end:
+			func.return : ()
+		}
+
+		ivy.object.func get-age-in-units:%units -> #ivy.id {
+		^switch.cond.0:
+			%0 = ivy.atom "years"
+			%cmptmp.0 = ivy.cmp eq %age, %0 : (#ivy.id, #ivy.atom) -> i1
+			cf.br-cond %cmptmp.0, ^switch.body.0, ^switch.cond.1
+
+		^switch.body.0:
+			%v0 = ptr.load %self.age : ptr -> #ivy.id
+			cf.br ^switch.end(%v0: #ivy.id)
+
+		^switch.cond.1:
+			%1 = ivy.atom "months"
+			%cmptmp.1 = ivy.cmp eq %age, %1 : (#ivy.id, #ivy.atom) -> i1
+			cf.br-cond %cmptmp.1, ^switch.body.1, ^switch.cond.2
+
+		^switch.body.1:
+			%v0 = ptr.load %self.age : ptr -> #ivy.id
+			%d0 = i32.constant 12
+			%divtmp.0 = ivy.div %v0, %d0 : (#ivy.id, i32) -> #ivy.id
+			cf.br ^switch.end(%divtmp.0: #ivy.id)
+
+		^switch.cond.2:
+			%2 = ivy.atom "days"
+			%cmptmp.2 = ivy.cmp eq %age, %2 : (#ivy.id, #ivy.atom) -> i1
+			cf.br-cond %cmptmp.2, ^switch.body.2, ^switch.default
+
+		^switch.body.2:
+			%v1 = ptr.load %self.age : ptr -> #ivy.id
+			%d1 = i32.constant 365
+			%divtmp.1 = ivy.div %v1, %d1 : (#ivy.id, i32) -> #ivy.id
+			cf.br ^switch.end(%divtmp.1: #ivy.id)
+
+		^switch.default:
+			%d2 = i32.constant 0
+			cf.br ^switch.end(%d2.1: i32)
+
+		^switch.end(%result: #ivy.id):
+			func.return %result : #ivy.id
+		}
+
+		ivy.object.prop example-property
+		get {
+			%0 = ptr.load %self.val : ptr -> #ivy.id
+			func.return %0 : #ivy.id
+		}
+		set (%value: #ivy.id) {
+			ptr.store %value, %self.val : #ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.object.prop example-property-2 get {
+			%0 = ptr.load %self.val : ptr -> #ivy.id
+			func.return %0 : #ivy.id
+		} set (%x: #ivy.id) {
+			ptr.store %x, %self.val : #ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.object.prop example-property-3 get {
+			%0 = i32.constant 42
+			func.return %0 : i32
+		}
+
+		ivy.object.prop example-property-4 get {
+			%0 = ptr.load %self.p-example-property-4 : ptr -> #ivy.id
+			func.return %0 : #ivy.id
+		} set (%0: #ivy.id) {
+			ptr.store %0, %self.p-example-property-4 : #ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.object.prop example-property-5 get {
+			%0 = ptr.load %self.p-example-property-5 : ptr -> #ivy.id
+			func.return %0 : #ivy.id
+		}
+	}
+
+	ivy.init-text {
+		; p1 = Person new(name:'John Doe', age:34).
+		%Person = ivy.global-ref @Person : ptr
+		%0 = ivy.str.constant "John Doe"
+		%1 = i32.constant 34
+
+		%2 = ivy.msg.send to %Person, new(name:%0, age:%1) -> #ivy.id
+
+		%p1 = ptr.alloca #ivy.id -> ptr
+		ptr.store %2, %p1 : #ivy.id, ptr
+
+		; p1 set-age:100 in-unit:$months.
+		%3 = ptr.load %p1 : ptr -> #ivy.id
+		%4 = i32.constant 100
+		%5 = ivy.atom "months"
+		ivy.msg.send to %3, set-age:%4 in-units:%5 -> void
+
+		; p1 test(param:'Hello', 'World').
+		%6 = ptr.load %p1 : ptr -> #ivy.id
+		%7 = ivy.str.constant "Hello"
+		%8 = ivy.str.constant "World"
+		ivy.msg.send to %6, test(param:%7, _:%8) -> void
+
+		; i = 0.
+		%i = ptr.alloca i32 -> ptr
+		%9 = i32.constant 0
+		ptr.store %9, %i : i32, ptr
+		cf.br ^while.cond
+
+		; while i < 100 do
+	^while.cond:
+		; i < 100
+		%10 = ptr.load %i : ptr -> i32
+		%11 = i32.constant 100
+		%cmptmp = ivy.cmp lt %10, %11 : (i32, i32) -> i1
+		scf.condition(%cmptmp)
+		cf.br-cond %cmptmp, ^while.body, ^while.end
+
+	^while.body:
+		; cout put:'Count is {i}'.
+		%12 = ivy.msg.send to %StringBuilder, new -> #ivy.id
+
+		%13 = ivy.str.constant "Count is "
+		ivy.msg.send to %12, append:%13 -> void
+
+		%14 = ptr.load %i : ptr -> i32
+		ivy.msg.send to %12, append:14 -> void
+
+		%15 = ivy.msg.send to %12, to-string -> #ivy.id
+
+		%16 = ptr.load %cout : ptr -> #ivy.id
+		ivy.msg.send to %16, put:%15 -> void
+
+		; i += 2
+		%17 = ptr.load %i : ptr -> i32
+		%18 = i32.constant 2
+		%addtmp = ivy.add %17, %18 : (i32, i32) -> i32
+		ptr.store %addtmp, %i : i32, ptr
+		cf.br ^while.cond
+
+	^while.end:
+		; 0 to:100 step:2
+		%19 = i32.constant 0
+		%20 = i32.constant 100
+		%21 = i32.constant 2
+		%22 = ivy.msg.send to %19, to:%20 step:%21 -> #ivy.id
+
+		cf.br ^for.init(%22: #ivy.id)
+
+	^for.init(%it: #ivy.id):
+		%for.iv.0 = ivy.msg.send to %it, value -> #ivy.id
+		cf.br ^for.cond(%it: #ivy.id, %for.iv.0: #ivy.id)
+
+	^for.step(%it: #ivy.id):
+		ivy.msg.send to %22, move-next -> void
+		%for.iv.next = ivy.msg.send to %22, value -> #ivy.id
+		cf.br ^for.cond(%it: #ivy.id, %for.iv.next: #ivy.id)
+
+	^for.cond(%it: #ivy.id, %iv: #ivy.id):
+		%for.valid = ivy.is-null-ref %iv : #ivy.id -> i1
+		cf.br-cond %for.valid, ^for.body(%it: #ivy.id, %iv: #ivy.id), ^for.end
+
+	^for.body(%it: #ivy.id, %x: #ivy.id):
+		; for x in 0 to:100 step:2 do
+		%23 = ivy.msg.send to %StringBuilder, new -> #ivy.id
+
+		; 'Count is {x}'
+		%24 = ivy.str.constant "Count is "
+		ivy.msg.send to %23, append:%24 -> void
+
+		ivy.msg.send to %23, append:%x -> void
+
+		%25 = ivy.msg.send to %23, to-string -> #ivy.id
+
+		; cout put:"Count is {x}"
+		%26 = ptr.load %cout : ptr -> #ivy.id
+		ivy.msg.send to %26, put:%25 -> void
+
+		cf.br ^for.step(%it: #ivy.id)
+
+	^for.end:
+		; 0 to:100 step:2 do:...
+		%27 = i32.constant 0
+		%28 = i32.constant 100
+		%29 = i32.constant 2
+		; [ :i | cout put:'Count: {i}' ]
+		%30 = ivy.lambda.create %lambda.0 -> #ivy.id
+
+		; 0 to:100 step:2 do:[ :i | cout put:'Count: {i}' ].
+		ivy.msg.send to %27, to:%28 step:%29 do:%30
+
+		; q = 32.
+		%q = ptr.alloca i32 -> ptr
+		%31 = i32.constant 32
+		ptr.store %31, %q : i32, ptr
+
+		; l = [ cout put:'Value of q is {q}' ].
+		%l = ptr.alloca #ivy.id
+		%32 = ptr.load %q : ptr -> i32
+		%lambda.env = ivy.pkg.create -> #ivy.id
+		ivy.pkg.put %lambda.env[@q] = %32 : (#ivy.id, #ivy.id)
+
+		%33 = ivy.lambda.create <%lambda.env> %lambda.1 -> #ivy.id
+
+		ptr.store %33, %l : #ivy.id, ptr
+
+		; q = 64.
+		%34 = i32.constant 64
+		ptr.store %34, %q : i32, ptr
+
+		; l call.
+		%35 = ptr.load %l : ptr -> #ivy.id
+		ivy.msg.send to %35, call -> void
+
+		%j = ptr.alloca i32 -> ptr
+
+		%36 = i32.constant 32
+		ptr.store %36, %j : i32, ptr
+
+		%37 = ptr.load %i : ptr -> i32
+		%38 = ptr.load %j : ptr -> i32
+
+		%cmptmp = arith.cmp lt %37, %38 : (i32, i32) -> i1
+
+		%39 = ivy.lambda : () -> void {
+			%cout = ivy.global-ref @cout -> ptr
+			%0 = ivy.str.constant "True!"
+			%1 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %1, put:%0 -> void
+		}
+
+		%40 = ivy.lambda : () -> void {
+			%cout = ivy.global-ref @cout -> ptr
+			%0 = ivy.str.constant "False!"
+			%1 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %1, put:%0 -> void
+		}
+
+		ivy.msg.send to %cmptmp, if:%39 else:%40 -> void
+
+		%41 = ptr.load %i : ptr -> i32
+		%42 = ptr.load %j : ptr -> i32
+
+		%cmptmp.0 = arith.cmp lt %41, %42 : (i32, i32) -> i1
+
+		scf.if %cmptmp.0 -> void {
+			%43 = ivy.str.constant "True!"
+			%44 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %44, put:%43 -> void
+		}
+
+		; pkg = {}.
+		%pkg = ptr.alloca #ivy.id -> ptr
+
+
+		%45 = ivy.pkg.create -> #ivy.id
+		ptr.store %45, %pkg : #ivy.id, ptr
+
+		; pkg[0] = 16.
+		%46 = ptr.load %pkg : ptr -> #ivy.id
+		%47 = i32.constant 0
+		%48 = i32.constant 16
+
+		ivy.msg.send to %46, at:%47 put:%48 -> void
+
+		; tuple = (32, 'a string')
+		%tuple = ptr.alloca #ivy.id -> ptr
+
+		%49 = i32.constant 32
+		%50 = ivy.str.constant "a string"
+
+		%51 = ivy.tuple.create %49, %50 : (i32, #ivy.id) -> #ivy.id
+
+		ptr.store %51, %tuple : #ivy.id, ptr
+
+		%52 = ptr.load %tuple : ptr -> #ivy.id
+		%53 = ivy.msg.send to %52, get-iterator -> #ivy.id
+
+		ivy.for %54 in %53 -> void {
+			%key = ivy.tuple.get-item %54[0] : #ivy.id -> #ivy.id
+			%val = ivy.tuple.get-item %54[1] : #ivy.id -> #ivy.id
+
+			; '{key} -> {val}'
+			%55 = ivy.msg.send to %StringBuilder, new -> #ivy.id
+
+			ivy.msg.send to %55, append:%key -> void
+
+			%56 = ivy.str.constant " -> "
+			ivy.msg.send to %55, append:%56 -> void
+
+			ivy.msg.send to %55, append:%val -> void
+
+			%57 = ivy.msg.send to %23, to-string -> #ivy.id
+
+			; cout put:'{key} -> {val}'
+			%58 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %58, put:%57 -> void
+		}
+
+		; _ = 3 * 2.
+		%59 = i32.constant 3
+		%60 = i32.constant 2
+		%multmp = arith.mul %59, %60 : (i32, i32) -> i32
+
+		; a = (32, 64).
+		%a = ptr.alloca #ivy.id -> ptr
+
+		%61 = i32.constant 32
+		%62 = i32.constant 64
+		%63 = ivy.tuple.create %61, %62 : (i32, i32) -> #ivy.id
+
+		ptr.store %63, %a : #ivy.id, ptr
+
+		%v = ptr.alloca #ivy.id -> ptr
+
+		%64 = ptr.load %a : ptr -> #ivy.id
+		%65 = ivy.tuple.get-item %64[1] : #ivy.id -> #ivy.id
+
+		ptr.store %65, %v : #ivy.id, ptr
+
+		%66 = ivy.atom "err:number-format"
+
+		ivy.try -> void {
+
+		} catch (%ex = %66), %data {
+
+		} catch-all %ex, %data {
+
+		}
+
+		%67 = ivy.lambda : () -> void {
+			%v = ptr.alloca #ivy.id -> ptr
+			%Int = ivy.global-ref @Int -> ptr
+			%0 = ivy.str.constant "342"
+
+			%1 = ivy.msg.send to %Int, parse:%0
+
+			ptr.store %1, %v : #ivy.id, ptr
+		}
+
+		%68 = ivy.lambda %err, %data : (#ivy.id, #ivy.id) -> void {
+			%0 = ivy.msg.send to %StringBuilder, new -> #ivy.id
+
+			ivy.msg.send to %0, append:%key -> void
+
+			%1 = ivy.str.constant "Cannot parse integer string ("
+			ivy.msg.send to %0, append:%1 -> void
+
+			ivy.msg.send to %0, append:%err -> void
+
+			%2 = ivy.str.constant ")"
+			ivy.msg.send to %0, append:%2 -> void
+
+			%3 = ivy.msg.send to %0, to-string -> #ivy.id
+
+			; cout put:'{key} -> {val}'
+			%4 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %4, put:%3 -> void
+		}
+
+		%69 = ivy.lambda %err, %data : (#ivy.id, #ivy.id) -> void {
+			%0 = ivy.msg.send to %StringBuilder, new -> #ivy.id
+
+			ivy.msg.send to %0, append:%key -> void
+
+			%1 = ivy.str.constant "Error "
+			ivy.msg.send to %0, append:%1 -> void
+
+			ivy.msg.send to %0, append:%err -> void
+
+			%2 = ivy.str.constant " occurred ("
+			ivy.msg.send to %0, append:%2 -> void
+
+			ivy.msg.send to %0, append:%data -> void
+
+			%3 = ivy.str.constant ")"
+
+			%4 = ivy.msg.send to %0, to-string -> #ivy.id
+
+			; cout put:'{key} -> {val}'
+			%5 = ptr.load %cout : ptr -> #ivy.id
+			ivy.msg.send to %5, put:%4 -> void
+		}
+
+		%70 = ivy.atom "err:number-format"
+		ivy.msg.send to %67, on:%70 do:%68 -> #ivy.id
+		ivy.msg.send to %67, on-error:%69 -> void
+		ivy.msg.send to %67, call -> void
+	}
+}

doc/sample/ir/Person.mie

@@ -0,0 +1,460 @@
+meta.source-filename "Person.im"
+
+ivy.package-scope "net.doorstuck.test"
+
+ivy.package-ref "std.io"
+
+ivy.module {
+	%cout = ivy.global-ref @cout -> ptr
+
+	ivy.class @Person {
+		%self.name = ivy.object-var @name : !ivy.id -> ptr
+		%self.age = ivy.object-var @age : !ivy.id -> ptr
+		%self.val = ivy.object-var @val : !ivy.id -> ptr
+		%self.__example-property-4 = ivy.object-var @val : !ivy.id -> ptr
+		%self.__example-property-5 = ivy.object-var @val : !ivy.id -> ptr
+
+		ivy.msgh.object init(name:%name, age:%age) -> void {
+			ptr.store %name, %self.name : !ivy.id, ptr
+			ptr.store %age, %self.age : !ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.msgh.object test(param:%data, _:%extra) -> void {
+			%0 = ivy.string-builder.begin
+
+			ivy.string-builder.add %0 << "Received "
+			ivy.string-builder.add %0 << %data : !ivy.id
+			ivy.string-builder.add %0 << ", "
+			ivy.string-builder.add %0 << %extra : !ivy.id
+
+			%1 = ivy.string-builder.end %0 -> !ivy.id
+
+			%2 = ptr.load %cout : ptr -> !ivy.id
+			ivy.msg.send to %2, put:%1 -> void
+			func.return : ()
+		}
+
+		ivy.msgh.object name -> !ivy.id {
+			%0 = ptr.load %self.name : ptr -> !ivy.id
+			func.return %0 : !ivy.id
+		}
+
+		ivy.msgh.object age -> !ivy.id {
+			%0 = ptr.load %self.age : ptr -> !ivy.id
+			func.return %0 : !ivy.id
+		}
+
+		ivy.msgh.object age-in-months -> !ivy.id {
+			%0 = ptr.load %self.age : ptr -> !ivy.id
+			%1 = arith.constant 12 : i32
+			%multmp = ivy.mul %0, %1 : (!ivy.id, i32) -> !ivy.id
+			func.return %multmp : !ivy.id
+		}
+
+		ivy.msgh.object set-name:%name -> void {
+			ptr.store %name, %self.name : !ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.msgh.object set-age:%age -> void {
+			ptr.store %age, %self.age : !ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.msgh.object set-age:%age in-units:%units -> void {
+			scf.switch : () -> void
+			case {
+				%0 = ivy.atom "years"
+				%cmptmp.0 = ivy.cmp eq %age, %0 : (!ivy.id, !ivy.atom) -> i1
+				scf.switch-condition %cmptmp.0
+			} then {
+				ptr.store %age, %self.age : !ivy.id, ptr
+				scf.switch-break : ()
+			} case {
+				%1 = ivy.atom "months"
+				%cmptmp.1 = ivy.cmp eq %age, %1 : (!ivy.id, !ivy.atom) -> i1
+				scf.condition %cmptmp.1
+			} then {
+				%d0 = arith.constant 12 : i32
+				%divtmp.0 = ivy.div %age, %d0 : (!ivy.id, i32) -> !ivy.id
+				ptr.store %divtmp.0, %self.age : !ivy.id, ptr
+				scf.switch-break : ()
+			} case {
+				%2 = ivy.atom "days"
+				%cmptmp.2 = ivy.cmp eq %age, %2 : (!ivy.id, !ivy.atom) -> i1
+				scf.condition %cmptmp.2
+			} then {
+				%d1 = arith.constant 365 : i32
+				%divtmp.1 = ivy.div %age, %d1 : (!ivy.id, i32) -> !ivy.id
+				ptr.store %divtmp.1, %self.age : !ivy.id, ptr
+				scf.switch-break : ()
+			} default {
+				%d2 = arith.constant 0 : i32
+				scf.switch-break : ()
+			}
+
+			func.return : ()
+		}
+
+		ivy.msgh.object get-age-in-units:%units -> !ivy.id {
+			%result = scf.switch : () -> !ivy.id
+			case {
+				%0 = ivy.atom "years"
+				%cmptmp.0 = ivy.cmp eq %age, %0 : (!ivy.id, !ivy.atom) -> i1
+				scf.switch-condition %cmptmp.0
+			} then {
+				%v0 = ptr.load %self.age : ptr -> !ivy.id
+				scf.switch-break %v0 : !ivy.id
+			} case {
+				%1 = ivy.atom "months"
+				%cmptmp.1 = ivy.cmp eq %age, %1 : (!ivy.id, !ivy.atom) -> i1
+				scf.condition %cmptmp.1
+			} then {
+				%v0 = ptr.load %self.age : ptr -> !ivy.id
+				%d0 = arith.constant 12 : i32
+				%divtmp.0 = ivy.div %v0, %d0 : (!ivy.id, i32) -> !ivy.id
+				scf.switch-break %divtmp.0 : !ivy.id
+			} case {
+				%2 = ivy.atom "days"
+				%cmptmp.2 = ivy.cmp eq %age, %2 : (!ivy.id, !ivy.atom) -> i1
+				scf.condition %cmptmp.2
+			} then {
+				%v1 = ptr.load %self.age : ptr -> !ivy.id
+				%d1 = arith.constant 365 : i32
+				%divtmp.1 = ivy.div %v1, %d1 : (!ivy.id, i32) -> !ivy.id
+				scf.switch-break %divtmp.1 : !ivy.id
+			} default {
+				%d2 = arith.constant 0 : i32
+				scf.switch-break %d2 : !ivy.id
+			}
+
+			func.return %result : !ivy.id
+		}
+
+		ivy.object-prop example-property
+		get {
+			%0 = ptr.load %self.val : ptr -> !ivy.id
+			func.return %0 : !ivy.id
+		}
+		set (%value: !ivy.id) {
+			ptr.store %value, %self.val : !ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.object-prop example-property-2 get {
+			%0 = ptr.load %self.val : ptr -> !ivy.id
+			func.return %0 : !ivy.id
+		} set (%x: !ivy.id) {
+			ptr.store %x, %self.val : !ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.object-prop example-property-3 get {
+			%0 = arith.constant 42 : i32
+			func.return %0 : i32
+		}
+
+		ivy.object-prop example-property-4 get {
+			%0 = ptr.load %self.__example-property-4 : ptr -> !ivy.id
+			func.return %0 : !ivy.id
+		} set (%0: !ivy.id) {
+			ptr.store %0, %self.__example-property-4 : !ivy.id, ptr
+			func.return : ()
+		}
+
+		ivy.object-prop example-property-5 get {
+			%0 = ptr.load %self.__example-property-5 : ptr -> !ivy.id
+			func.return %0 : !ivy.id
+		}
+	}
+
+	ivy.init-text {
+		; p1 = Person new(name:'John Doe', age:34).
+		%Person = ivy.global-ref @Person : ptr
+		%0 = ivy.str.constant "John Doe"
+		%1 = arith.constant 34 : i32
+
+		%2 = ivy.msg.send to %Person, new(name:%0, age:%1) -> !ivy.id
+
+		%p1 = ptr.alloca !ivy.id -> ptr
+		ptr.store %2, %p1 : !ivy.id, ptr
+
+		; p1 set-age:100 in-unit:$months.
+		%3 = ptr.load %p1 : ptr -> !ivy.id
+		%4 = arith.constant 100 : i32
+		%5 = ivy.atom "months"
+		ivy.msg.send to %3, set-age:%4 in-units:%5 -> void
+
+		; p1 test(param:'Hello', 'World').
+		%6 = ptr.load %p1 : ptr -> !ivy.id
+		%7 = ivy.str.constant "Hello"
+		%8 = ivy.str.constant "World"
+		ivy.msg.send to %6, test(param:%7, _:%8) -> void
+
+		; i = 0.
+		%i = ptr.alloca i32 -> ptr
+		%9 = arith.constant 0 : i32
+		ptr.store %9, %i : i32, ptr
+
+		; while i < 100 do
+		scf.while -> void {
+			; i < 100
+			%10 = ptr.load %i : ptr -> i32
+			%11 = arith.constant 100 : i32
+			%cmptmp = ivy.cmp lt %10, %11 : (i32, i32) -> i1
+			scf.condition(%cmptmp)
+		} do {
+			; cout put:'Count is {i}'.
+			%12 = ivy.string-builder.begin
+
+			ivy.string-builder.add %12 << "Count is "
+
+			%14 = ptr.load %i : ptr -> i32
+			ivy.string-builder.add %12 << %14 : i32
+
+			%15 = ivy.string-builder.end %12 -> !ivy.id
+
+			%16 = ptr.load %cout : ptr -> !ivy.id
+			ivy.msg.send to %16, put:%15 -> void
+
+			; i += 2
+			%17 = ptr.load %i : ptr -> i32
+			%18 = arith.constant 2 : i32
+			%addtmp = ivy.add %17, %18 : (i32, i32) -> i32
+			ptr.store %addtmp, %i : i32, ptr
+		}
+
+		; 0 to:100 step:2
+		%19 = arith.constant 0 : i32
+		%20 = arith.constant 100 : i32
+		%21 = arith.constant 2 : i32
+		%22 = ivy.msg.send to %19, to:%20 step:%21 -> !ivy.id
+
+		; for x in 0 to:100 step:2 do
+		ivy.for %x in %22 -> void {
+			%23 = ivy.string-builder.begin
+
+			; 'Count is {x}'
+			ivy.string-builder.add %23 << "Count is "
+			ivy.string-builder.add %23 << %x : !ivy.id
+
+			%25 = ivy.string-builder.end %23 -> !ivy.id
+
+			; cout put:"Count is {x}"
+			%26 = ptr.load %cout : ptr -> !ivy.id
+			ivy.msg.send to %26, put:%25 -> void
+		}
+
+		; 0 to:100 step:2 do:...
+		%27 = arith.constant 0 : i32
+		%28 = arith.constant 100 : i32
+		%29 = arith.constant 2 : i32
+		; [ :i | cout put:'Count: {i}' ]
+		%30 = ivy.lambda %i : (!ivy.id) -> void {
+			%0 = ivy.string-builder.begin
+
+			ivy.string-builder.add %0 << "Count is "
+			ivy.string-builder.add %0 << %i : !ivy.id
+
+			%2 = ivy.string-builder.end %0 -> !ivy.id
+
+			%cout = ivy.global-ref @cout -> ptr
+			%3 = ptr.load %cout : ptr -> !ivy.id
+			ivy.msg.send to %3, put:%2 -> void
+		}
+
+		; 0 to:100 step:2 do:[ :i | cout put:'Count: {i}' ].
+		ivy.msg.send to %27, to:%28 step:%29 do:%30
+
+		; q = 32.
+		%q = ptr.alloca i32 -> ptr
+		%31 = arith.constant 32 : i32
+		ptr.store %31, %q : i32, ptr
+
+		; l = [ cout put:'Value of q is {q}' ].
+		%l = ptr.alloca !ivy.id
+		%32 = ptr.load %q : ptr -> i32
+		%33 = ivy.lambda (%env.q = %32) : () -> void {
+			%0 = ivy.string-builder.begin
+
+			ivy.string-builder.add %0 << "Value of q is "
+			ivy.string-builder.add %0 << %env.q : !ivy.id
+
+			%2 = ivy.string-builder.end %0 -> !ivy.id
+
+			%cout = ivy.global-ref @cout -> ptr
+			%3 = ptr.load %cout : ptr -> !ivy.id
+			ivy.msg.send to %3, put:%2 -> void
+		}
+
+		ptr.store %33, %l : !ivy.id, ptr
+
+		; q = 64.
+		%34 = arith.constant 64 : i32
+		ptr.store %34, %q : i32, ptr
+
+		; l call.
+		%35 = ptr.load %l : ptr -> !ivy.id
+		ivy.msg.send to %35, call -> void
+
+		%j = ptr.alloca i32 -> ptr
+
+		%36 = arith.constant 32 : i32
+		ptr.store %36, %j : i32, ptr
+
+		%37 = ptr.load %i : ptr -> i32
+		%38 = ptr.load %j : ptr -> i32
+
+		%cmptmp = arith.cmp lt %37, %38 : (i32, i32) -> i1
+
+		%39 = ivy.lambda : () -> void {
+			%cout = ivy.global-ref @cout -> ptr
+			%0 = ivy.str.constant "True!"
+			%1 = ptr.load %cout : ptr -> !ivy.id
+			ivy.msg.send to %1, put:%0 -> void
+		}
+
+		%40 = ivy.lambda : () -> void {
+			%cout = ivy.global-ref @cout -> ptr
+			%0 = ivy.str.constant "False!"
+			%1 = ptr.load %cout : ptr -> !ivy.id
+			ivy.msg.send to %1, put:%0 -> void
+		}
+
+		ivy.msg.send to %cmptmp, if:%39 else:%40 -> void
+
+		%41 = ptr.load %i : ptr -> i32
+		%42 = ptr.load %j : ptr -> i32
+
+		%cmptmp.0 = arith.cmp lt %41, %42 : (i32, i32) -> i1
+
+		scf.if %cmptmp.0 -> void {
+			%43 = ivy.str.constant "True!"
+			%44 = ptr.load %cout : ptr -> !ivy.id
+			ivy.msg.send to %44, put:%43 -> void
+		}
+
+		; pkg = {}.
+		%pkg = ptr.alloca !ivy.id -> ptr
+
+		%Package = ivy.global-ref @std.lang.Package -> ptr
+
+		%45 = ivy.msg.send to %Package, new -> !ivy.id
+		ptr.store %45, %pkg : !ivy.id, ptr
+
+		; pkg[0] = 16.
+		%46 = ptr.load %pkg : ptr -> !ivy.id
+		%47 = arith.constant 0 : i32
+		%48 = arith.constant 16 : i32
+
+		ivy.msg.send to %46, at:%47 put:%48 -> void
+
+		; tuple = (32, 'a string')
+		%tuple = ptr.alloca !ivy.id -> ptr
+
+		%49 = arith.constant 32 : i32
+		%50 = ivy.str.constant "a string"
+
+		%51 = ivy.tuple.create %49, %50 : (i32, !ivy.id) -> !ivy.id
+
+		ptr.store %51, %tuple : !ivy.id, ptr
+
+		%52 = ptr.load %tuple : ptr -> !ivy.id
+		%53 = ivy.msg.send to %52, get-iterator -> !ivy.id
+
+		ivy.for %54 in %53 -> void {
+			%key = ivy.tuple.get-item %54[0] : (!ivy.id, i32) -> !ivy.id
+			%val = ivy.tuple.get-item %54[1] : (!ivy.id, i32) -> !ivy.id
+
+			; '{key} -> {val}'
+			%55 = ivy.string-builder.begin
+
+			ivy.string-builder.add %55 << %key : !ivy.id
+			ivy.string-builder.add %55 << " -> "
+			ivy.string-builder.add %55 << %val : !ivy.id
+
+			%57 = ivy.string-builder.end %55 -> !ivy.id
+
+			; cout put:'{key} -> {val}'
+			%58 = ptr.load %cout : ptr -> !ivy.id
+			ivy.msg.send to %58, put:%57 -> void
+		}
+
+		; _ = 3 * 2.
+		%59 = arith.constant 3 : i32
+		%60 = arith.constant 2 : i32
+		%multmp = arith.mul %59, %60 : (i32, i32) -> i32
+
+		; a = (32, 64).
+		%a = ptr.alloca !ivy.id -> ptr
+
+		%61 = arith.constant 32 : i32
+		%62 = arith.constant 64 : i32
+		%63 = ivy.tuple.create %61, %62 : (i32, i32) -> !ivy.id
+
+		ptr.store %63, %a : !ivy.id, ptr
+
+		%v = ptr.alloca !ivy.id -> ptr
+
+		%64 = ptr.load %a : ptr -> !ivy.id
+		%65 = ivy.tuple.get-item %64[1] : !ivy.id -> !ivy.id
+
+		ptr.store %65, %v : !ivy.id, ptr
+
+		%66 = ivy.atom "err:number-format"
+
+		ivy.try -> void {
+
+		} catch (%ex = %66), %data {
+
+		} catch-all %ex, %data {
+
+		}
+
+		%67 = ivy.lambda : () -> void {
+			%v = ptr.alloca !ivy.id -> ptr
+			%Int = ivy.global-ref @Int -> ptr
+			%0 = ivy.str.constant "342"
+
+			%1 = ivy.msg.send to %Int, parse:%0
+
+			ptr.store %1, %v : !ivy.id, ptr
+		}
+
+		%68 = ivy.lambda %err, %data : (!ivy.id, !ivy.id) -> void {
+			%0 = ivy.string-builder.begin
+
+			ivy.string-builder.add %0 << "Cannot parse integer string ("
+			ivy.string-builder.add %0 << %err : !ivy.id
+			ivy.string-builder.add %0 << ")"
+
+			%3 = ivy.string-builder.end %0 -> !ivy.id
+
+			; cout put:'{key} -> {val}'
+			%4 = ptr.load %cout : ptr -> !ivy.id
+			ivy.msg.send to %4, put:%3 -> void
+		}
+
+		%69 = ivy.lambda %err, %data : (!ivy.id, !ivy.id) -> void {
+			%0 = ivy.string-builder.create
+
+			ivy.string-builder.add %0 << "Error "
+			ivy.string-builder.add %0 << %err : !ivy.id
+			ivy.string-builder.add %0 << " occurred ("
+			ivy.string-builder.add %0 << %data : !ivy.id
+			ivy.string-builder.add %0 << ")"
+
+			%4 = ivy.string-builder.end %0 -> !ivy.id
+
+			; cout put:'{key} -> {val}'
+			%5 = ptr.load %cout : ptr -> !ivy.id
+			ivy.msg.send to %5, put:%4 -> void
+		}
+
+		%70 = ivy.atom "err:number-format"
+		ivy.msg.send to %67, on:%70 do:%68 -> !ivy.id
+		ivy.msg.send to %67, on-error:%69 -> void
+		ivy.msg.send to %67, call -> void
+	}
+}

doc/sample/ir/Simple.1.mie

@@ -0,0 +1,46 @@
+meta.source-filename "Simple.im"
+
+ivy.package-scope "net.doorstuck.test"
+
+ivy.package-ref "std.io"
+
+ivy.module {
+	ivy.init-text {
+		%0 = i32.constant 32
+		%1 = i32.constant 64
+		%multmp = arith.mul %0, %1 : (i32, i32) -> i32
+
+		%y = ptr.alloca i32
+		ptr.store %multmp, %y : i32, ptr
+
+		%2 = i32.constant 64
+		%3 = i32.constant 4
+		%divtmp = arith.div %2, %3 : (i32, i32) -> i32
+
+		%z = ptr.alloca i32
+		ptr.store %divtmp, %z : i32, ptr
+
+		%4 = ptr.load %y : ptr -> i32
+		%5 = ptr.load %z : ptr -> i32
+		%addtmp = arith.add %4, %5 : (i32, i32) -> i32
+
+		%x = ptr.alloca i32
+		ptr.store %addtmp, %x : i32, ptr
+
+		%cout = ivy.global-ref @cout -> ptr
+
+		%6 = ivy.string-builder.begin
+		ivy.string-builder.add %6 << "Answer: "
+
+		%7 = ptr.load %x : ptr -> i32
+		ivy.string-builder.add %6 << %7 : i32
+
+		%8 = ivy.string-builder.end %6 -> #ivy.id
+
+		%9 = ptr.load %cout : ptr -> #ivy.id
+
+		ivy.msg.send to %9, put:%8 -> void
+
+		func.return : ()
+	}
+}

doc/sample/ir/Simple.2.mie

@@ -0,0 +1,50 @@
+meta.source-filename "Simple.im"
+
+ivy.package-scope "net.doorstuck.test"
+
+ivy.package-ref "std.io"
+
+ivy.module {
+	%cout = ivy.global-ref @cout -> ptr
+	%StringBuilder = ivy.global-ref @std.lang.StringBuilder -> ptr
+
+	%.str.0 = ivy.str.constant "Answer: "
+
+	ivy.init-text {
+		%0 = i32.constant 32
+		%1 = i32.constant 64
+		%multmp = arith.mul %0, %1 : (i32, i32) -> i32
+
+		%y = ptr.alloca i32
+		ptr.store %multmp, %y : i32, ptr
+
+		%2 = i32.constant 64
+		%3 = i32.constant 4
+		%divtmp = arith.div %2, %3 : (i32, i32) -> i32
+
+		%z = ptr.alloca i32
+		ptr.store %divtmp, %z : i32, ptr
+
+		%4 = ptr.load %y : ptr -> i32
+		%5 = ptr.load %z : ptr -> i32
+		%addtmp = arith.add %4, %5 : (i32, i32) -> i32
+
+		%x = ptr.alloca i32
+		ptr.store %addtmp, %x : i32, ptr
+
+		%10 = ptr.load %StringBuilder : ptr -> #ivy.id
+
+		ivy.msg.send to %10, append:%.str.0 -> void
+
+		%7 = ptr.load %x : ptr -> i32
+		ivy.msg.send to %10, append:%7 -> void
+
+		%8 = ivy.msg.send to %10, to-string -> #ivy.id
+
+		%9 = ptr.load %cout : ptr -> #ivy.id
+
+		ivy.msg.send to %9, put:%8 -> void
+
+		func.return : ()
+	}
+}

doc/sample/ir/Simple.3.mie

@@ -0,0 +1,63 @@
+meta.source-filename "Simple.im"
+
+ivy.package-scope "net.doorstuck.test"
+
+ivy.package-ref "std.io"
+
+ivy.module {
+	%cout = ivy.pool.ident @cout -> #ivy.pool-slot
+	%StringBuilder = ivy.pool.ident @std.lang.StringBuilder -> #ivy.pool-slot
+
+	%.str.0 = ivy.pool.string "Answer: " -> #ivy.pool-slot
+
+	%.sel.o-append = ivy.pool.selector append -> #ivy.pool-slot
+	%.sel.o-to-string = ivy.pool.selector to-string -> #ivy.pool-slot
+	%.sel.o-put = ivy.pool.selector put -> #ivy.pool-slot
+
+	ivy.init-text {
+		%0 = i32.constant 32
+		%1 = i32.constant 64
+		%multmp = *ivy.MUL %0, %1 : (i32, i32) -> i32
+
+		*ivy.PUSH %multmp : i32
+		%y = ivy.bp-slot 0 -> #ivy.bp-slot
+
+		%2 = i32.constant 64
+		%3 = i32.constant 4
+		%divtmp = *ivy.DIV %2, %3 : (i32, i32) -> i32
+
+		*ivy.PUSH %divtmp : i32
+		%z = ivy.bp-slot 1 -> #ivy.bp-slot
+
+		%4 = *ivy.LDR-BP %y : #ivy.bp-slot -> i32
+		%5 = *ivy.LDR-BP %z : #ivy.bp-slot -> i32
+		%addtmp = *ivy.ADD %4, %5 : (i32, i32) -> i32
+
+		*ivy.PUSH %addtmp : i32
+		%x = ivy.bp-slot 2 -> #ivy.bp-slot
+
+		%10 = *ivy.LDR-POOL %StringBuilder : #ivy.pool-slot -> #ivy.id
+
+		%20 = *ivy.LDR-POOL %.sel.o-append : #ivy.pool-slot -> #ivy.id
+		%21 = *ivy.LDR-POOL %.str.0 : #ivy.pool-slot -> #ivy.id
+		*ivy.PUSH %21 : #ivy.id
+		*ivy.MSG-I %10, %20, 1 : (#ivy.id, #ivy.id, i32) -> void
+
+		%7 = *ivy.LDR-BP %x : ptr -> i32
+		*ivy.PUSH %7 : i32
+		%22 = *ivy.LDR-POOL %.sel.o-append : #ivy.pool-slot -> #ivy.id
+		*ivy.MSG-I %10, %22, 1 : (#ivy.id, #ivy.id, i32) -> void
+
+		%23 = *ivy.LDR-POOL %.sel.o-to-string : #ivy.pool-slot -> #ivy.id
+		%8 = *ivy.MSG-I %10, %23, 0 : (#ivy.id, #ivy.id, i32) -> #ivy.id
+
+		%9 = *ivy.LDR-POOL %cout : #ivy.pool-slot -> #ivy.id
+		%24 = *ivy.LDR-POOL %.sel.o-put : #ivy.pool-slot -> #ivy.id
+
+		*ivy.PUSH %8 : #ivy.id
+
+		*ivy.MSG-I %9, %24, 1 : (#ivy.id, #ivy.id, i32) -> void
+
+		*ivy.RET-N : ()
+	}
+}

doc/sample/ir/Simple.4.mie

@@ -0,0 +1,62 @@
+meta.source-filename "Simple.im"
+
+ivy.package-scope "net.doorstuck.test"
+
+ivy.package-ref "std.io"
+
+ivy.module {
+	%cout = ivy.pool.ident @cout -> #ivy.pool-slot
+	%StringBuilder = ivy.pool.ident @std.lang.StringBuilder -> #ivy.pool-slot
+
+	%.str.0 = ivy.pool.string "Answer: " -> #ivy.pool-slot
+
+	%.sel.o-append = ivy.pool.selector append -> #ivy.pool-slot
+	%.sel.o-to-string = ivy.pool.selector to-string -> #ivy.pool-slot
+	%.sel.o-put = ivy.pool.selector put -> #ivy.pool-slot
+
+	ivy.init-text {
+		%0 = i32.constant 32
+		%1 = i32.constant 64
+		%multmp = *ivy.MUL %0, %1 : (i32, i32) -> i32
+
+		*ivy.PUSH %multmp : i32
+		%y = ivy.bp-slot 0 -> #ivy.bp-slot
+
+		%2 = i32.constant 64
+		%3 = i32.constant 4
+		%divtmp = *ivy.DIV %2, %3 : (i32, i32) -> i32
+
+		*ivy.PUSH %divtmp : i32
+		%z = ivy.bp-slot 1 -> #ivy.bp-slot
+
+		%4 = *ivy.LDR %y : #ivy.bp-slot -> i32
+		%5 = *ivy.LDR %z : #ivy.bp-slot -> i32
+		%addtmp = *ivy.ADD %4, %5 : (i32, i32) -> i32
+
+		*ivy.PUSH %addtmp : i32
+		%x = ivy.bp-slot 2 -> #ivy.bp-slot
+
+		%10 = *ivy.LDR %StringBuilder : #ivy.pool-slot -> #ivy.id
+
+		%20 = *ivy.LDR %.sel.o-append : #ivy.pool-slot -> #ivy.id
+		%21 = *ivy.LDR %.str.0 : #ivy.pool-slot -> #ivy.id
+		*ivy.PUSH %21 : #ivy.id
+		*ivy.MSG %10, %20, 1 : (#ivy.id, #ivy.id, i32) -> void
+
+		%7 = *ivy.LDR %x : ptr -> i32
+		*ivy.PUSH %7 : i32
+		*ivy.MSG %10, %20, 1 : (#ivy.id, #ivy.id, i32) -> void
+
+		%23 = *ivy.LDR %.sel.o-to-string : #ivy.pool-slot -> #ivy.id
+		%8 = *ivy.MSG %10, %23, 0 : (#ivy.id, #ivy.id, i32) -> #ivy.id
+
+		%9 = *ivy.LDR %cout : #ivy.pool-slot -> #ivy.id
+		%24 = *ivy.LDR %.sel.o-put : #ivy.pool-slot -> #ivy.id
+
+		*ivy.PUSH %8 : #ivy.id
+
+		*ivy.MSG %9, %24, 1 : (#ivy.id, #ivy.id, i32) -> void
+
+		*ivy.RET-N : ()
+	}
+}

doc/sample/ir/Simple.5.mie

@@ -0,0 +1,68 @@
+meta.source-filename "Simple.im"
+
+ivy.package-scope "net.doorstuck.test"
+
+ivy.package-ref "std.io"
+
+ivy.module {
+	%cout = ivy.pool.ident @cout -> #ivy.pool-slot
+	%StringBuilder = ivy.pool.ident @std.lang.StringBuilder -> #ivy.pool-slot
+
+	%.str.0 = ivy.pool.string "Answer: " -> #ivy.pool-slot
+
+	%.sel.o-append = ivy.pool.selector append -> #ivy.pool-slot
+	%.sel.o-to-string = ivy.pool.selector to-string -> #ivy.pool-slot
+	%.sel.o-put = ivy.pool.selector put -> #ivy.pool-slot
+
+	%.i.0 = i32.constant 0
+	%.i.1 = i32.constant 1
+	%.i.4 = i32.constant 4
+	%.i.32 = i32.constant 32
+	%.i.64 = i32.constant 64
+
+	ivy.init-text {
+		$X0		= *ivy.LDR		%.i.32 -> i32
+		$X1		= *ivy.LDR		%.i.64 -> i32
+		$X2		= *ivy.MUL		$X0, $X1 : (i32, i32) -> i32
+
+				  *ivy.PUSH		$X2 : i32
+		%.bp.0	= ivy.bp-slot	0 -> #ivy.bp-slot
+
+		$X4		= *ivy.LDR		%.i.64 -> i32
+		$X5		= *ivy.LDR		%.i.4 -> i32
+		$X6		= *ivy.DIV		$X4, $X5 : (i32, i32) -> i32
+
+				  *ivy.PUSH		$X6 : i32
+		%.bp.1	= ivy.bp-slot	1 -> #ivy.bp-slot
+
+		$X8		= *ivy.LDR		%.bp.0 : #ivy.bp-slot -> i32
+		$X9		= *ivy.LDR		%.bp.1 : #ivy.bp-slot -> i32
+		$X10	= *ivy.ADD		$X8, $X9 : (i32, i32) -> i32
+
+				  *ivy.PUSH		$X10 : i32
+		%.bp.2	= ivy.bp-slot	2 -> #ivy.bp-slot
+
+		%10		= *ivy.LDR		%StringBuilder : #ivy.pool-slot -> #ivy.id
+
+		%20		= *ivy.LDR		%.sel.o-append : #ivy.pool-slot -> #ivy.id
+		%21		= *ivy.LDR		%.str.0 : #ivy.pool-slot -> #ivy.id
+				  *ivy.PUSH		%21 : #ivy.id
+				  *ivy.MSG		%10, %20, %.i.1 : (#ivy.id, #ivy.id, i32) -> void
+
+		%7		= *ivy.LDR		%.bp.2 : ptr -> i32
+				  *ivy.PUSH		%7 : i32
+				  *ivy.MSG		%10, %20, %.i.1 : (#ivy.id, #ivy.id, i32) -> void
+
+		%23		= *ivy.LDR		%.sel.o-to-string : #ivy.pool-slot -> #ivy.id
+		%8		= *ivy.MSG		%10, %23, %.i.0 : (#ivy.id, #ivy.id, i32) -> #ivy.id
+
+		%9		= *ivy.LDR		%cout : #ivy.pool-slot -> #ivy.id
+		%24		= *ivy.LDR		%.sel.o-put : #ivy.pool-slot -> #ivy.id
+
+				  *ivy.PUSH		%8 : #ivy.id
+
+				  *ivy.MSG		%9, %24, %.i.1 : (#ivy.id, #ivy.id, i32) -> void
+
+				  *ivy.RET-N : ()
+	}
+}

doc/sample/ir/for-loop-1.mie

@@ -1,6 +1,7 @@
+; Comment
 func.func @reduce(%buffer: memref<1024*f32>, %lb: index, %ub: index, %step: index) -> f32 {
 	; Initial sum set to 0.
-	%sum.0 = arith.constant 0.0 : f32
+	%sum.0 = f32.constant 0.0
 	; iter_args binds initial values to the loop's region arguments.
 	%sum = scf.for %iv = %lb to %ub step %step iter-args(%sum.iter = %sum.0) -> (f32) {
 		%t = memref.load %buffer[%iv] : memref<1024*f32>

doc/sample/ir/for-loop-2.mie

@@ -1,6 +1,6 @@
 func.func @reduce(%buffer: memref<1024*f32>, %lb: index, %ub: index, %step: index) -> f32 {
 	; Initial sum set to 0.
-	%sum.0 = *arith.constant() {value = 0.0 : f32} : () -> f32
+	%sum.0 = *f32.constant() {value = 0.0 : f32} : () -> f32
 
 	; iter_args binds initial values to the loop's region arguments.
 	%sum = scf.for %iv = %lb to %ub step %step iter_args(%sum.iter = %sum.0) -> (f32) {

doc/sample/ir/for-loop-3.mie

@@ -0,0 +1,20 @@
+~func.func() ({
+^entry(%buffer: memref<1024*f32>, %lb: index, %ub: index, %step: index):
+	; Initial sum set to 0.
+	%sum.0 = ~f32.constant() {value = 0.0 : f32} : () -> f32
+
+	; iter_args binds initial values to the loop's region arguments.
+	%sum = ~scf.for(%lb, %ub, %step) -> (f32) {
+	^for.entry(%iv: index, %sum.iter: f32):
+		%t = ~memref.load(%buffer, %iv) : (memref<1024*f32>, index) -> f32
+		%sum.next = Zarith.addf(%sum.iter, %t) : (f32, f32) -> f32
+		; Yield current iteration sum to next iteration %sum.iter or to %sum
+		; if final iteration.
+		%iv.next = ~arith.addi(%iv, %step) : (index, index) -> index
+		%stop = ~arith.cmpi(%iv.next, %ub) {predicate = 9 : i64} : (index, index) -> i1
+		~cf.br-cond(%stop) [ ^for.end, ^for.entry:(%iv.next: index, %sum.next: f32) ] : () -> ()
+	}
+^for.end:
+	~func.return(%sum) : (f32) -> ()
+}) {sym_name = "reduce"} : (memref<1024*i32>, index, index, index) -> f32
+

doc/sample/ir/for-loop-4.mie

@@ -0,0 +1,25 @@
+~func.func() ({
+^entry(%buffer: memref<1024*f32>, %lb: index, %ub: index, %step: index):
+	; Initial sum set to 0.
+	%sum.0 = ~f32.constant() {value = 0.0 : f32} : () -> f32
+	; iter_args binds initial values to the loop's region arguments.
+	;%sum = "scf.for"(%lb, %ub, %step) -> (f32) {
+	~cf.br [ ^for.entry(%lb: index, %sum.0: f32) ] : () -> ()
+
+^for.entry(%iv: index, %sum.iter: f32):
+	%t = ~memref.load(%buffer, %iv) : (memref<1024*f32>, index) -> f32
+	%sum.next = ~arith.addf(%sum.iter, %t) : (f32, f32) -> f32
+
+	~cf.br [ ^for.cond:(%iv: index, %sum.next: f32) ] : () -> ()
+
+^for.cond(%iv: index, %sum.next: f32):
+	; Yield current iteration sum to next iteration %sum.iter or to %sum
+	; if final iteration.
+	%iv.next = ~arith.addi(%iv, %step) : (index, index) -> index
+	%stop = ~arith.cmpi(%iv.next, %ub) {predicate = 9 : i64} : (index, index) -> i1
+	~cf.br-cond(%stop) [ ^for.end, ^for.entry:(%iv.next: index, %sum.next: f32) ] : () -> ()
+
+^for.end(%sum: f32):
+	~func.return(%sum) : (f32) -> ()
+}) {sym_name = "reduce"} : (memref<1024*f32>, index, index, index) -> f32
+

doc/sample/ir/lex-test.mie

@@ -0,0 +1,14 @@
++graph.name \
+%vreg.name
+$mreg.name
+^block.name
+#type.name
+@symbol.name
+abc.def
+21.5
+"a String"
+index
+memref
+1024*f32
+	: = , - * + % $ ^ # @ { } [ ] ( ) < > ->
+abc

doc/sample/ir/parse-test.mie

@@ -0,0 +1,26 @@
+~builtin.module() ({
+	~func.func() ({
+	^entry(%buffer: i32, %lb: index, %ub: index, %step: index):
+		; Initial sum set to 0.
+		%sum.0 = ~arith.constant() {value = 0.0 : f32} : () -> f32
+		; iter_args binds initial values to the loop's region arguments.
+		;%sum = "scf.for"(%lb, %ub, %step) -> (f32) {
+		~cf.br() [ ^for.entry:(%lb: index, %sum.0: f32) ] : () -> ()
+
+	^for.entry(%iv: index, %sum.iter: f32):
+		%t, %x, %z = ~memref.load(%buffer, %iv) : (i32, index) -> (f32, i1, i1)
+		%sum.next = ~arith.addf(%sum.iter, %t) : (f32, f32) -> f32
+
+		~cf.br() [ ^for.cond:(%iv: index, %sum.next: f32) ] : () -> ()
+
+	^for.cond(%iv2: index, %sum.next2: f32):
+		; Yield current iteration sum to next iteration %sum.iter or to %sum
+		; if final iteration.
+		%iv.next = ~arith.addi(%iv, %step) : (index, index) -> index
+		%stop = ~arith.cmpi(%iv.next, %ub) { predicate = 9 } : (index, index) -> i1
+		~cf.br-cond(%stop) [ ^for.end, ^for.entry:(%iv.next: index, %sum.next: f32) ] : (i1) -> ()
+
+	^for.end(%sum: f32):
+		~func.return(%sum) : (f32) -> ()
+	}) {sym_name = "reduce", function_type = (i32, index, index, index) -> f32 } : () -> ()
+}) : () -> ()

mie.vim/syntax/mie.vim

@@ -5,41 +5,52 @@ endif
 let s:save_cpo = &cpoptions
 set cpoptions&vim
 setlocal iskeyword+=-
+setlocal shiftwidth=4
+setlocal tabstop=4
 
-syn keyword	mieUnspecifiedKeyword	to step iter-args
+syn keyword	mieUnspecifiedKeyword
+			\ to step iter-args get set
+			\ case then default
 syn keyword	mieInstructionFlag
 			\ eq gt ge lt le
 syn match	mieRegister		"%[0-9]\>"
 syn match	mieRegister		"%[1-9][0-9]\+\>"
 syn match	mieRegister		"%[A-Za-z_\-\.][A-Za-z0-9_\-\.]*\>"
+syn match	mieMachineRegister	"$[0-9]\>"
+syn match	mieMachineRegister	"$[1-9][0-9]\+\>"
+syn match	mieMachineRegister	"$[A-Za-z_\-\.][A-Za-z0-9_\-\.]*\>"
 syn match	mieIdentifier		/@\(\w\+\)\(\.\(\w\+\)\)*\>/
 syn match	mieIdentifier		/@\.\(\w\+\)\(\.\(\w\+\)\)*\>/
 syn match	mieBlockIdentifier	/\^\(\w\+\)\(\.\(\w\+\)\)*/
 syn match	mieBlockLabel		/\^\(\w\+\)\(\.\(\w\+\)\)*\:/
-syn keyword	mieBuiltinType		void index
-syn keyword	mieBuiltinType		f16 f32 f64 f80 f128
+syn keyword	mieBuiltinType		void
 " Use syn match for type names that are ALSO dialect names, to ensure that
 " dialect operations are still matched as such.
 syn match	mieBuiltinType		/\<memref\>/
-syn match	mieBuiltinType		"i[0-9]\>"
-syn match	mieBuiltinType		"i[1-9][0-9]\+\>"
-syn match	mieDialectType		/#[A-Za-z][A-Za-z0-9\-]*\(\.[A-Za-z][A-Za-z0-9\-]*\)\+/
+syn match	mieBuiltinType		/\<ptr\>/
+syn match	mieBuiltinType		/\<index\>/
+syn match	mieBuiltinType		"\<[if][0-9]\>"
+syn match	mieBuiltinType		"\<[if][1-9][0-9]\+\>"
+syn match	mieDialectType		/![A-Za-z][A-Za-z0-9\-]*\(\.[A-Za-z][A-Za-z0-9\-]*\)\+/
+syn match	mieDialectAttribute	/#[A-Za-z][A-Za-z0-9\-]*\(\.[A-Za-z][A-Za-z0-9\-]*\)\+/
 
+syn match	mieInstruction		/\*[A-Za-z][A-Za-z0-9\-]*\(\.[A-Za-z][A-Za-z0-9\-]*\)\+\([>\*]\)\@!\>/
+syn match	mieGenericOperation	/\~[A-Za-z][A-Za-z0-9\-]*\(\.[A-Za-z][A-Za-z0-9\-]*\)\+\([>\*]\)\@!\>/
+syn match	mieGraphOperation	/+[A-Za-z][A-Za-z0-9\-]*\(\.[A-Za-z][A-Za-z0-9\-]*\)\+\([>\*]\)\@!\>/
 syn match	mieCustomOperation	/\<[A-Za-z][A-Za-z0-9\-]*\(\.[A-Za-z][A-Za-z0-9\-]*\)\+\>/
-syn match	mieGenericOperation	/\*[A-Za-z][A-Za-z0-9\-]*\(\.[A-Za-z][A-Za-z0-9\-]*\)\+\([>\*]\)\@!\>/
 
 syn match	mieAttributeName	/\<[A-Za-z][A-Za-z0-9\-_\.]*\(\s*=\)\@=\>/
 
 syn region	mieString		start=+"+ end=+"\%(u8\)\=+ end=+$+ extend
 
-syn match	mieFloat		/[0-9]\+\.[0-9]\+/
-syn match	mieFloat		/-[0-9]\+\.[0-9]\+/
-syn match	mieFloat		/+[0-9]\+\.[0-9]\+/
+syn match	mieFloat		/\<[0-9]\+\.[0-9]\+/
+syn match	mieFloat		/\<-[0-9]\+\.[0-9]\+/
+syn match	mieFloat		/\<+[0-9]\+\.[0-9]\+/
 
-syn match	mieInteger		/[0-9]\+\(\.\)\@!\>/
-syn match	mieInteger		/-[0-9]\+\(\.\)\@!\>/
-syn match	mieInteger		/0x[:xdigit:]\+\>/
-syn match	mieInteger		/-0x[:xdigit:]\+\>/
+syn match	mieInteger		/\<[0-9]\+\(\.\)\@!\>/
+syn match	mieInteger		/\<-[0-9]\+\(\.\)\@!\>/
+syn match	mieInteger		/\<0x[:xdigit:]\+\>/
+syn match	mieInteger		/\<-0x[:xdigit:]\+\>/
 
 syn match	mieIntegerDimension	/[0-9]\+x/
 syn match	mieIntegerDimension	/0x[:xdigit:]\+x/
@@ -55,12 +66,9 @@ syn match	mieBraces		"[{}]" display
 syn match	mieAngleBrackets	"[<>]" display
 syn match	mieOperator		"[=:]" display
 syn match	mieOperator		"->" display
-syn match	ivyPropertySymbol	"\$" display
 
 " The default highlighting.
 hi def link	mieUnspecifiedKeyword	Keyword
-hi def link	ivyPropertySymbol	Statement
-
 hi def link	mieInteger		Number
 hi def link	mieFloat		Number
 
@@ -70,14 +78,18 @@ hi def link	mieBrackets		Delimiter
 hi def link	mieAngleBrackets	StorageClass
 
 hi def link 	mieDialectType		Type
+hi def link 	mieDialectAttribute	@attribute
 
 hi def link 	mieGenericOperation	@function.builtin
+hi def link 	mieGraphOperation	Statement
 hi def link 	mieCustomOperation	Function
+hi def link 	mieInstruction		@attribute
 hi def link 	mieInstructionFlag	StorageClass
 hi def link 	mieIdentifier		Identifier
 hi def link 	mieBlockIdentifier	Label
 hi def link 	mieBlockLabel		Label
-hi def link 	mieRegister		@variable
+hi def link 	mieRegister		@variable.parameter
+hi def link 	mieMachineRegister	@variable.builtin
 
 hi def link 	mieString		String
 hi def link 	mieBuiltinType		@type.builtin

mie/CMakeLists.txt

@@ -11,5 +11,5 @@ else ()
 endif ()
 
 target_include_directories(mie PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include/)
-target_link_libraries(mie Bluelib::Core Bluelib::Ds)
+target_link_libraries(mie Bluelib::Core Bluelib::Ds Bluelib::Io)
 target_compile_definitions(mie PRIVATE MIE_EXPORT=1 MIE_STATIC=${MIE_STATIC})

mie/attribute/attribute-definition.c

@@ -0,0 +1,39 @@
+#include <blue/ds/string.h>
+#include <mie/attribute/attribute-definition.h>
+#include <mie/dialect/dialect.h>
+
+struct mie_attribute_definition *mie_attribute_definition_create(
+	struct mie_dialect *parent, const char *name)
+{
+	struct mie_attribute_definition *out = malloc(sizeof *out);
+	if (!out) {
+		return NULL;
+	}
+
+	memset(out, 0x0, sizeof *out);
+
+	out->a_name = b_strdup(name);
+	if (!out->a_name) {
+		free(out);
+		return NULL;
+	}
+
+	out->a_parent = parent;
+
+	b_rope name_rope = B_ROPE_CSTR(name);
+	mie_id_map_put(&parent->d_attributes, &out->a_id, &name_rope);
+
+	return out;
+}
+
+bool mie_attribute_definition_check_name(
+	const struct mie_attribute_definition *def, const char *dialect_name,
+	const char *attrib_name)
+{
+	if (!def || !def->a_parent) {
+		return false;
+	}
+
+	return (!strcmp(def->a_name, attrib_name)
+	        && !strcmp(def->a_parent->d_name, dialect_name));
+}

mie/attribute/attribute-map.c

@@ -0,0 +1,264 @@
+#include <blue/core/hash.h>
+#include <blue/core/queue.h>
+#include <blue/ds/string.h>
+#include <mie/attribute/attribute-map.h>
+
+enum attribute_map_entry_type {
+	ATTRMAP_ENTRY_NONE = 0,
+	ATTRMAP_ENTRY_BUCKET,
+	ATTRMAP_ENTRY_ITEM,
+};
+
+struct attribute_map_entry {
+	enum attribute_map_entry_type e_type;
+	uint64_t e_hash;
+	union {
+		b_btree_node e_node;
+		b_queue_entry e_entry;
+	};
+};
+
+struct attribute_map_bucket {
+	struct attribute_map_entry b_base;
+	b_queue b_items;
+};
+
+struct attribute_map_item {
+	struct attribute_map_entry i_base;
+	char *i_name;
+	const struct mie_attribute *i_value;
+};
+
+static B_BTREE_DEFINE_SIMPLE_INSERT(
+	struct attribute_map_entry, e_node, e_hash, put_entry);
+static B_BTREE_DEFINE_SIMPLE_GET(
+	struct attribute_map_entry, uint64_t, e_node, e_hash, get_entry);
+
+void mie_attribute_map_init(struct mie_attribute_map *map)
+{
+	memset(map, 0x0, sizeof *map);
+}
+
+void mie_attribute_map_cleanup(struct mie_attribute_map *map)
+{
+	/* TODO */
+}
+
+static const struct mie_attribute *get_attribute_from_item(
+	const struct attribute_map_item *item, const char *name)
+{
+	if (!strcmp(item->i_name, name)) {
+		return item->i_value;
+	}
+
+	return NULL;
+}
+
+static const struct mie_attribute *get_attribute_from_bucket(
+	const struct attribute_map_bucket *bucket, const char *name)
+{
+	b_queue_entry *cur = b_queue_first(&bucket->b_items);
+	while (cur) {
+		const struct attribute_map_item *item = b_unbox(
+			const struct attribute_map_item, cur, i_base.e_entry);
+
+		if (!strcmp(item->i_name, name)) {
+			return item->i_value;
+		}
+
+		cur = b_queue_next(cur);
+	}
+
+	return NULL;
+}
+
+static const struct mie_attribute *get_attribute_from_entry(
+	const struct attribute_map_entry *entry, const char *name)
+{
+	switch (entry->e_type) {
+	case ATTRMAP_ENTRY_ITEM:
+		return get_attribute_from_item(
+			(const struct attribute_map_item *)entry, name);
+	case ATTRMAP_ENTRY_BUCKET:
+		return get_attribute_from_bucket(
+			(const struct attribute_map_bucket *)entry, name);
+	default:
+		return NULL;
+	}
+}
+
+const struct mie_attribute *mie_attribute_map_get(
+	const struct mie_attribute_map *map, const char *name)
+{
+	uint64_t name_hash = b_hash_cstr(name);
+	struct attribute_map_entry *entry = get_entry(&map->m_entries, name_hash);
+	if (!entry) {
+		return NULL;
+	}
+
+	return get_attribute_from_entry(entry, name);
+}
+
+static struct attribute_map_bucket *convert_item_to_bucket(
+	struct mie_attribute_map *map, struct attribute_map_item *item)
+{
+	struct attribute_map_bucket *bucket = malloc(sizeof *bucket);
+	if (!bucket) {
+		return NULL;
+	}
+
+	b_btree_delete(&map->m_entries, &item->i_base.e_node);
+	memset(bucket, 0x0, sizeof *bucket);
+
+	bucket->b_base.e_type = ATTRMAP_ENTRY_BUCKET;
+	bucket->b_base.e_hash = item->i_base.e_hash;
+
+	b_queue_push_back(&bucket->b_items, &item->i_base.e_entry);
+	put_entry(&map->m_entries, &bucket->b_base);
+
+	return bucket;
+}
+
+static struct attribute_map_item *create_item(
+	const char *name, uint64_t name_hash, const struct mie_attribute *attrib)
+{
+	struct attribute_map_item *out = malloc(sizeof *out);
+	if (!out) {
+		return NULL;
+	}
+
+	memset(out, 0x0, sizeof *out);
+
+	out->i_value = attrib;
+	out->i_base.e_type = ATTRMAP_ENTRY_ITEM;
+	out->i_base.e_hash = name_hash;
+	out->i_name = b_strdup(name);
+	if (!out->i_name) {
+		free(out);
+		return NULL;
+	}
+
+	return out;
+}
+
+enum mie_status mie_attribute_map_put(
+	struct mie_attribute_map *map, const char *name,
+	const struct mie_attribute *value, enum mie_attribute_map_flags flags)
+{
+	uint64_t name_hash = b_hash_cstr(name);
+	struct attribute_map_entry *entry = get_entry(&map->m_entries, name_hash);
+	struct attribute_map_item *item = NULL;
+	struct attribute_map_bucket *bucket = NULL;
+	enum mie_status status = MIE_SUCCESS;
+
+	if (!entry) {
+		item = create_item(name, name_hash, value);
+		if (!item) {
+			return MIE_ERR_NO_MEMORY;
+		}
+
+		put_entry(&map->m_entries, &item->i_base);
+		return MIE_SUCCESS;
+	}
+
+	if (entry->e_type == ATTRMAP_ENTRY_ITEM) {
+		item = (struct attribute_map_item *)entry;
+		if (!strcmp(item->i_name, name)) {
+			status = MIE_ERR_NAME_EXISTS;
+
+			if (flags & MIE_ATTRMAP_F_REPLACE) {
+				item->i_value = value;
+				status = MIE_SUCCESS;
+			}
+
+			return status;
+		}
+
+		bucket = convert_item_to_bucket(map, item);
+	} else {
+		bucket = (struct attribute_map_bucket *)entry;
+	}
+
+	item = create_item(name, name_hash, value);
+	if (!item) {
+		return MIE_ERR_NO_MEMORY;
+	}
+
+	b_queue_push_back(&bucket->b_items, &item->i_base.e_entry);
+	return MIE_SUCCESS;
+}
+
+enum mie_status mie_attribute_map_iterator_begin(
+	struct mie_attribute_map_iterator *it, const struct mie_attribute_map *map)
+{
+	memset(it, 0x0, sizeof *it);
+	it->_n = b_btree_first(&map->m_entries);
+	if (!it->_n) {
+		return MIE_ERR_NO_DATA;
+	}
+
+	struct attribute_map_entry *entry
+		= b_unbox(struct attribute_map_entry, it->_n, e_node);
+	struct attribute_map_item *item = NULL;
+	struct attribute_map_bucket *bucket = NULL;
+
+	switch (entry->e_type) {
+	case ATTRMAP_ENTRY_ITEM:
+		item = (struct attribute_map_item *)entry;
+		it->it_name = item->i_name;
+		it->it_value = item->i_value;
+		return MIE_SUCCESS;
+	case ATTRMAP_ENTRY_BUCKET:
+		bucket = (struct attribute_map_bucket *)entry;
+		it->_e = b_queue_first(&bucket->b_items);
+		item = b_unbox(struct attribute_map_item, it->_e, i_base.e_entry);
+		it->it_name = item->i_name;
+		it->it_value = item->i_value;
+		return MIE_SUCCESS;
+	default:
+		return MIE_ERR_BAD_STATE;
+	}
+}
+
+enum mie_status mie_attribute_map_iterator_move_next(
+	struct mie_attribute_map_iterator *it)
+{
+	struct attribute_map_entry *next_entry = NULL;
+	struct attribute_map_item *next_item = NULL;
+	struct attribute_map_bucket *next_bucket = NULL;
+
+	if (it->_e) {
+		it->_e = b_queue_next(it->_e);
+		next_entry = b_unbox(struct attribute_map_entry, it->_e, e_entry);
+	} else if (it->_n) {
+		it->_n = b_btree_next(it->_n);
+		next_entry = b_unbox(struct attribute_map_entry, it->_n, e_node);
+	} else {
+		memset(it, 0x0, sizeof *it);
+		return MIE_ERR_NO_DATA;
+	}
+
+	if (!next_entry) {
+		memset(it, 0x0, sizeof *it);
+		return MIE_ERR_NO_DATA;
+	}
+
+	switch (next_entry->e_type) {
+	case ATTRMAP_ENTRY_ITEM:
+		next_item = (struct attribute_map_item *)next_entry;
+		break;
+	case ATTRMAP_ENTRY_BUCKET:
+		next_bucket = (struct attribute_map_bucket *)next_item;
+		it->_e = b_queue_first(&next_bucket->b_items);
+		next_item = b_unbox(
+			struct attribute_map_item, it->_e, i_base.e_entry);
+		break;
+	default:
+		memset(it, 0x0, sizeof *it);
+		return MIE_ERR_BAD_STATE;
+	}
+
+	it->it_name = next_item->i_name;
+	it->it_value = next_item->i_value;
+	return MIE_SUCCESS;
+}

mie/attribute/attribute.c

@@ -0,0 +1,14 @@
+#include <mie/attribute/attribute-definition.h>
+#include <mie/attribute/attribute.h>
+
+bool mie_attribute_check_name(
+	const struct mie_attribute *attrib, const char *dialect_name,
+	const char *attrib_name)
+{
+	if (!attrib || !attrib->a_def) {
+		return false;
+	}
+
+	return mie_attribute_definition_check_name(
+		attrib->a_def, dialect_name, attrib_name);
+}

mie/ctx.c

@@ -1,34 +1,48 @@
+#include <blue/core/bstr.h>
 #include <blue/ds/hashmap.h>
 #include <blue/ds/list.h>
 #include <blue/ds/string.h>
+#include <mie/attribute/attribute-definition.h>
 #include <mie/ctx.h>
-#include <mie/ir/const.h>
+#include <mie/diag/class.h>
+#include <mie/diag/diag.h>
+#include <mie/dialect/arith.h>
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/dialect.h>
+#include <mie/dialect/index.h>
+#include <mie/interface/interface-definition.h>
+#include <mie/ir/op-definition.h>
+#include <mie/ir/op.h>
+#include <mie/pass/pass-definition.h>
+#include <mie/pass/pass.h>
+#include <mie/trait/trait-definition.h>
+#include <mie/trait/trait.h>
+#include <mie/type/function.h>
+#include <mie/type/storage.h>
+#include <mie/type/type-definition.h>
+#include <mie/type/type.h>
 #include <stdlib.h>
 #include <string.h>
 
-struct ctx_int_cache_entry {
-	b_btree_node i_node;
-	struct mie_type i_type;
-	b_btree i_values;
-};
+#define DIALECT_NS_ID                                                          \
+	MIE_ID(0xa1, 0x35, 0x01, 0x1b, 0xe4, 0x71, 0x46, 0x08, 0x92, 0xd4,     \
+	       0xe6, 0x5a, 0x40, 0xba, 0x7f, 0xee)
 
-struct ctx_int_value_cache_entry {
-	b_btree_node i_node;
-	struct mie_int i_value;
-};
+#define TYPE_NS_ID                                                             \
+	MIE_ID(0xf5, 0x4e, 0xc5, 0x8c, 0xc0, 0x1e, 0x48, 0x47, 0xb5, 0xf4,     \
+	       0x7b, 0xb9, 0x6b, 0x47, 0xca, 0x48)
 
-B_BTREE_DEFINE_SIMPLE_INSERT(
-	struct ctx_int_cache_entry, i_node, i_type.t_width, put_cached_int_type)
-B_BTREE_DEFINE_SIMPLE_GET(
-	struct ctx_int_cache_entry, unsigned int, i_node, i_type.t_width,
-	get_cached_int_type)
+#define TRAIT_NS_ID                                                            \
+	MIE_ID(0xeb, 0x02, 0xcc, 0xe5, 0x32, 0x80, 0x4e, 0xc3, 0x84, 0xf3,     \
+	       0xc0, 0x07, 0x72, 0xf0, 0x4c, 0xca)
 
-B_BTREE_DEFINE_SIMPLE_INSERT(
-	struct ctx_int_value_cache_entry, i_node, i_value.i_value,
-	put_cached_int_value)
-B_BTREE_DEFINE_SIMPLE_GET(
-	struct ctx_int_value_cache_entry, int64_t, i_node, i_value.i_value,
-	get_cached_int_value)
+#define ATTRIBUTE_NS_ID                                                        \
+	MIE_ID(0xc6, 0x94, 0x38, 0x34, 0xdb, 0x08, 0x45, 0xc7, 0xb9, 0x89,     \
+	       0x69, 0x82, 0x7a, 0x9d, 0x42, 0xd8)
+
+#define PASS_NS_ID                                                             \
+	MIE_ID(0x76, 0xfc, 0xdd, 0xb5, 0xc0, 0x20, 0x47, 0x13, 0x8d, 0xfa,     \
+	       0x3f, 0x28, 0x2f, 0x81, 0x6d, 0x7d)
 
 struct mie_ctx *mie_ctx_create(void)
 {
@@ -40,244 +54,474 @@ struct mie_ctx *mie_ctx_create(void)
 
 	memset(out, 0x0, sizeof *out);
 
-	out->ctx_true = MIE_CONST(mie_ctx_get_int(out, 1, 1));
-	out->ctx_false = MIE_CONST(mie_ctx_get_int(out, 0, 1));
+	mie_id dialects_ns = DIALECT_NS_ID;
+	mie_id_map_init(&out->ctx_dialects, &dialects_ns);
 
-	out->ctx_null = malloc(sizeof *out->ctx_null);
-	if (!out->ctx_null) {
-		mie_ctx_destroy(out);
-		return NULL;
-	}
+	mie_id types_ns = TYPE_NS_ID;
+	mie_id_map_init(&out->ctx_types, &types_ns);
 
-	mie_value_init(out->ctx_null, MIE_VALUE_NONE);
+	mie_id traits_ns = TRAIT_NS_ID;
+	mie_id_map_init(&out->ctx_traits, &traits_ns);
 
-	out->ctx_sel_cache = b_hashmap_create(free, free);
-	out->ctx_string_cache = b_hashmap_create(free, free);
+	mie_id attributes_ns = ATTRIBUTE_NS_ID;
+	mie_id_map_init(&out->ctx_attributes, &attributes_ns);
+
+	mie_id pass_ns = PASS_NS_ID;
+	mie_id_map_init(&out->ctx_passes, &pass_ns);
 
 	return out;
 }
 
-void mie_ctx_destroy(struct mie_ctx *ctx)
+struct mie_op *mie_ctx_create_op(
+	const struct mie_ctx *ctx, const char *dialect, const char *op)
 {
-	ctx->ctx_true = NULL;
-	ctx->ctx_false = NULL;
-
-	b_btree_node *node = b_btree_first(&ctx->ctx_int_cache);
-	while (node) {
-		struct ctx_int_cache_entry *entry
-			= b_unbox(struct ctx_int_cache_entry, node, i_node);
-		b_btree_node *next = b_btree_next(node);
-		b_btree_delete(&ctx->ctx_int_cache, node);
-
-		b_btree_node *node2 = b_btree_first(&entry->i_values);
-		while (node2) {
-			struct ctx_int_value_cache_entry *value = b_unbox(
-				struct ctx_int_value_cache_entry, node2, i_node);
-			b_btree_node *next2 = b_btree_next(node2);
-			b_btree_delete(&entry->i_values, node2);
-			free(value);
-			node2 = next2;
-		}
-
-		free(entry);
-		node = next;
-	}
-
-	const size_t nr_types = sizeof ctx->ctx_types / sizeof ctx->ctx_types[0];
-	for (size_t i = 0; i < nr_types; i++) {
-		if (ctx->ctx_types[i]) {
-			mie_value_destroy(MIE_VALUE(ctx->ctx_types[i]));
-			ctx->ctx_types[i] = NULL;
-		}
-	}
-
-	if (ctx->ctx_null) {
-		mie_value_destroy(ctx->ctx_null);
-	}
-
-	b_hashmap_unref(ctx->ctx_sel_cache);
-
-	free(ctx);
-}
-
-struct mie_type *mie_ctx_get_type(struct mie_ctx *ctx, enum mie_type_id type_id)
-{
-	if (type_id == MIE_TYPE_INT) {
+	const struct mie_op_definition *def
+		= mie_ctx_get_op_definition(ctx, dialect, op);
+	if (!def) {
 		return NULL;
 	}
 
-	if (ctx->ctx_types[type_id]) {
-		return ctx->ctx_types[type_id];
+	struct mie_op *out = mie_op_create();
+	if (!out) {
+		return NULL;
 	}
 
-	struct mie_type *type = mie_type_create();
+	out->op_flags |= MIE_OP_F_OP_RESOLVED;
+	out->op_info = def;
+
+	return out;
+}
+
+bool mie_ctx_resolve_op(const struct mie_ctx *ctx, struct mie_op *op)
+{
+	if (op->op_flags & MIE_OP_F_OP_RESOLVED) {
+		return true;
+	}
+
+	const char *dialect_name = NULL, *op_name = NULL;
+
+	char *dot = strchr(op->op_name, '.');
+	if (dot) {
+		*dot = 0;
+		dialect_name = op->op_name;
+		op_name = dot + 1;
+	} else {
+		dialect_name = NULL;
+		op_name = op->op_name;
+	}
+
+	const struct mie_dialect *dialect = mie_ctx_get_dialect(ctx, dialect_name);
+	if (dot) {
+		*dot = '.';
+	}
+
+	/* dialect_name is no longer valid after this point */
+	dialect_name = NULL;
+
+	if (!dialect) {
+		return false;
+	}
+
+	const struct mie_op_definition *op_info
+		= mie_dialect_get_op(dialect, op_name);
+	if (!op_info) {
+		return false;
+	}
+
+	op->op_info = op_info;
+
+	free(op->op_name);
+	op->op_name = NULL;
+
+	op->op_flags |= MIE_OP_F_OP_RESOLVED;
+
+	return true;
+}
+
+struct mie_dialect *mie_ctx_get_dialect(const struct mie_ctx *ctx, const char *name)
+{
+	b_rope name_rope = B_ROPE_CSTR(name);
+	mie_id id;
+	mie_id_init_ns(&id, mie_id_map_get_ns(&ctx->ctx_dialects), &name_rope);
+
+	mie_id *target = mie_id_map_get(&ctx->ctx_dialects, &id);
+	return b_unbox(struct mie_dialect, target, d_id);
+}
+
+const struct mie_op_definition *mie_ctx_get_op_definition(
+	const struct mie_ctx *ctx, const char *dialect_name, const char *op_name)
+{
+	b_rope dialect_name_rope = B_ROPE_CSTR(dialect_name);
+	mie_id id;
+	mie_id_init_ns(
+		&id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope);
+
+	mie_id *target = mie_id_map_get(&ctx->ctx_dialects, &id);
+	struct mie_dialect *dialect = b_unbox(struct mie_dialect, target, d_id);
+	if (!dialect) {
+		return NULL;
+	}
+
+	b_rope op_name_rope = B_ROPE_CSTR(op_name);
+	mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_ops), &op_name_rope);
+	target = mie_id_map_get(&dialect->d_ops, &id);
+
+	return b_unbox(struct mie_op_definition, target, op_id);
+}
+
+struct mie_type_definition *mie_ctx_get_type_definition(
+	const struct mie_ctx *ctx, const char *dialect_name, const char *type_name)
+{
+	b_rope dialect_name_rope = B_ROPE_CSTR(dialect_name);
+	mie_id id;
+	mie_id_init_ns(
+		&id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope);
+
+	mie_id *target = mie_id_map_get(&ctx->ctx_dialects, &id);
+	struct mie_dialect *dialect = b_unbox(struct mie_dialect, target, d_id);
+	if (!dialect) {
+		return NULL;
+	}
+
+	b_rope type_name_rope = B_ROPE_CSTR(type_name);
+	mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_types), &type_name_rope);
+	target = mie_id_map_get(&dialect->d_types, &id);
+
+	return b_unbox(struct mie_type_definition, target, ty_id);
+}
+
+const struct mie_trait_definition *mie_ctx_get_trait_definition(
+	const struct mie_ctx *ctx, const char *dialect_name, const char *trait_name)
+{
+	b_rope dialect_name_rope = B_ROPE_CSTR(dialect_name);
+	mie_id id;
+	mie_id_init_ns(
+		&id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope);
+
+	mie_id *target = mie_id_map_get(&ctx->ctx_dialects, &id);
+	struct mie_dialect *dialect = b_unbox(struct mie_dialect, target, d_id);
+	if (!dialect) {
+		return NULL;
+	}
+
+	b_rope trait_name_rope = B_ROPE_CSTR(trait_name);
+	mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_traits), &trait_name_rope);
+	target = mie_id_map_get(&dialect->d_traits, &id);
+
+	return b_unbox(struct mie_trait_definition, target, tr_id);
+}
+
+const struct mie_attribute_definition *mie_ctx_get_attribute_definition(
+	const struct mie_ctx *ctx, const char *dialect_name,
+	const char *attribute_name)
+{
+	b_rope dialect_name_rope = B_ROPE_CSTR(dialect_name);
+	mie_id id;
+	mie_id_init_ns(
+		&id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope);
+
+	mie_id *target = mie_id_map_get(&ctx->ctx_dialects, &id);
+	struct mie_dialect *dialect = b_unbox(struct mie_dialect, target, d_id);
+	if (!dialect) {
+		return NULL;
+	}
+
+	b_rope attribute_name_rope = B_ROPE_CSTR(attribute_name);
+	mie_id_init_ns(
+		&id, mie_id_map_get_ns(&dialect->d_attributes),
+		&attribute_name_rope);
+	target = mie_id_map_get(&dialect->d_attributes, &id);
+
+	return b_unbox(struct mie_attribute_definition, target, a_id);
+}
+
+const struct mie_interface_definition *mie_ctx_get_interface_definition(
+	const struct mie_ctx *ctx, const char *dialect_name,
+	const char *interface_name)
+{
+	b_rope dialect_name_rope = B_ROPE_CSTR(dialect_name);
+	mie_id id;
+	mie_id_init_ns(
+		&id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope);
+
+	mie_id *target = mie_id_map_get(&ctx->ctx_dialects, &id);
+	struct mie_dialect *dialect = b_unbox(struct mie_dialect, target, d_id);
+	if (!dialect) {
+		return NULL;
+	}
+
+	b_rope interface_name_rope = B_ROPE_CSTR(interface_name);
+	mie_id_init_ns(
+		&id, mie_id_map_get_ns(&dialect->d_interfaces),
+		&interface_name_rope);
+	target = mie_id_map_get(&dialect->d_interfaces, &id);
+
+	return b_unbox(struct mie_interface_definition, target, if_id);
+}
+
+struct mie_type *mie_ctx_get_type(
+	struct mie_ctx *ctx, const char *dialect_name, const char *type_name)
+{
+	char full_name[256];
+	snprintf(full_name, sizeof full_name, "%s.%s", dialect_name, type_name);
+	b_rope full_name_rope = B_ROPE_CSTR(full_name);
+
+	mie_id id;
+	mie_id_init_ns(&id, mie_id_map_get_ns(&ctx->ctx_types), &full_name_rope);
+
+	mie_id *target = mie_id_map_get(&ctx->ctx_types, &id);
+	struct mie_type *type = b_unbox(struct mie_type, target, ty_id);
+	if (type) {
+		return type;
+	}
+
+	struct mie_type_definition *type_info
+		= mie_ctx_get_type_definition(ctx, dialect_name, type_name);
+	if (!type_info /* || (type_info->ty_flags & MIE_DIALECT_TYPE_PARAMETISED) */) {
+		/* cannot initialise unknown or parametised types */
+		return NULL;
+	}
+
+	if (type_info->ty_data_size < sizeof(struct mie_type)) {
+		/* invalid type info */
+		return NULL;
+	}
+
+	type = malloc(type_info->ty_data_size);
 	if (!type) {
 		return NULL;
 	}
 
-	type->t_id = type_id;
+	memset(type, 0x0, sizeof *type);
+
+	type->ty_def = type_info;
+	type->ty_name = b_bstr_fmt(NULL, "%s.%s", dialect_name, type_name);
+
+	if (type_info->ty_init) {
+		type_info->ty_init(type_info, type);
+	}
+
+	mie_id_map_put(&ctx->ctx_types, &type->ty_id, &full_name_rope);
 
-	ctx->ctx_types[type_id] = type;
 	return type;
 }
 
-struct mie_value *mie_ctx_get_null(struct mie_ctx *ctx)
+const struct mie_trait *mie_ctx_get_trait(
+	struct mie_ctx *ctx, const char *dialect_name, const char *trait_name)
 {
-	return ctx->ctx_null;
+	char full_name[256];
+	snprintf(full_name, sizeof full_name, "%s.%s", dialect_name, trait_name);
+	b_rope full_name_rope = B_ROPE_CSTR(full_name);
+
+	mie_id id;
+	mie_id_init_ns(&id, mie_id_map_get_ns(&ctx->ctx_traits), &full_name_rope);
+
+	mie_id *target = mie_id_map_get(&ctx->ctx_traits, &id);
+	struct mie_trait *trait = b_unbox(struct mie_trait, target, tr_id);
+	if (trait) {
+		return trait;
 	}
 
-struct mie_type *mie_ctx_get_int_type(struct mie_ctx *ctx, unsigned int nr_bits)
-{
-	struct ctx_int_cache_entry *entry
-		= get_cached_int_type(&ctx->ctx_int_cache, nr_bits);
-
-	if (entry) {
-		return &entry->i_type;
+	const struct mie_trait_definition *trait_info
+		= mie_ctx_get_trait_definition(ctx, dialect_name, trait_name);
+	if (!trait_info /* || (trait_info->ty_flags & MIE_DIALECT_TYPE_PARAMETISED) */) {
+		/* cannot initialise unknown or parametised traits */
+		return NULL;
 	}
 
-	entry = malloc(sizeof *entry);
+	if (trait_info->tr_data_size < sizeof(struct mie_trait)) {
+		/* invalid trait info */
+		return NULL;
+	}
+
+	trait = malloc(trait_info->tr_data_size);
+	if (!trait) {
+		return NULL;
+	}
+
+	memset(trait, 0x0, sizeof trait_info->tr_data_size);
+
+	trait->tr_def = trait_info;
+	trait->tr_name = b_bstr_fmt(NULL, "%s.%s", dialect_name, trait_name);
+
+	if (trait_info->tr_init) {
+		trait_info->tr_init(trait_info, trait);
+	}
+
+	mie_id_map_put(&ctx->ctx_traits, &trait->tr_id, &full_name_rope);
+
+	return trait;
+}
+
+struct mie_type *mie_ctx_get_storage_type(
+	struct mie_ctx *ctx, const struct mie_type **parts, size_t nr_parts)
+{
+	struct mie_id_builder id_builder;
+	mie_id_builder_begin(&id_builder, &ctx->ctx_types.map_ns_id);
+	mie_storage_type_build_id(&id_builder, parts, nr_parts);
+	mie_id id;
+	mie_id_builder_end(&id_builder, &id);
+
+	mie_id *target = mie_id_map_get(&ctx->ctx_types, &id);
+	struct mie_type *type = b_unbox(struct mie_type, target, ty_id);
+	if (type) {
+		return type;
+	}
+
+	struct mie_storage_type *new_type = mie_storage_type_create();
+	for (size_t i = 0; i < nr_parts; i++) {
+		mie_storage_type_add_part(new_type, parts[i]);
+	}
+
+	new_type->st_base.ty_id = id;
+	mie_id_map_put_id(&ctx->ctx_types, &new_type->st_base.ty_id);
+	return (struct mie_type *)new_type;
+}
+
+struct mie_type *mie_ctx_get_function_type(
+	struct mie_ctx *ctx, const struct mie_type **in, size_t nr_in,
+	const struct mie_type **out, size_t nr_out)
+{
+	struct mie_id_builder id_builder;
+	mie_id_builder_begin(&id_builder, &ctx->ctx_types.map_ns_id);
+	mie_function_type_build_id(&id_builder, in, nr_in, out, nr_out);
+	mie_id id;
+	mie_id_builder_end(&id_builder, &id);
+
+	mie_id *target = mie_id_map_get(&ctx->ctx_types, &id);
+	struct mie_type *type = b_unbox(struct mie_type, target, ty_id);
+	if (type) {
+		return type;
+	}
+
+	struct mie_function_type *new_type = mie_function_type_create();
+	for (size_t i = 0; i < nr_in; i++) {
+		mie_function_type_add_in_part(new_type, in[i]);
+	}
+
+	for (size_t i = 0; i < nr_out; i++) {
+		mie_function_type_add_out_part(new_type, out[i]);
+	}
+
+	new_type->func_base.ty_id = id;
+	mie_id_map_put_id(&ctx->ctx_types, &new_type->func_base.ty_id);
+	return (struct mie_type *)new_type;
+}
+
+enum mie_status mie_ctx_register_pass(
+	struct mie_ctx *ctx, struct mie_pass_definition *pass)
+{
+	if (pass->p_data_size < sizeof(struct mie_pass)) {
+		return MIE_ERR_INVALID_ARGUMENT;
+	}
+
+	switch (pass->p_type) {
+	case MIE_PASS_ANALYSE:
+	case MIE_PASS_TRANSFORM:
+		break;
+	default:
+		return MIE_ERR_INVALID_ARGUMENT;
+	}
+
+	mie_id id;
+	struct mie_id_builder id_builder;
+	mie_id_builder_begin(&id_builder, mie_id_map_get_ns(&ctx->ctx_passes));
+	mie_id_builder_add_cstr(&id_builder, pass->p_name);
+	mie_id_builder_end(&id_builder, &id);
+
+	mie_id *target = mie_id_map_get(&ctx->ctx_passes, &id);
+	if (target) {
+		return MIE_ERR_NAME_EXISTS;
+	}
+
+	pass->p_id = id;
+	mie_id_map_put_id(&ctx->ctx_passes, &pass->p_id);
+
+	return MIE_SUCCESS;
+}
+
+enum mie_status mie_ctx_get_pass(
+	struct mie_ctx *ctx, const char *name,
+	const struct mie_attribute_map *args, struct mie_pass **out)
+{
+	mie_id id;
+	struct mie_id_builder id_builder;
+	mie_id_builder_begin(&id_builder, mie_id_map_get_ns(&ctx->ctx_passes));
+	mie_id_builder_add_cstr(&id_builder, name);
+	mie_id_builder_end(&id_builder, &id);
+
+	mie_id *target = mie_id_map_get(&ctx->ctx_passes, &id);
+	if (!target) {
+		return MIE_ERR_NO_ENTRY;
+	}
+
+	struct mie_pass_definition *pass_def
+		= b_unbox(struct mie_pass_definition, target, p_id);
+
+	if (pass_def->p_data_size < sizeof(struct mie_pass)) {
+		return MIE_ERR_BAD_STATE;
+	}
+
+	struct mie_pass *pass = malloc(pass_def->p_data_size);
+	if (!pass) {
+		return MIE_ERR_NO_MEMORY;
+	}
+
+	memset(pass, 0x0, pass_def->p_data_size);
+
+	pass->p_def = pass_def;
+
+	enum mie_status status = MIE_SUCCESS;
+	if (pass_def->p_init) {
+		status = pass_def->p_init(pass, args);
+	}
+
+	if (status != MIE_SUCCESS) {
+		free(pass);
+		pass = NULL;
+	}
+
+	*out = pass;
+	return status;
+}
+
+struct mie_diag *mie_ctx_push_diag(
+	struct mie_ctx *ctx, struct mie_line_source *src,
+	const struct mie_file_cell *loc, const char *dialect_name,
+	unsigned long diag_class)
+{
+	struct mie_diag *diag = malloc(sizeof *diag);
+	if (!diag) {
+		return NULL;
+	}
+
+	struct mie_dialect *dialect = mie_ctx_get_dialect(ctx, dialect_name);
+	if (!dialect) {
+		return NULL;
+	}
+
+	if (diag_class >= dialect->d_nr_diag_classes) {
+		return NULL;
+	}
+
+	memset(diag, 0x0, sizeof *diag);
+
+	diag->diag_src = src;
+	diag->diag_loc = *loc;
+	diag->diag_parent = dialect;
+	diag->diag_class = &dialect->d_diag_classes[diag_class];
+
+	b_queue_push_back(&ctx->ctx_diag, &diag->diag_entry);
+
+	return diag;
+}
+
+struct mie_diag *mie_ctx_pop_diag(struct mie_ctx *ctx)
+{
+	b_queue_entry *entry = b_queue_pop_front(&ctx->ctx_diag);
 	if (!entry) {
 		return NULL;
 	}
 
-	memset(entry, 0x0, sizeof *entry);
-
-	entry->i_type.t_id = MIE_TYPE_INT;
-	entry->i_type.t_width = nr_bits;
-
-	put_cached_int_type(&ctx->ctx_int_cache, entry);
-	return &entry->i_type;
-}
-
-struct mie_value *mie_ctx_get_bool(struct mie_ctx *ctx, bool val)
-{
-	return MIE_VALUE(val ? ctx->ctx_true : ctx->ctx_false);
-}
-
-struct mie_value *mie_ctx_get_int(
-	struct mie_ctx *ctx, long long val, unsigned int nr_bits)
-{
-	struct ctx_int_cache_entry *entry
-		= get_cached_int_type(&ctx->ctx_int_cache, nr_bits);
-
-	if (!entry) {
-		entry = malloc(sizeof *entry);
-		if (!entry) {
-			return NULL;
-		}
-
-		memset(entry, 0x0, sizeof *entry);
-
-		entry->i_type.t_id = MIE_TYPE_INT;
-		entry->i_type.t_width = nr_bits;
-
-		put_cached_int_type(&ctx->ctx_int_cache, entry);
-	}
-
-	struct ctx_int_value_cache_entry *value
-		= get_cached_int_value(&entry->i_values, val);
-	if (value) {
-		return MIE_VALUE(&value->i_value);
-	}
-
-	value = malloc(sizeof *value);
-	if (!value) {
-		return NULL;
-	}
-
-	memset(value, 0x0, sizeof *value);
-
-	mie_const_init(&value->i_value.i_base, &entry->i_type);
-	value->i_value.i_value = val;
-
-	put_cached_int_value(&entry->i_values, value);
-
-	return MIE_VALUE(&value->i_value);
-}
-
-struct mie_value *mie_ctx_get_selector(struct mie_ctx *ctx, const char *sel)
-{
-	b_hashmap_key key = {
-		.key_data = sel,
-		.key_size = strlen(sel),
-	};
-
-	const b_hashmap_value *cache_entry
-		= b_hashmap_get(ctx->ctx_sel_cache, &key);
-
-	if (cache_entry) {
-		return cache_entry->value_data;
-	}
-
-	struct mie_selector *sel_value = malloc(sizeof *sel_value);
-	if (!sel_value) {
-		return NULL;
-	}
-
-	struct mie_type *sel_type = mie_ctx_get_type(ctx, MIE_TYPE_SELECTOR);
-	mie_const_init(&sel_value->sel_base, sel_type);
-	sel_value->sel_value = b_strdup(sel);
-
-	key.key_data = sel_value->sel_value;
-
-	b_hashmap_value hashmap_value = {
-		.value_data = sel_value,
-		.value_size = sizeof *sel_value,
-	};
-
-	b_hashmap_put(ctx->ctx_sel_cache, &key, &hashmap_value);
-
-	return MIE_VALUE(sel_value);
-}
-
-struct mie_value *mie_ctx_get_string(struct mie_ctx *ctx, const char *s)
-{
-	b_hashmap_key key = {
-		.key_data = s,
-		.key_size = strlen(s),
-	};
-
-	const b_hashmap_value *cache_entry
-		= b_hashmap_get(ctx->ctx_string_cache, &key);
-
-	if (cache_entry) {
-		return cache_entry->value_data;
-	}
-
-	struct mie_string *string_value = malloc(sizeof *string_value);
-	if (!string_value) {
-		return NULL;
-	}
-
-	struct mie_type *string_type = mie_ctx_get_type(ctx, MIE_TYPE_STR);
-	mie_const_init(&string_value->s_base, string_type);
-	string_value->s_value = b_strdup(s);
-
-	key.key_data = string_value->s_value;
-
-	b_hashmap_value hashmap_value = {
-		.value_data = string_value,
-		.value_size = sizeof *string_value,
-	};
-
-	b_hashmap_put(ctx->ctx_string_cache, &key, &hashmap_value);
-
-	return MIE_VALUE(string_value);
-}
-
-struct mie_value *mie_ctx_create_array(struct mie_ctx *ctx)
-{
-	struct mie_type *array_type = mie_ctx_get_type(ctx, MIE_TYPE_ARRAY);
-	struct mie_array *array = malloc(sizeof *array);
-
-	if (!array) {
-		return NULL;
-	}
-
-	memset(array, 0x0, sizeof *array);
-	mie_const_init(&array->a_base, array_type);
-
-	array->a_values = b_list_create();
-
-	return MIE_VALUE(array);
+	return b_unbox(struct mie_diag, entry, diag_entry);
 }

mie/diag/diag.c

@@ -0,0 +1,106 @@
+#include <blue/ds/string.h>
+#include <mie/ctx.h>
+#include <mie/diag/amendment.h>
+#include <mie/diag/component.h>
+#include <mie/diag/diag.h>
+#include <mie/diag/highlight.h>
+#include <mie/diag/msg.h>
+#include <mie/dialect/dialect.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct mie_diag_c_msg *diag_msg_create(const struct mie_diag_msg *content)
+{
+	struct mie_diag_c_msg *out = malloc(sizeof *out);
+	if (!out) {
+		return NULL;
+	}
+
+	memset(out, 0x0, sizeof *out);
+
+	out->msg_base.c_type = MIE_DIAG_COMPONENT_MSG;
+	out->msg_content = b_strdup(content->msg_content);
+
+	return out;
+}
+
+struct mie_diag_c_snippet *diag_snippet_create(
+	unsigned long first_line, unsigned long last_line,
+	const struct mie_diag_amendment *amendments, size_t nr_amendments,
+	const struct mie_diag_highlight *highlights, size_t nr_highlights)
+{
+	struct mie_diag_c_snippet *out = malloc(sizeof *out);
+	if (!out) {
+		return NULL;
+	}
+
+	memset(out, 0x0, sizeof *out);
+
+	out->s_base.c_type = MIE_DIAG_COMPONENT_SNIPPET;
+	out->s_first_line = first_line;
+	out->s_last_line = last_line;
+
+	out->s_nr_amendments = nr_amendments;
+	out->s_amendments = calloc(nr_amendments, sizeof *amendments);
+	if (!out->s_amendments) {
+		free(out);
+		return NULL;
+	}
+	memcpy(out->s_amendments, amendments, nr_amendments * sizeof *amendments);
+
+	out->s_nr_highlights = nr_highlights;
+	out->s_highlights = calloc(nr_highlights, sizeof *highlights);
+	if (!out->s_highlights) {
+		free(out->s_amendments);
+		free(out);
+		return NULL;
+	}
+	memcpy(out->s_highlights, highlights, nr_highlights * sizeof *highlights);
+
+	return out;
+}
+
+void mie_diag_set_location(
+	struct mie_diag *diag, unsigned long row, unsigned long col)
+{
+	diag->diag_loc.c_row = row;
+	diag->diag_loc.c_row = col;
+}
+
+void mie_diag_push_msg(
+	struct mie_diag *diag, struct mie_ctx *ctx, const char *dialect_name,
+	unsigned long msg, ...)
+{
+	struct mie_dialect *dialect = mie_ctx_get_dialect(ctx, dialect_name);
+	if (!dialect) {
+		return;
+	}
+
+	if (msg >= dialect->d_nr_diag_msgs) {
+		return;
+	}
+
+	const struct mie_diag_msg *msg_info = &dialect->d_diag_msgs[msg];
+
+	struct mie_diag_c_msg *c_msg = diag_msg_create(msg_info);
+	if (!c_msg) {
+		return;
+	}
+
+	b_queue_push_back(&diag->diag_components, &c_msg->msg_base.c_entry);
+}
+
+void mie_diag_push_snippet(
+	struct mie_diag *diag, unsigned long first_line, unsigned long last_line,
+	const struct mie_diag_amendment *amendments, size_t nr_amendments,
+	const struct mie_diag_highlight *highlights, size_t nr_highlights)
+{
+	struct mie_diag_c_snippet *c_snippet = diag_snippet_create(
+		first_line, last_line, amendments, nr_amendments, highlights,
+		nr_highlights);
+	if (!c_snippet) {
+		return;
+	}
+
+	b_queue_push_back(&diag->diag_components, &c_snippet->s_base.c_entry);
+}

mie/diag/diag.h

@@ -0,0 +1,6 @@
+#ifndef _DIAG_DIAG_H_
+#define _DIAG_DIAG_H_
+
+#include <blue/core/queue.h>
+
+#endif

mie/dialect/arith/arith.c

@@ -0,0 +1,11 @@
+#include <mie/ctx.h>
+#include <mie/dialect/arith.h>
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+
+MIE_DIALECT_BEGIN(mie_arith, struct mie_dialect, "arith")
+	MIE_DIALECT_ADD_OP(mie_arith_addi);
+	MIE_DIALECT_ADD_OP(mie_arith_cmpi);
+	MIE_DIALECT_ADD_OP(mie_arith_addf);
+	MIE_DIALECT_ADD_OP(mie_arith_constant);
+MIE_DIALECT_END()

mie/dialect/arith/float-cache.c

@@ -0,0 +1,218 @@
+#include <blue/core/btree.h>
+#include <mie/ctx.h>
+#include <mie/dialect/builtin.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef union float_key {
+	double f;
+	unsigned char i[sizeof(double)];
+} float_key;
+
+struct float_width_cache_entry {
+	b_btree_node e_node;
+	float_key e_key;
+	struct mie_float e_value;
+};
+
+struct float_width_cache {
+	b_btree_node c_node;
+	size_t c_width;
+	b_btree c_floats;
+};
+
+struct mie_float_cache {
+	b_btree c_widths;
+};
+
+static int float_key_compare(const float_key *a, const float_key *b)
+{
+	return memcmp(a->i, b->i, sizeof a->i);
+}
+
+static B_BTREE_DEFINE_SIMPLE_INSERT(
+	struct float_width_cache, c_node, c_width, put_width_cache);
+static B_BTREE_DEFINE_SIMPLE_GET(
+	struct float_width_cache, size_t, c_node, c_width, get_width_cache);
+
+void put_float(b_btree *tree, struct float_width_cache_entry *node)
+{
+	if (!tree->b_root) {
+		tree->b_root = &node->e_node;
+		b_btree_insert_fixup(tree, &node->e_node);
+		return;
+	}
+
+	b_btree_node *cur = tree->b_root;
+	while (1) {
+		struct float_width_cache_entry *cur_node
+			= b_unbox(struct float_width_cache_entry, cur, e_node);
+		b_btree_node *next = NULL;
+		int cmp = float_key_compare(&node->e_key, &cur_node->e_key);
+
+		if (cmp >= 0) {
+			next = b_btree_right(cur);
+
+			if (!next) {
+				b_btree_put_right(cur, &node->e_node);
+				break;
+			}
+		} else if (cmp < 0) {
+			next = b_btree_left(cur);
+
+			if (!next) {
+				b_btree_put_left(cur, &node->e_node);
+				break;
+			}
+		} else {
+			return;
+		}
+
+		cur = next;
+	}
+
+	b_btree_insert_fixup(tree, &node->e_node);
+}
+
+static struct float_width_cache_entry *get_float(const b_btree *tree, float_key key)
+{
+	b_btree_node *cur = tree->b_root;
+	while (cur) {
+		struct float_width_cache_entry *cur_node
+			= b_unbox(struct float_width_cache_entry, cur, e_node);
+		int cmp = float_key_compare(&key, &cur_node->e_key);
+		if (cmp > 0) {
+			cur = b_btree_right(cur);
+		} else if (cmp < 0) {
+			cur = b_btree_left(cur);
+		} else {
+			return cur_node;
+		}
+	}
+
+	return NULL;
+}
+
+static struct float_width_cache *float_width_cache_create(size_t width)
+{
+	struct float_width_cache *out = malloc(sizeof *out);
+	if (!out) {
+		return NULL;
+	}
+
+	memset(out, 0x0, sizeof *out);
+
+	out->c_width = width;
+
+	return out;
+}
+
+static void float_width_cache_destroy(struct float_width_cache *cache)
+{
+	b_btree_node *cur = b_btree_first(&cache->c_floats);
+	while (cur) {
+		b_btree_node *next = b_btree_next(cur);
+		b_btree_delete(&cache->c_floats, cur);
+
+		struct float_width_cache_entry *entry
+			= b_unbox(struct float_width_cache_entry, cur, e_node);
+		free(entry);
+
+		cur = next;
+	}
+
+	free(cache);
+}
+
+static struct float_width_cache_entry *float_width_cache_entry_create(
+	struct mie_ctx *ctx, size_t width, double value)
+{
+	struct float_width_cache_entry *out = malloc(sizeof *out);
+	if (!out) {
+		return NULL;
+	}
+
+	memset(out, 0x0, sizeof *out);
+
+	switch (width) {
+	case MIE_FLOAT_32:
+		out->e_value.f_val.v_32 = value;
+		break;
+	case MIE_FLOAT_64:
+		out->e_value.f_val.v_64 = value;
+		break;
+	default:
+		free(out);
+		return NULL;
+	}
+
+	out->e_value.f_base.a_def
+		= mie_ctx_get_attribute_definition(ctx, "builtin", "float");
+	out->e_value.f_type = mie_ctx_get_float_type(ctx, width);
+	if (!out->e_value.f_type) {
+		free(out);
+		return NULL;
+	}
+
+	return out;
+}
+
+struct mie_float_cache *mie_float_cache_create(void)
+{
+	struct mie_float_cache *out = malloc(sizeof *out);
+	if (!out) {
+		return NULL;
+	}
+
+	memset(out, 0x0, sizeof *out);
+	return out;
+}
+
+void mie_float_cache_destroy(struct mie_float_cache *cache)
+{
+	b_btree_node *cur = b_btree_first(&cache->c_widths);
+	while (cur) {
+		b_btree_node *next = b_btree_next(cur);
+		b_btree_delete(&cache->c_widths, cur);
+
+		struct float_width_cache *width_cache
+			= b_unbox(struct float_width_cache, cur, c_node);
+		float_width_cache_destroy(width_cache);
+
+		cur = next;
+	}
+
+	free(cache);
+}
+
+struct mie_float *mie_float_cache_get(
+	struct mie_float_cache *cache, struct mie_ctx *ctx, double value,
+	size_t bit_width)
+{
+	struct float_width_cache *width_cache
+		= get_width_cache(&cache->c_widths, bit_width);
+	if (!width_cache) {
+		width_cache = float_width_cache_create(bit_width);
+
+		if (!width_cache) {
+			return NULL;
+		}
+
+		put_width_cache(&cache->c_widths, width_cache);
+	}
+
+	float_key key = {.f = value};
+	struct float_width_cache_entry *entry
+		= get_float(&width_cache->c_floats, key);
+	if (!entry) {
+		entry = float_width_cache_entry_create(ctx, bit_width, value);
+
+		if (!entry) {
+			return NULL;
+		}
+
+		put_float(&width_cache->c_floats, entry);
+	}
+
+	return &entry->e_value;
+}

mie/dialect/arith/int-cache.c

@@ -0,0 +1,142 @@
+#include <blue/core/btree.h>
+#include <mie/ctx.h>
+#include <mie/dialect/builtin.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct int_width_cache_entry {
+	b_btree_node e_node;
+	struct mie_int e_value;
+};
+
+struct int_width_cache {
+	b_btree_node c_node;
+	size_t c_width;
+	b_btree c_ints;
+};
+
+struct mie_int_cache {
+	b_btree c_widths;
+};
+
+static B_BTREE_DEFINE_SIMPLE_INSERT(
+	struct int_width_cache, c_node, c_width, put_width_cache);
+static B_BTREE_DEFINE_SIMPLE_GET(
+	struct int_width_cache, size_t, c_node, c_width, get_width_cache);
+
+static B_BTREE_DEFINE_SIMPLE_INSERT(
+	struct int_width_cache_entry, e_node, e_value.i_val.v_small, put_int);
+static B_BTREE_DEFINE_SIMPLE_GET(
+	struct int_width_cache_entry, uint64_t, e_node, e_value.i_val.v_small,
+	get_int);
+
+static struct int_width_cache *int_width_cache_create(size_t width)
+{
+	struct int_width_cache *out = malloc(sizeof *out);
+	if (!out) {
+		return NULL;
+	}
+
+	memset(out, 0x0, sizeof *out);
+
+	out->c_width = width;
+
+	return out;
+}
+
+static void int_width_cache_destroy(struct int_width_cache *cache)
+{
+	b_btree_node *cur = b_btree_first(&cache->c_ints);
+	while (cur) {
+		b_btree_node *next = b_btree_next(cur);
+		b_btree_delete(&cache->c_ints, cur);
+
+		struct int_width_cache_entry *entry
+			= b_unbox(struct int_width_cache_entry, cur, e_node);
+		free(entry);
+
+		cur = next;
+	}
+
+	free(cache);
+}
+
+static struct int_width_cache_entry *int_width_cache_entry_create(
+	struct mie_ctx *ctx, size_t width, size_t value)
+{
+	struct int_width_cache_entry *out = malloc(sizeof *out);
+	if (!out) {
+		return NULL;
+	}
+
+	memset(out, 0x0, sizeof *out);
+
+	out->e_value.i_base.a_def
+		= mie_ctx_get_attribute_definition(ctx, "builtin", "int");
+	out->e_value.i_val.v_small = value;
+	out->e_value.i_type = mie_ctx_get_int_type(ctx, width);
+	if (!out->e_value.i_type) {
+		free(out);
+		return NULL;
+	}
+
+	return out;
+}
+
+struct mie_int_cache *mie_int_cache_create(void)
+{
+	struct mie_int_cache *out = malloc(sizeof *out);
+	if (!out) {
+		return NULL;
+	}
+
+	memset(out, 0x0, sizeof *out);
+	return out;
+}
+
+void mie_int_cache_destroy(struct mie_int_cache *cache)
+{
+	b_btree_node *cur = b_btree_first(&cache->c_widths);
+	while (cur) {
+		b_btree_node *next = b_btree_next(cur);
+		b_btree_delete(&cache->c_widths, cur);
+
+		struct int_width_cache *width_cache
+			= b_unbox(struct int_width_cache, cur, c_node);
+		int_width_cache_destroy(width_cache);
+
+		cur = next;
+	}
+
+	free(cache);
+}
+
+struct mie_int *mie_int_cache_get(
+	struct mie_int_cache *cache, struct mie_ctx *ctx, size_t value,
+	size_t bit_width)
+{
+	struct int_width_cache *width_cache
+		= get_width_cache(&cache->c_widths, bit_width);
+	if (!width_cache) {
+		width_cache = int_width_cache_create(bit_width);
+
+		if (!width_cache) {
+			return NULL;
+		}
+
+		put_width_cache(&cache->c_widths, width_cache);
+	}
+
+	struct int_width_cache_entry *entry = get_int(&width_cache->c_ints, value);
+	if (!entry) {
+		entry = int_width_cache_entry_create(ctx, bit_width, value);
+
+		if (!entry) {
+			return NULL;
+		}
+
+		put_int(&width_cache->c_ints, entry);
+	}
+
+	return &entry->e_value;
+}

mie/dialect/arith/op/addf.c

@@ -0,0 +1,34 @@
+#include <mie/dialect/dialect.h>
+#include <mie/ir/op-definition.h>
+#include <mie/ir/op.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+
+static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
+{
+	if (MIE_VECTOR_COUNT(op->op_args) != 2) {
+		return MIE_SUCCESS;
+	}
+
+	const struct mie_op_arg *left = &op->op_args.items[0];
+	const struct mie_op_arg *right = &op->op_args.items[1];
+
+	b_stream_write_char(printer->p_stream, ' ');
+	mie_printer_print_op_arg(printer, left, false);
+	b_stream_write_string(printer->p_stream, ", ", NULL);
+	mie_printer_print_op_arg(printer, right, false);
+	b_stream_write_string(printer->p_stream, " : ", NULL);
+	mie_printer_print_type(printer, mie_op_arg_get_type(left));
+
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+{
+	return MIE_SUCCESS;
+}
+
+MIE_OP_DEFINITION_BEGIN(mie_arith_addf, "addf")
+	MIE_OP_DEFINITION_PRINT(print);
+	MIE_OP_DEFINITION_PARSE(parse);
+MIE_OP_DEFINITION_END()

mie/dialect/arith/op/addi.c

@@ -0,0 +1,54 @@
+#include <mie/ctx.h>
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/dialect.h>
+#include <mie/ir/emit.h>
+#include <mie/ir/op-definition.h>
+#include <mie/ir/op.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+#include <mie/type/type.h>
+
+static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
+{
+	if (MIE_VECTOR_COUNT(op->op_args) != 2) {
+		return MIE_SUCCESS;
+	}
+
+	const struct mie_op_arg *left = &op->op_args.items[0];
+	const struct mie_op_arg *right = &op->op_args.items[1];
+
+	b_stream_write_char(printer->p_stream, ' ');
+	mie_printer_print_op_arg(printer, left, false);
+	b_stream_write_string(printer->p_stream, ", ", NULL);
+	mie_printer_print_op_arg(printer, right, false);
+	b_stream_write_string(printer->p_stream, " : ", NULL);
+	mie_printer_print_type(printer, mie_op_arg_get_type(left));
+
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+{
+	return MIE_SUCCESS;
+}
+
+struct mie_register *mie_arith_addi_put(
+	struct mie_emitter *e, struct mie_register *left,
+	struct mie_register *right, const char *name)
+{
+	struct mie_register *args[] = {left, right};
+	const size_t nr_args = sizeof args / sizeof args[0];
+
+	struct mie_op *op = mie_emitter_put_op(e, "arith", "addi", args, nr_args);
+	const struct mie_type *ty = left->reg_type;
+
+	struct mie_register *result = mie_op_add_result(op, ty);
+	mie_emitter_put_name(e, &result->reg_name, name);
+
+	return result;
+}
+
+MIE_OP_DEFINITION_BEGIN(mie_arith_addi, "addi")
+	MIE_OP_DEFINITION_PRINT(print);
+	MIE_OP_DEFINITION_PARSE(parse);
+MIE_OP_DEFINITION_END()

mie/dialect/arith/op/cmpi.c

@@ -0,0 +1,80 @@
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/dialect.h>
+#include <mie/ir/op-definition.h>
+#include <mie/ir/op.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+
+static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
+{
+	if (MIE_VECTOR_COUNT(op->op_args) != 2
+	    || MIE_VECTOR_COUNT(op->op_result) != 1) {
+		return MIE_SUCCESS;
+	}
+
+	const struct mie_op_arg *left = &op->op_args.items[0];
+	const struct mie_op_arg *right = &op->op_args.items[1];
+	const struct mie_register *result = &op->op_result.items[0];
+	const struct mie_attribute *pred_attr
+		= mie_attribute_map_get(&op->op_attrib, "predicate");
+	long long pred;
+	if (!mie_int_get_value(pred_attr, &pred)) {
+		return MIE_SUCCESS;
+	}
+
+	b_stream_write_char(printer->p_stream, ' ');
+
+	switch (pred) {
+	case 0:
+		b_stream_write_string(printer->p_stream, "eq", NULL);
+		break;
+	case 1:
+		b_stream_write_string(printer->p_stream, "ne", NULL);
+		break;
+	case 2:
+		b_stream_write_string(printer->p_stream, "slt", NULL);
+		break;
+	case 3:
+		b_stream_write_string(printer->p_stream, "sle", NULL);
+		break;
+	case 4:
+		b_stream_write_string(printer->p_stream, "sgt", NULL);
+		break;
+	case 5:
+		b_stream_write_string(printer->p_stream, "sge", NULL);
+		break;
+	case 6:
+		b_stream_write_string(printer->p_stream, "ult", NULL);
+		break;
+	case 7:
+		b_stream_write_string(printer->p_stream, "ule", NULL);
+		break;
+	case 8:
+		b_stream_write_string(printer->p_stream, "ugt", NULL);
+		break;
+	case 9:
+		b_stream_write_string(printer->p_stream, "uge", NULL);
+		break;
+	default:
+		return MIE_SUCCESS;
+	}
+
+	b_stream_write_char(printer->p_stream, ' ');
+	mie_printer_print_op_arg(printer, left, false);
+	b_stream_write_string(printer->p_stream, ", ", NULL);
+	mie_printer_print_op_arg(printer, right, false);
+	b_stream_write_string(printer->p_stream, " : ", NULL);
+	mie_printer_print_type(printer, mie_op_arg_get_type(left));
+
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+{
+	return MIE_SUCCESS;
+}
+
+MIE_OP_DEFINITION_BEGIN(mie_arith_cmpi, "cmpi")
+	MIE_OP_DEFINITION_PRINT(print);
+	MIE_OP_DEFINITION_PARSE(parse);
+MIE_OP_DEFINITION_END()

mie/dialect/arith/op/constant.c

@@ -0,0 +1,81 @@
+#include <mie/attribute/attribute.h>
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/dialect.h>
+#include <mie/ir/emit.h>
+#include <mie/ir/op-definition.h>
+#include <mie/ir/op.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+
+static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
+{
+	const struct mie_attribute *value
+		= mie_attribute_map_get(&op->op_attrib, "value");
+	if (!value) {
+		return MIE_SUCCESS;
+	}
+
+	const struct mie_type *type = NULL;
+	if (mie_attribute_check_name(value, "builtin", "int")) {
+		const struct mie_int *i = (const struct mie_int *)value;
+		b_stream_write_fmt(
+			printer->p_stream, NULL, " %lld : ", i->i_val.v_small);
+		type = i->i_type;
+	} else if (mie_attribute_check_name(value, "builtin", "float")) {
+		const struct mie_float *f = (const struct mie_float *)value;
+		double d;
+		mie_float_get_value(value, &d);
+		b_stream_write_fmt(printer->p_stream, NULL, " %g : ", d);
+		type = f->f_type;
+	} else {
+		return MIE_SUCCESS;
+	}
+
+	mie_printer_print_type(printer, type);
+
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+{
+	return MIE_SUCCESS;
+}
+
+struct mie_register *mie_arith_constant_i_put(
+	struct mie_emitter *e, long long value, const char *name)
+{
+	struct mie_op *op = mie_emitter_put_op(e, "arith", "constant", NULL, 0);
+	const struct mie_type *ty
+		= mie_ctx_get_int_type(mie_emitter_get_ctx(e), 32);
+	struct mie_register *result = mie_op_add_result(op, ty);
+
+	mie_emitter_put_name(e, &result->reg_name, name);
+
+	struct mie_attribute *val
+		= mie_ctx_get_int(mie_emitter_get_ctx(e), value, 32);
+	mie_attribute_map_put(&op->op_attrib, "value", val, MIE_ATTRMAP_F_REPLACE);
+
+	return result;
+}
+
+struct mie_register *mie_arith_constant_f_put(
+	struct mie_emitter *e, long long value, const char *name)
+{
+	struct mie_op *op = mie_emitter_put_op(e, "arith", "constant", NULL, 0);
+	const struct mie_type *ty
+		= mie_ctx_get_int_type(mie_emitter_get_ctx(e), 32);
+	struct mie_register *result = mie_op_add_result(op, ty);
+
+	mie_emitter_put_name(e, &result->reg_name, name);
+
+	struct mie_attribute *val
+		= mie_ctx_get_float(mie_emitter_get_ctx(e), value, 32);
+	mie_attribute_map_put(&op->op_attrib, "value", val, MIE_ATTRMAP_F_REPLACE);
+
+	return result;
+}
+
+MIE_OP_DEFINITION_BEGIN(mie_arith_constant, "constant")
+	MIE_OP_DEFINITION_PRINT(print);
+	MIE_OP_DEFINITION_PARSE(parse);
+MIE_OP_DEFINITION_END()

mie/dialect/builtin/attribute/array.c

@@ -0,0 +1,103 @@
+#include <mie/attribute/attribute-definition.h>
+#include <mie/attribute/attribute.h>
+#include <mie/ctx.h>
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+#include <mie/parse/parser.h>
+#include <mie/print/printer.h>
+
+static enum mie_status print(
+	const struct mie_attribute *value, struct mie_printer *out)
+{
+	const struct mie_array *array = (const struct mie_array *)value;
+
+	if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) {
+		b_stream_write_string(out->p_stream, "#builtin.array<", NULL);
+	}
+
+	b_stream_write_char(out->p_stream, '[');
+
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(array->a_items); i++) {
+		if (i > 0) {
+			b_stream_write_char(out->p_stream, ',');
+		}
+
+		b_stream_write_char(out->p_stream, ' ');
+		mie_printer_print_attribute(out, array->a_items.items[i]);
+	}
+
+	if (MIE_VECTOR_COUNT(array->a_items) != 0) {
+		b_stream_write_char(out->p_stream, ' ');
+	}
+	b_stream_write_char(out->p_stream, ']');
+
+	if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) {
+		b_stream_write_char(out->p_stream, '>');
+	}
+
+	return MIE_SUCCESS;
+}
+
+static struct mie_array *array_create(struct mie_ctx *ctx)
+{
+	struct mie_array *array = malloc(sizeof *array);
+	if (!array) {
+		return NULL;
+	}
+
+	memset(array, 0x0, sizeof *array);
+
+	array->a_base.a_def
+		= mie_ctx_get_attribute_definition(ctx, "builtin", "array");
+
+	return array;
+}
+
+static enum mie_status parse(
+	struct mie_parser *ctx, const struct mie_attribute **out)
+{
+	if (!mie_parser_parse_symbol(ctx, MIE_SYM_LEFT_BRACKET)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	struct mie_array *array = array_create(mie_parser_get_mie_ctx(ctx));
+	if (!array) {
+		return MIE_ERR_NO_MEMORY;
+	}
+
+	const struct mie_attribute *item = NULL;
+
+	if (!mie_parser_parse_attribute(ctx, &item)) {
+		free(array);
+		return MIE_ERR_BAD_FORMAT;
+	}
+
+	mie_vector_push_back(array->a_items, &item, NULL);
+
+	while (1) {
+		if (mie_parser_parse_symbol(ctx, MIE_SYM_RIGHT_BRACKET)) {
+			break;
+		}
+
+		if (!mie_parser_parse_symbol(ctx, MIE_SYM_COMMA)) {
+			return false;
+		}
+
+		if (!mie_parser_parse_attribute(ctx, &item)) {
+			free(array);
+			return MIE_ERR_BAD_FORMAT;
+		}
+
+		mie_vector_push_back(array->a_items, &item, NULL);
+	}
+
+	*out = (struct mie_attribute *)array;
+	return MIE_SUCCESS;
+}
+
+MIE_ATTRIBUTE_DEFINITION_BEGIN(mie_builtin_array, "array")
+	MIE_ATTRIBUTE_DEFINITION_STRUCT(struct mie_array);
+	MIE_ATTRIBUTE_DEFINITION_PRINT(print);
+	MIE_ATTRIBUTE_DEFINITION_PARSE(parse);
+MIE_ATTRIBUTE_DEFINITION_END()

mie/dialect/builtin/attribute/float.c

@@ -0,0 +1,107 @@
+#include "../float.h"
+
+#include <blue/core/bstr.h>
+#include <mie/attribute/attribute-definition.h>
+#include <mie/attribute/attribute.h>
+#include <mie/ctx.h>
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+#include <mie/parse/parser.h>
+#include <mie/print/printer.h>
+
+static enum mie_status print(
+	const struct mie_attribute *value, struct mie_printer *out)
+{
+	const struct mie_float *float_val = (const struct mie_float *)value;
+	const struct float_type *float_ty
+		= (const struct float_type *)float_val->f_type;
+	if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) {
+		b_stream_write_string(out->p_stream, "#builtin.float<", NULL);
+	}
+
+	switch (float_ty->f_width) {
+	case MIE_FLOAT_32:
+		b_stream_write_fmt(
+			out->p_stream, NULL, "%f : f%zu", float_val->f_val.v_32,
+			float_ty->f_width);
+		break;
+	case MIE_FLOAT_64:
+		b_stream_write_fmt(
+			out->p_stream, NULL, "%lf : f%zu",
+			float_val->f_val.v_64, float_ty->f_width);
+		break;
+	default:
+		b_stream_write_fmt(
+			out->p_stream, NULL, "NaN : f%zu", float_ty->f_width);
+		break;
+	}
+
+	if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) {
+		b_stream_write_string(out->p_stream, ">", NULL);
+	}
+
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(
+	struct mie_parser *ctx, const struct mie_attribute **out)
+{
+	double value = 0;
+	struct mie_file_span span;
+
+	if (!mie_parser_parse_float(ctx, &value, &span)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_symbol(ctx, MIE_SYM_COLON)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	const struct mie_type *type = NULL;
+	if (!mie_parser_parse_type(ctx, &type)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	size_t width = mie_float_type_get_width(type);
+	if (width == (size_t)-1) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	struct mie_attribute *v
+		= mie_ctx_get_float(mie_parser_get_mie_ctx(ctx), value, width);
+	if (!v) {
+		return MIE_ERR_NO_MEMORY;
+	}
+
+	*out = v;
+	return MIE_SUCCESS;
+}
+
+bool mie_float_get_value(const struct mie_attribute *attrib, double *out)
+{
+	if (!mie_attribute_check_name(attrib, "builtin", "float")) {
+		return false;
+	}
+
+	const struct mie_float *v = (const struct mie_float *)attrib;
+
+	switch (mie_float_type_get_width(v->f_type)) {
+	case MIE_FLOAT_32:
+		*out = v->f_val.v_32;
+		break;
+	case MIE_FLOAT_64:
+		*out = v->f_val.v_64;
+		break;
+	default:
+		return false;
+	}
+
+	return true;
+}
+
+MIE_ATTRIBUTE_DEFINITION_BEGIN(mie_builtin_float, "float")
+	MIE_ATTRIBUTE_DEFINITION_STRUCT(struct mie_float);
+	MIE_ATTRIBUTE_DEFINITION_PRINT(print);
+	MIE_ATTRIBUTE_DEFINITION_PARSE(parse);
+MIE_ATTRIBUTE_DEFINITION_END()

mie/dialect/builtin/attribute/int.c

@@ -0,0 +1,103 @@
+#include "../int.h"
+
+#include <blue/core/bstr.h>
+#include <mie/attribute/attribute-definition.h>
+#include <mie/attribute/attribute.h>
+#include <mie/ctx.h>
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+#include <mie/parse/parser.h>
+#include <mie/print/printer.h>
+
+static enum mie_status print(
+	const struct mie_attribute *value, struct mie_printer *out)
+{
+	const struct mie_int *int_val = (const struct mie_int *)value;
+	const struct int_type *int_ty = (const struct int_type *)int_val->i_type;
+	bool abbrev = ((out->p_flags & MIE_PRINT_F_ABBREVIATED) != 0);
+
+	if (!abbrev) {
+		b_stream_write_string(out->p_stream, "#builtin.int<", NULL);
+	}
+
+	if (int_ty->i_width <= 64) {
+		b_stream_write_fmt(
+			out->p_stream, NULL, "%zu", int_val->i_val.v_small,
+			int_ty->i_width);
+	} else {
+		b_stream_write_fmt(out->p_stream, NULL, "INF", int_ty->i_width);
+	}
+
+	if (int_ty->i_width != 64 || !abbrev) {
+		b_stream_write_string(out->p_stream, " : ", NULL);
+
+		if (abbrev) {
+			b_stream_write_fmt(
+				out->p_stream, NULL, "i%zu", int_ty->i_width);
+		} else {
+			b_stream_write_fmt(
+				out->p_stream, NULL, "!builtin.int<%zu>",
+				int_ty->i_width);
+		}
+	}
+
+	if (!abbrev) {
+		b_stream_write_string(out->p_stream, ">", NULL);
+	}
+
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(
+	struct mie_parser *ctx, const struct mie_attribute **out)
+{
+	long long value = 0;
+	struct mie_file_span span;
+
+	if (!mie_parser_parse_int(ctx, &value, &span)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	const struct mie_type *type = NULL;
+	size_t width = (size_t)-1;
+
+	if (!mie_parser_parse_symbol(ctx, MIE_SYM_COLON)) {
+		width = 64;
+	} else if (!mie_parser_parse_type(ctx, &type)) {
+		return false;
+	} else {
+		width = mie_int_type_get_width(type);
+	}
+
+	if (width == (size_t)-1) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	struct mie_attribute *v
+		= mie_ctx_get_int(mie_parser_get_mie_ctx(ctx), value, width);
+	if (!v) {
+		return MIE_ERR_NO_MEMORY;
+	}
+
+	*out = v;
+	return MIE_SUCCESS;
+}
+
+bool mie_int_get_value(const struct mie_attribute *attrib, long long *out)
+{
+	if (!mie_attribute_check_name(attrib, "builtin", "int")) {
+		return false;
+	}
+
+	const struct mie_int *v = (const struct mie_int *)attrib;
+	*out = v->i_val.v_small;
+
+	return true;
+}
+
+MIE_ATTRIBUTE_DEFINITION_BEGIN(mie_builtin_int, "int")
+	MIE_ATTRIBUTE_DEFINITION_STRUCT(struct mie_int);
+	MIE_ATTRIBUTE_DEFINITION_PRINT(print);
+	MIE_ATTRIBUTE_DEFINITION_PARSE(parse);
+MIE_ATTRIBUTE_DEFINITION_END()

mie/dialect/builtin/attribute/string.c

@@ -0,0 +1,57 @@
+#include <mie/attribute/attribute-definition.h>
+#include <mie/attribute/attribute.h>
+#include <mie/ctx.h>
+#include <mie/dialect/builtin.h>
+#include <mie/macros.h>
+#include <mie/parse/parser.h>
+#include <mie/print/printer.h>
+
+static enum mie_status print(
+	const struct mie_attribute *value, struct mie_printer *out)
+{
+	const struct mie_string *str = (const struct mie_string *)value;
+	if (out->p_flags & MIE_PRINT_F_ABBREVIATED) {
+		b_stream_write_fmt(out->p_stream, NULL, "\"%s\"", str->str_val);
+	} else {
+		b_stream_write_fmt(
+			out->p_stream, NULL, "#builtin.string<\"%s\">",
+			str->str_val);
+	}
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(
+	struct mie_parser *ctx, const struct mie_attribute **out)
+{
+	b_string *str = mie_parser_get_tempstr(ctx);
+	struct mie_file_span span;
+	if (!mie_parser_parse_string(ctx, str, &span)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	struct mie_attribute *v = mie_ctx_get_string(
+		mie_parser_get_mie_ctx(ctx), b_string_ptr(str));
+
+	if (!v) {
+		return MIE_ERR_NO_MEMORY;
+	}
+
+	*out = v;
+	return MIE_SUCCESS;
+}
+
+const char *mie_string_get_cstr(const struct mie_attribute *attrib)
+{
+	if (!mie_attribute_check_name(attrib, "builtin", "string")) {
+		return NULL;
+	}
+
+	const struct mie_string *str = (const struct mie_string *)attrib;
+	return str->str_val;
+}
+
+MIE_ATTRIBUTE_DEFINITION_BEGIN(mie_builtin_string, "string")
+	MIE_ATTRIBUTE_DEFINITION_STRUCT(struct mie_string);
+	MIE_ATTRIBUTE_DEFINITION_PRINT(print);
+	MIE_ATTRIBUTE_DEFINITION_PARSE(parse);
+MIE_ATTRIBUTE_DEFINITION_END();

mie/dialect/builtin/attribute/type.c

@@ -0,0 +1,81 @@
+#include <mie/attribute/attribute-definition.h>
+#include <mie/attribute/attribute.h>
+#include <mie/ctx.h>
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+#include <mie/parse/parser.h>
+#include <mie/print/printer.h>
+
+struct mie_attribute *mie_type_attr_create(
+	struct mie_ctx *ctx, const struct mie_type *ty)
+{
+	struct mie_type_attr *out = malloc(sizeof *out);
+	if (!out) {
+		return NULL;
+	}
+
+	memset(out, 0x0, sizeof *out);
+
+	out->ty_base.a_def
+		= mie_ctx_get_attribute_definition(ctx, "builtin", "type");
+	out->ty_value = ty;
+
+	return (struct mie_attribute *)out;
+}
+
+static enum mie_status print(
+	const struct mie_attribute *value, struct mie_printer *out)
+{
+	const struct mie_type_attr *ty = (const struct mie_type_attr *)value;
+
+	if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) {
+		b_stream_write_string(out->p_stream, "#builtin.type<", NULL);
+	}
+
+	mie_printer_print_type(out, ty->ty_value);
+
+	if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) {
+		b_stream_write_char(out->p_stream, '>');
+	}
+
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(
+	struct mie_parser *ctx, const struct mie_attribute **out)
+{
+	struct mie_type_attr *ty = (struct mie_type_attr *)mie_type_attr_create(
+		mie_parser_get_mie_ctx(ctx), NULL);
+	if (!ty) {
+		return MIE_ERR_NO_MEMORY;
+	}
+
+	const struct mie_type *type = NULL;
+
+	if (!mie_parser_parse_type(ctx, &type)) {
+		free(ty);
+		return MIE_ERR_BAD_FORMAT;
+	}
+
+	ty->ty_value = type;
+
+	*out = (struct mie_attribute *)ty;
+	return MIE_SUCCESS;
+}
+
+const struct mie_type *mie_type_attr_get_type(const struct mie_attribute *attrib)
+{
+	if (!mie_attribute_check_name(attrib, "builtin", "type")) {
+		return NULL;
+	}
+
+	const struct mie_type_attr *ty = (const struct mie_type_attr *)attrib;
+	return ty->ty_value;
+}
+
+MIE_ATTRIBUTE_DEFINITION_BEGIN(mie_builtin_type, "type")
+	MIE_ATTRIBUTE_DEFINITION_STRUCT(struct mie_type_attr);
+	MIE_ATTRIBUTE_DEFINITION_PRINT(print);
+	MIE_ATTRIBUTE_DEFINITION_PARSE(parse);
+MIE_ATTRIBUTE_DEFINITION_END()

mie/dialect/builtin/builtin.c

@@ -0,0 +1,107 @@
+#include <mie/ctx.h>
+#include <mie/diag/class.h>
+#include <mie/diag/msg.h>
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+
+struct builtin_dialect {
+	struct mie_dialect d_base;
+	struct mie_string_cache *ctx_strings;
+	struct mie_int_cache *ctx_ints;
+	struct mie_float_cache *ctx_floats;
+	struct mie_index_cache *ctx_indices;
+};
+
+static enum mie_status init(struct mie_dialect *d)
+{
+	struct builtin_dialect *dialect = (struct builtin_dialect *)d;
+	dialect->ctx_strings = mie_string_cache_create();
+	dialect->ctx_ints = mie_int_cache_create();
+	dialect->ctx_floats = mie_float_cache_create();
+	dialect->ctx_indices = mie_index_cache_create();
+	return MIE_SUCCESS;
+}
+
+static enum mie_status cleanup(struct mie_dialect *d)
+{
+	struct builtin_dialect *dialect = (struct builtin_dialect *)d;
+	mie_string_cache_destroy(dialect->ctx_strings);
+	mie_int_cache_destroy(dialect->ctx_ints);
+	mie_float_cache_destroy(dialect->ctx_floats);
+	mie_index_cache_destroy(dialect->ctx_indices);
+	return MIE_SUCCESS;
+}
+
+struct mie_attribute *mie_ctx_get_int(
+	struct mie_ctx *ctx, long long val, size_t nr_bits)
+{
+	struct builtin_dialect *dialect
+		= (struct builtin_dialect *)mie_ctx_get_dialect(ctx, "builtin");
+	if (!dialect) {
+		return NULL;
+	}
+
+	return (struct mie_attribute *)mie_int_cache_get(
+		dialect->ctx_ints, ctx, val, nr_bits);
+}
+
+struct mie_attribute *mie_ctx_get_float(
+	struct mie_ctx *ctx, double val, size_t nr_bits)
+{
+	struct builtin_dialect *dialect
+		= (struct builtin_dialect *)mie_ctx_get_dialect(ctx, "builtin");
+	if (!dialect) {
+		return NULL;
+	}
+
+	return (struct mie_attribute *)mie_float_cache_get(
+		dialect->ctx_floats, ctx, val, nr_bits);
+}
+
+struct mie_attribute *mie_ctx_get_string(struct mie_ctx *ctx, const char *s)
+{
+	struct builtin_dialect *dialect
+		= (struct builtin_dialect *)mie_ctx_get_dialect(ctx, "builtin");
+	if (!dialect) {
+		return NULL;
+	}
+
+	return (struct mie_attribute *)mie_string_cache_get(
+		dialect->ctx_strings, ctx, s);
+}
+
+struct mie_attribute *mie_ctx_get_index(struct mie_ctx *ctx, size_t val)
+{
+	struct builtin_dialect *dialect
+		= (struct builtin_dialect *)mie_ctx_get_dialect(ctx, "builtin");
+	if (!dialect) {
+		return NULL;
+	}
+
+	return (struct mie_attribute *)mie_index_cache_get(
+		dialect->ctx_indices, ctx, val);
+}
+
+MIE_DIAG_CLASS_LIST_EXTERN(mie_builtin_diag);
+MIE_DIAG_MSG_LIST_EXTERN(mie_builtin_msg);
+
+MIE_DIALECT_BEGIN(mie_builtin, struct builtin_dialect, "builtin")
+	MIE_DIALECT_INIT(init);
+	MIE_DIALECT_CLEANUP(cleanup);
+	MIE_DIALECT_DIAG_CLASS_LIST(mie_builtin_diag);
+	MIE_DIALECT_DIAG_MSG_LIST(mie_builtin_msg);
+	MIE_DIALECT_ADD_TRAIT(mie_builtin_isolated_from_above);
+	MIE_DIALECT_ADD_TRAIT(mie_builtin_symbol_table);
+	MIE_DIALECT_ADD_TYPE(mie_builtin_int);
+	MIE_DIALECT_ADD_TYPE(mie_builtin_float);
+	MIE_DIALECT_ADD_TYPE(mie_builtin_index);
+	MIE_DIALECT_ADD_TYPE(mie_builtin_string);
+	MIE_DIALECT_ADD_ATTRIBUTE(mie_builtin_int);
+	MIE_DIALECT_ADD_ATTRIBUTE(mie_builtin_float);
+	MIE_DIALECT_ADD_ATTRIBUTE(mie_builtin_type);
+	MIE_DIALECT_ADD_ATTRIBUTE(mie_builtin_string);
+	MIE_DIALECT_ADD_INTERFACE(mie_builtin_symbol);
+	MIE_DIALECT_ADD_ATTRIBUTE(mie_builtin_array);
+	MIE_DIALECT_ADD_OP(mie_builtin_module);
+MIE_DIALECT_END()

mie/dialect/builtin/diag.c

@@ -0,0 +1,36 @@
+#include <mie/diag/class.h>
+#include <mie/diag/msg.h>
+#include <mie/dialect/builtin.h>
+#include <mie/macros.h>
+
+#define MIE_DIAG_CLASS_PREFIX MIE_BUILTIN_E
+#define MIE_DIAG_MSG_PREFIX   MIE_BUILTIN_MSG
+
+MIE_DIAG_CLASS_LIST_BEGIN(mie_builtin_diag)
+	MIE_DIAG_CLASS(UNRECOGNISED_TOKEN, ERROR, "Unrecognised token")
+	MIE_DIAG_CLASS(UNRESOLVED_VALUE, ERROR, "Unresolved value")
+	MIE_DIAG_CLASS(UNRESOLVED_SUCCESSOR, ERROR, "Unresolved successor")
+MIE_DIAG_CLASS_LIST_END(mie_builtin_diag)
+
+MIE_DIAG_MSG_LIST_BEGIN(mie_builtin_msg)
+	MIE_DIAG_MSG(UNRECOGNISED_TOKEN, "encountered an unrecognised token.")
+	MIE_DIAG_MSG(UNRESOLVED_VALUE, "cannot resolve this value reference.")
+	MIE_DIAG_MSG(
+		CANNOT_FIND_BLOCK,
+		"cannot find a block with this name in this region.")
+	MIE_DIAG_MSG(
+		VALUE_DEFINED_IN_NON_DOMINANT_BLOCK,
+		"this value cannot be referenced here, as it is defined in a "
+		"block that does not dominate this block.")
+	MIE_DIAG_MSG(
+		VALUE_DEFINED_AFTER_USE,
+		"this value cannot be referenced here, as it is not defined "
+		"until later in this block.")
+	MIE_DIAG_MSG(
+		VALUE_DEFINED_OUTSIDE_ISOLATED_REGION,
+		"this value cannot be referenced here, as this region is "
+		"isolated from above, and the definition for this value is "
+		"outside of this region.")
+	MIE_DIAG_MSG(
+		VALUE_DEFINED_IN_BLOCK, "the value is defined in this block.")
+MIE_DIAG_MSG_LIST_END(mie_builtin_msg)

mie/dialect/builtin/float.h

@@ -0,0 +1,12 @@
+#ifndef _BUILTIN_FLOAT_H_
+#define _BUILTIN_FLOAT_H_
+
+#include <mie/attribute/attribute.h>
+#include <mie/type/type.h>
+
+struct float_type {
+	struct mie_type f_base;
+	size_t f_width;
+};
+
+#endif

mie/dialect/builtin/index-cache.c

@@ -0,0 +1,81 @@
+#include <blue/core/btree.h>
+#include <mie/ctx.h>
+#include <mie/dialect/builtin.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct index_cache_entry {
+	b_btree_node e_node;
+	struct mie_index e_value;
+};
+
+struct mie_index_cache {
+	b_btree c_entries;
+};
+
+static B_BTREE_DEFINE_SIMPLE_INSERT(
+	struct index_cache_entry, e_node, e_value.i_value, put_index);
+static B_BTREE_DEFINE_SIMPLE_GET(
+	struct index_cache_entry, size_t, e_node, e_value.i_value, get_index);
+
+static struct index_cache_entry *index_cache_entry_create(
+	struct mie_ctx *ctx, size_t val)
+{
+	struct index_cache_entry *out = malloc(sizeof *out);
+	if (!out) {
+		return NULL;
+	}
+
+	memset(out, 0x0, sizeof *out);
+
+	out->e_value.i_base.a_def
+		= mie_ctx_get_attribute_definition(ctx, "builtin", "index");
+	out->e_value.i_value = val;
+
+	return out;
+}
+
+struct mie_index_cache *mie_index_cache_create(void)
+{
+	struct mie_index_cache *out = malloc(sizeof *out);
+	if (!out) {
+		return NULL;
+	}
+
+	memset(out, 0x0, sizeof *out);
+	return out;
+}
+
+void mie_index_cache_destroy(struct mie_index_cache *cache)
+{
+	b_btree_node *cur = b_btree_first(&cache->c_entries);
+	while (cur) {
+		b_btree_node *next = b_btree_next(cur);
+		b_btree_delete(&cache->c_entries, cur);
+
+		struct index_cache_entry *entry
+			= b_unbox(struct index_cache_entry, cur, e_node);
+		free(entry);
+
+		cur = next;
+	}
+
+	free(cache);
+}
+
+struct mie_index *mie_index_cache_get(
+	struct mie_index_cache *cache, struct mie_ctx *ctx, size_t value)
+{
+	struct index_cache_entry *entry = get_index(&cache->c_entries, value);
+	if (!entry) {
+		entry = index_cache_entry_create(ctx, value);
+
+		if (!entry) {
+			return NULL;
+		}
+
+		put_index(&cache->c_entries, entry);
+	}
+
+	return &entry->e_value;
+}

mie/dialect/builtin/int.h

@@ -0,0 +1,12 @@
+#ifndef _BUILTIN_INT_H_
+#define _BUILTIN_INT_H_
+
+#include <mie/attribute/attribute.h>
+#include <mie/type/type.h>
+
+struct int_type {
+	struct mie_type i_base;
+	size_t i_width;
+};
+
+#endif

mie/dialect/builtin/interface/symbol.c

@@ -0,0 +1,7 @@
+#include <mie/dialect/builtin.h>
+#include <mie/interface/interface-definition.h>
+#include <mie/macros.h>
+
+MIE_INTERFACE_DEFINITION_BEGIN(mie_builtin_symbol, "symbol")
+	MIE_INTERFACE_DEFINITION_STRUCT(struct mie_symbol);
+MIE_INTERFACE_DEFINITION_END()

mie/dialect/builtin/op/module.c

@@ -0,0 +1,30 @@
+#include <mie/ctx.h>
+#include <mie/dialect/dialect.h>
+#include <mie/ir/op-definition.h>
+#include <mie/ir/op.h>
+#include <mie/ir/region.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+
+static enum mie_status print(struct mie_printer *out, const struct mie_op *op)
+{
+	b_stream_write_char(out->p_stream, ' ');
+
+	struct mie_region *region = mie_op_get_first_region(op);
+	if (region) {
+		mie_printer_print_region(out, region, 0);
+	}
+
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+{
+	return MIE_SUCCESS;
+}
+
+MIE_OP_DEFINITION_BEGIN(mie_builtin_module, "module")
+	MIE_OP_DEFINITION_PRINT(print);
+	MIE_OP_DEFINITION_PARSE(parse);
+	MIE_OP_DEFINITION_TRAIT("builtin", "isolated-from-above");
+MIE_OP_DEFINITION_END()

mie/dialect/builtin/string-cache.c

@@ -0,0 +1,80 @@
+#include <blue/core/btree.h>
+#include <blue/ds/hashmap.h>
+#include <mie/ctx.h>
+#include <mie/dialect/builtin.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct mie_string_cache {
+	b_hashmap *c_entries;
+};
+
+static struct mie_string *mie_string_create(
+	struct mie_ctx *ctx, const char *s, size_t len)
+{
+	struct mie_string *out = malloc(sizeof *out);
+	if (!out) {
+		return NULL;
+	}
+
+	out->str_base.a_def
+		= mie_ctx_get_attribute_definition(ctx, "builtin", "string");
+	out->str_val = b_strdup(s);
+	if (!out->str_val) {
+		return NULL;
+	}
+
+	out->str_len = len;
+
+	return out;
+}
+
+static void mie_string_destroy(struct mie_string *str)
+{
+}
+
+struct mie_string_cache *mie_string_cache_create(void)
+{
+	struct mie_string_cache *out = malloc(sizeof *out);
+	if (!out) {
+		return NULL;
+	}
+
+	memset(out, 0x0, sizeof *out);
+
+	out->c_entries = b_hashmap_create(
+		NULL, (b_hashmap_value_destructor)mie_string_destroy);
+	if (!out->c_entries) {
+		free(out);
+		return NULL;
+	}
+
+	return out;
+}
+
+void mie_string_cache_destroy(struct mie_string_cache *cache)
+{
+	b_hashmap_unref(cache->c_entries);
+	free(cache);
+}
+
+struct mie_string *mie_string_cache_get(
+	struct mie_string_cache *cache, struct mie_ctx *ctx, const char *s)
+{
+	size_t s_len = strlen(s);
+	b_hashmap_key key = {.key_data = s, .key_size = s_len};
+	const b_hashmap_value *value = b_hashmap_get(cache->c_entries, &key);
+	if (value) {
+		return value->value_data;
+	}
+
+	struct mie_string *str = mie_string_create(ctx, s, s_len);
+	if (!str) {
+		return NULL;
+	}
+
+	b_hashmap_value new_val = {.value_data = str, .value_size = sizeof *str};
+	b_hashmap_put(cache->c_entries, &key, &new_val);
+
+	return str;
+}

mie/dialect/builtin/trait/isolated-from-above.c

@@ -0,0 +1,21 @@
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+#include <mie/trait/trait-definition.h>
+#include <mie/trait/trait.h>
+
+static enum mie_status validate(
+	const struct mie_trait_definition *trait_def,
+	const struct mie_trait *trait, const struct mie_trait_target *target)
+{
+	return MIE_SUCCESS;
+}
+
+/* builtin.isolated-from-above trait:
+ * regions of an op that has this trait cannot capture or reference
+ * values defined in the enclosing scope. */
+MIE_TRAIT_DEFINITION_BEGIN(
+	mie_builtin_isolated_from_above, "isolated-from-above")
+	MIE_TRAIT_DEFINITION_TARGETS(MIE_TRAIT_TARGET_OP | MIE_TRAIT_TARGET_TYPE);
+	MIE_TRAIT_DEFINITION_STRUCT(struct mie_trait);
+	MIE_TRAIT_DEFINITION_VALIDATE(validate);
+MIE_TRAIT_DEFINITION_END()

mie/dialect/builtin/trait/symbol-table.c

@@ -0,0 +1,21 @@
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+#include <mie/trait/trait-definition.h>
+#include <mie/trait/trait.h>
+
+static enum mie_status validate(
+	const struct mie_trait_definition *trait_def,
+	const struct mie_trait *trait, const struct mie_trait_target *target)
+{
+	return MIE_SUCCESS;
+}
+
+/* builtin.isolated-from-above trait:
+ * regions of an op that has this trait cannot capture or reference
+ * values defined in the enclosing scope. */
+MIE_TRAIT_DEFINITION_BEGIN(mie_builtin_symbol_table, "symbol-table")
+	MIE_TRAIT_DEFINITION_TARGETS(MIE_TRAIT_TARGET_OP | MIE_TRAIT_TARGET_TYPE);
+	MIE_TRAIT_DEFINITION_STRUCT(struct mie_symbol_table);
+	MIE_TRAIT_DEFINITION_VALIDATE(validate);
+MIE_TRAIT_DEFINITION_END()

mie/dialect/builtin/type/float.c

@@ -0,0 +1,80 @@
+#include "../float.h"
+
+#include <blue/core/bstr.h>
+#include <mie/ctx.h>
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+#include <mie/type/type-definition.h>
+#include <mie/type/type.h>
+
+struct mie_type *mie_ctx_get_float_type(struct mie_ctx *ctx, size_t bit_width)
+{
+	struct mie_type_definition *type_info
+		= mie_ctx_get_type_definition(ctx, "builtin", "float");
+	if (!type_info) {
+		return NULL;
+	}
+
+	b_rope rope_i = B_ROPE_CHAR('f'), rope_width = B_ROPE_UINT(bit_width);
+	b_rope type_name;
+	b_rope_concat(&type_name, &rope_i, &rope_width);
+
+	mie_id id;
+	mie_id_init_ns(&id, mie_id_map_get_ns(&ctx->ctx_types), &type_name);
+
+	mie_id *target = mie_id_map_get(&ctx->ctx_types, &id);
+	if (target) {
+		return b_unbox(struct mie_type, target, ty_id);
+	}
+
+	struct float_type *type = (struct float_type *)mie_type_create(type_info);
+	if (!type) {
+		return NULL;
+	}
+
+	type->f_base.ty_name = b_bstr_fmt(NULL, "builtin.float<%zu>", bit_width);
+	type->f_base.ty_instance_size = sizeof(struct mie_float);
+	type->f_width = bit_width;
+
+	mie_id_map_put(&ctx->ctx_types, &type->f_base.ty_id, &type_name);
+	return (struct mie_type *)type;
+}
+
+size_t mie_float_type_get_width(const struct mie_type *type)
+{
+	if (strcmp(type->ty_def->ty_parent->d_name, "builtin") != 0) {
+		return (size_t)-1;
+	}
+
+	if (strcmp(type->ty_def->ty_name, "float") != 0) {
+		return (size_t)-1;
+	}
+
+	const struct float_type *float_type = (const struct float_type *)type;
+	return float_type->f_width;
+}
+
+static enum mie_status print(const struct mie_type *ty, struct mie_printer *out)
+{
+	const struct float_type *float_type = (const struct float_type *)ty;
+	b_stream_write_fmt(
+		out->p_stream, NULL,
+		(out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "f%zu" : "!builtin.float<%zu>",
+		float_type->f_width);
+
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, const struct mie_type **out)
+{
+	return MIE_SUCCESS;
+}
+
+MIE_TYPE_DEFINITION_BEGIN(mie_builtin_float, "float")
+	// MIE_TYPE_DEFINITION_FLAGS(MIE_TYPE_DEFINITION_PARAMETISED);
+	MIE_TYPE_DEFINITION_STRUCT(struct float_type);
+	MIE_TYPE_DEFINITION_PRINT(print);
+	MIE_TYPE_DEFINITION_PARSE(parse);
+MIE_TYPE_DEFINITION_END()

mie/dialect/builtin/type/index.c

@@ -0,0 +1,21 @@
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+#include <mie/type/type-definition.h>
+#include <mie/type/type.h>
+
+struct index_type {
+	struct mie_type i_base;
+};
+
+static void type_init(
+	const struct mie_type_definition *type_info, struct mie_type *type)
+{
+	type->ty_instance_size = sizeof(struct mie_index);
+}
+
+MIE_TYPE_DEFINITION_BEGIN(mie_builtin_index, "index")
+	MIE_TYPE_DEFINITION_STRUCT(struct index_type);
+	MIE_TYPE_DEFINITION_INIT(type_init);
+MIE_TYPE_DEFINITION_END()

mie/dialect/builtin/type/int.c

@@ -0,0 +1,81 @@
+#include "../int.h"
+
+#include <blue/core/bstr.h>
+#include <mie/ctx.h>
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+#include <mie/type/type-definition.h>
+#include <mie/type/type.h>
+
+struct mie_type *mie_ctx_get_int_type(struct mie_ctx *ctx, size_t bit_width)
+{
+	struct mie_type_definition *type_info
+		= mie_ctx_get_type_definition(ctx, "builtin", "int");
+	if (!type_info) {
+		return NULL;
+	}
+
+	b_rope rope_i = B_ROPE_CHAR('i'), rope_width = B_ROPE_UINT(bit_width);
+	b_rope type_name;
+	b_rope_concat(&type_name, &rope_i, &rope_width);
+
+	mie_id id;
+	mie_id_init_ns(&id, mie_id_map_get_ns(&ctx->ctx_types), &type_name);
+
+	mie_id *target = mie_id_map_get(&ctx->ctx_types, &id);
+	if (target) {
+		return b_unbox(struct mie_type, target, ty_id);
+	}
+
+	struct int_type *type = (struct int_type *)mie_type_create(type_info);
+	if (!type) {
+		return NULL;
+	}
+
+	type->i_base.ty_name = b_bstr_fmt(NULL, "builtin.int<%zu>", bit_width);
+	type->i_base.ty_instance_size = sizeof(struct mie_int);
+	type->i_width = bit_width;
+
+	mie_id_map_put(&ctx->ctx_types, &type->i_base.ty_id, &type_name);
+	return (struct mie_type *)type;
+}
+
+size_t mie_int_type_get_width(const struct mie_type *type)
+{
+	if (strcmp(type->ty_def->ty_parent->d_name, "builtin") != 0) {
+		return (size_t)-1;
+	}
+
+	if (strcmp(type->ty_def->ty_name, "int") != 0) {
+		return (size_t)-1;
+	}
+
+	const struct int_type *int_type = (const struct int_type *)type;
+	return int_type->i_width;
+}
+
+static enum mie_status print(const struct mie_type *ty, struct mie_printer *out)
+{
+	const struct int_type *int_type = (const struct int_type *)ty;
+	b_stream_write_fmt(
+		out->p_stream, NULL,
+		(out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "i%zu"
+							 : "!builtin.int<%zu>",
+		int_type->i_width);
+
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, const struct mie_type **out)
+{
+	return MIE_SUCCESS;
+}
+
+MIE_TYPE_DEFINITION_BEGIN(mie_builtin_int, "int")
+	// MIE_TYPE_DEFINITION_FLAGS(MIE_TYPE_DEFINITION_PARAMETISED);
+	MIE_TYPE_DEFINITION_STRUCT(struct int_type);
+	MIE_TYPE_DEFINITION_PRINT(print);
+	MIE_TYPE_DEFINITION_PARSE(parse);
+MIE_TYPE_DEFINITION_END()

mie/dialect/builtin/type/string.c

@@ -0,0 +1,29 @@
+#include <blue/core/bstr.h>
+#include <mie/ctx.h>
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+#include <mie/type/type-definition.h>
+#include <mie/type/type.h>
+
+static void type_init(
+	const struct mie_type_definition *type_info, struct mie_type *type)
+{
+	type->ty_instance_size = sizeof(struct mie_string);
+}
+
+static enum mie_status print(const struct mie_type *ty, struct mie_printer *out)
+{
+	b_stream_write_string(
+		out->p_stream,
+		(out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "str" : "!builtin.string",
+		NULL);
+	return MIE_SUCCESS;
+}
+
+MIE_TYPE_DEFINITION_BEGIN(mie_builtin_string, "string")
+	MIE_TYPE_DEFINITION_STRUCT(struct mie_type);
+	MIE_TYPE_DEFINITION_INIT(type_init);
+	MIE_TYPE_DEFINITION_PRINT(print);
+MIE_TYPE_DEFINITION_END()

mie/dialect/cf/cf.c

@@ -0,0 +1,7 @@
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+
+MIE_DIALECT_BEGIN(mie_cf, struct mie_dialect, "cf")
+	MIE_DIALECT_ADD_OP(mie_cf_br);
+	MIE_DIALECT_ADD_OP(mie_cf_br_cond);
+MIE_DIALECT_END()

mie/dialect/cf/op/br-cond.c

@@ -0,0 +1,57 @@
+#include <mie/dialect/dialect.h>
+#include <mie/ir/emit.h>
+#include <mie/ir/op-definition.h>
+#include <mie/ir/op.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+
+static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
+{
+	if (MIE_VECTOR_COUNT(op->op_args) != 1) {
+		return MIE_SUCCESS;
+	}
+
+	if (MIE_VECTOR_COUNT(op->op_successors) != 2) {
+		return MIE_SUCCESS;
+	}
+
+	const struct mie_op_arg *cond = &op->op_args.items[0];
+	const struct mie_op_successor *if_true = &op->op_successors.items[0];
+	const struct mie_op_successor *if_false = &op->op_successors.items[1];
+
+	b_stream_write_char(printer->p_stream, ' ');
+	mie_printer_print_op_arg(printer, cond, false);
+	b_stream_write_string(printer->p_stream, ", ", NULL);
+	mie_printer_print_op_successor(printer, if_true, true);
+	b_stream_write_string(printer->p_stream, ", ", NULL);
+	mie_printer_print_op_successor(printer, if_false, true);
+
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+{
+	return MIE_SUCCESS;
+}
+
+struct mie_op *mie_cf_br_cond_put(
+	struct mie_emitter *e, struct mie_register *cond,
+	struct mie_block *true_block, struct mie_register **true_args,
+	size_t nr_true_args, struct mie_block *false_block,
+	struct mie_register **false_args, size_t nr_false_args)
+{
+	struct mie_op *op = mie_emitter_put_op(e, "cf", "br-cond", &cond, 1);
+	if (!op) {
+		return NULL;
+	}
+
+	mie_op_add_successor(op, true_block, true_args, nr_true_args);
+	mie_op_add_successor(op, false_block, false_args, nr_false_args);
+
+	return op;
+}
+
+MIE_OP_DEFINITION_BEGIN(mie_cf_br_cond, "br-cond")
+	MIE_OP_DEFINITION_PRINT(print);
+	MIE_OP_DEFINITION_PARSE(parse);
+MIE_OP_DEFINITION_END()

mie/dialect/cf/op/br.c

@@ -0,0 +1,42 @@
+#include <mie/dialect/dialect.h>
+#include <mie/ir/block.h>
+#include <mie/ir/emit.h>
+#include <mie/ir/op-definition.h>
+#include <mie/ir/op.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+
+static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
+{
+	b_stream_write_char(printer->p_stream, ' ');
+	const struct mie_op_successor *successor = &op->op_successors.items[0];
+
+	mie_printer_print_op_successor(printer, successor, true);
+
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+{
+	return MIE_SUCCESS;
+}
+
+struct mie_op *mie_cf_br_put(
+	struct mie_emitter *e, struct mie_block *dest,
+	struct mie_register **dest_args, size_t nr_dest_args)
+{
+	struct mie_op *op = mie_emitter_put_op(e, "cf", "br", NULL, 0);
+	if (!op) {
+		return NULL;
+	}
+
+	struct mie_op_successor *s
+		= mie_op_add_successor(op, dest, dest_args, nr_dest_args);
+
+	return op;
+}
+
+MIE_OP_DEFINITION_BEGIN(mie_cf_br, "br")
+	MIE_OP_DEFINITION_PRINT(print);
+	MIE_OP_DEFINITION_PARSE(parse);
+MIE_OP_DEFINITION_END()

mie/dialect/dialect.c

@@ -0,0 +1,87 @@
+#include <blue/ds/string.h>
+#include <mie/ctx.h>
+#include <mie/dialect/dialect.h>
+#include <mie/ir/op-definition.h>
+#include <mie/type/type-definition.h>
+
+#define TYPE_NS_ID                                                             \
+	MIE_ID(0xe4, 0x99, 0x42, 0x58, 0x2b, 0xdb, 0x45, 0xa3, 0xbd, 0x4b,     \
+	       0x17, 0xe3, 0xc4, 0xa9, 0xbc, 0x30)
+#define OP_NS_ID                                                               \
+	MIE_ID(0xb9, 0x97, 0xcf, 0xd3, 0x81, 0xd4, 0x45, 0x06, 0x9b, 0x44,     \
+	       0x05, 0x9f, 0xb4, 0x76, 0xf1, 0x2d)
+
+#define TRAIT_NS_ID                                                            \
+	MIE_ID(0x5a, 0x11, 0x68, 0x8e, 0x21, 0x1d, 0x4d, 0x5f, 0xb8, 0x6b,     \
+	       0x39, 0x73, 0xb0, 0x1f, 0xce, 0xf7)
+
+#define ATTRIBUTE_NS_ID                                                        \
+	MIE_ID(0x86, 0x76, 0xcb, 0xfb, 0xc8, 0xe5, 0x40, 0x7d, 0xa3, 0x84,     \
+	       0x93, 0xe3, 0xa5, 0x29, 0x74, 0xfe)
+
+#define INTERFACE_NS_ID                                                        \
+	MIE_ID(0xc5, 0x85, 0x7f, 0x8a, 0x7d, 0xe4, 0x4d, 0x03, 0x88, 0x8d,     \
+	       0x34, 0x32, 0xbf, 0x29, 0x5c, 0x72)
+
+struct mie_dialect *mie_dialect_create(
+	struct mie_ctx *ctx, const char *name, size_t size)
+{
+	if (size < sizeof(struct mie_dialect)) {
+		return NULL;
+	}
+
+	struct mie_dialect *out = malloc(size);
+	if (!out) {
+		return NULL;
+	}
+
+	memset(out, 0x0, size);
+
+	out->d_name = b_strdup(name);
+	if (!out->d_name) {
+		free(out);
+		return NULL;
+	}
+
+	mie_id op_ns = OP_NS_ID;
+	mie_id_map_init(&out->d_ops, &op_ns);
+
+	mie_id type_ns = TYPE_NS_ID;
+	mie_id_map_init(&out->d_types, &type_ns);
+
+	mie_id trait_ns = TRAIT_NS_ID;
+	mie_id_map_init(&out->d_traits, &trait_ns);
+
+	mie_id attribute_ns = ATTRIBUTE_NS_ID;
+	mie_id_map_init(&out->d_attributes, &attribute_ns);
+
+	mie_id interface_ns = INTERFACE_NS_ID;
+	mie_id_map_init(&out->d_interfaces, &interface_ns);
+
+	b_rope name_rope = B_ROPE_CSTR(name);
+	mie_id_map_put(&ctx->ctx_dialects, &out->d_id, &name_rope);
+
+	return out;
+}
+
+const struct mie_op_definition *mie_dialect_get_op(
+	const struct mie_dialect *dialect, const char *name)
+{
+	b_rope name_rope = B_ROPE_CSTR(name);
+	mie_id id;
+	mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_ops), &name_rope);
+
+	mie_id *target = mie_id_map_get(&dialect->d_ops, &id);
+	return b_unbox(struct mie_op_definition, target, op_id);
+}
+
+const struct mie_type_definition *mie_dialect_get_type(
+	const struct mie_dialect *dialect, const char *name)
+{
+	b_rope name_rope = B_ROPE_CSTR(name);
+	mie_id id;
+	mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_types), &name_rope);
+
+	mie_id *target = mie_id_map_get(&dialect->d_types, &id);
+	return b_unbox(struct mie_type_definition, target, ty_id);
+}

mie/dialect/func/func.c

@@ -0,0 +1,9 @@
+#include <mie/dialect/dialect.h>
+#include <mie/ir/op-definition.h>
+#include <mie/macros.h>
+
+MIE_DIALECT_BEGIN(mie_func, struct mie_dialect, "func")
+	MIE_DIALECT_ADD_TRAIT(mie_func_function_like);
+	MIE_DIALECT_ADD_OP(mie_func_func);
+	MIE_DIALECT_ADD_OP(mie_func_return);
+MIE_DIALECT_END()

mie/dialect/func/op/func.c

@@ -0,0 +1,137 @@
+#include <mie/attribute/attribute-map.h>
+#include <mie/ctx.h>
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/dialect.h>
+#include <mie/dialect/func.h>
+#include <mie/interface/interface-definition.h>
+#include <mie/interface/interface.h>
+#include <mie/ir/block.h>
+#include <mie/ir/emit.h>
+#include <mie/ir/op-definition.h>
+#include <mie/ir/op.h>
+#include <mie/ir/region.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+#include <mie/type/function.h>
+
+static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
+{
+	const struct mie_attribute *sym_name
+		= mie_attribute_map_get(&op->op_attrib, "sym_name");
+	const struct mie_attribute *function_type_attr
+		= mie_attribute_map_get(&op->op_attrib, "function_type");
+	const char *sym_name_cstr = mie_string_get_cstr(sym_name);
+	const struct mie_type *function_type_g
+		= mie_type_attr_get_type(function_type_attr);
+	const struct mie_function_type *function_ty
+		= (const struct mie_function_type *)function_type_g;
+
+	b_stream_write_fmt(printer->p_stream, NULL, " @%s(", sym_name_cstr);
+
+	const struct mie_region *code = mie_op_get_first_region(op);
+	const struct mie_block *entry = mie_region_get_first_block(code);
+
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(entry->b_params); i++) {
+		if (i > 0) {
+			b_stream_write_string(printer->p_stream, ", ", NULL);
+		}
+
+		const struct mie_register *param = &entry->b_params.items[i];
+
+		mie_printer_print_register(printer, param, MIE_PRINT_F_INCLUDE_TYPE);
+	}
+
+	b_stream_write_string(printer->p_stream, ") -> ", NULL);
+
+	if (MIE_VECTOR_COUNT(function_ty->func_out) != 1) {
+		b_stream_write_char(printer->p_stream, '(');
+	}
+
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(function_ty->func_out); i++) {
+		if (i > 0) {
+			b_stream_write_string(printer->p_stream, ", ", NULL);
+		}
+
+		const struct mie_type *ty = function_ty->func_out.items[i];
+
+		mie_printer_print_type(printer, ty);
+	}
+
+	if (MIE_VECTOR_COUNT(function_ty->func_out) != 1) {
+		b_stream_write_char(printer->p_stream, ')');
+	}
+
+	b_stream_write_char(printer->p_stream, ' ');
+
+	mie_printer_print_region(
+		printer, code, MIE_PRINT_F_EXCLUDE_FIRST_BLOCK_HEADER);
+
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+{
+	return MIE_SUCCESS;
+}
+
+struct mie_op *mie_func_func_put(
+	struct mie_emitter *e, const char *name, struct mie_func_parameter *params,
+	size_t nr_params, const struct mie_type **ret_types, size_t nr_ret_types)
+{
+	const struct mie_type **param_types
+		= calloc(nr_params, sizeof *param_types);
+	if (!param_types) {
+		return NULL;
+	}
+
+	for (size_t i = 0; i < nr_params; i++) {
+		param_types[i] = params[i].param_type;
+	}
+
+	const struct mie_type *func_type = mie_ctx_get_function_type(
+		mie_emitter_get_ctx(e), param_types, nr_params, ret_types,
+		nr_ret_types);
+	free(param_types);
+
+	if (!func_type) {
+		return NULL;
+	}
+
+	struct mie_op *op = mie_emitter_put_op(e, "func", "func", NULL, 0);
+
+	struct mie_region *region = mie_op_add_region(op);
+	struct mie_block *entry = mie_region_add_block(region);
+	mie_name_map_put(region->r_names, &entry->b_name, "entry", 0);
+
+	for (size_t i = 0; i < nr_params; i++) {
+		struct mie_register *param_reg = mie_block_add_param(entry);
+		mie_name_map_put(
+			region->r_names, &param_reg->reg_name,
+			params[i].param_name, 0);
+		param_reg->reg_type = params[i].param_type;
+		params[i].param_reg = param_reg;
+	}
+
+	struct mie_attribute *sym_name
+		= mie_ctx_get_string(mie_emitter_get_ctx(e), name);
+	struct mie_attribute *function_type
+		= mie_type_attr_create(mie_emitter_get_ctx(e), func_type);
+
+	mie_attribute_map_put(
+		&op->op_attrib, "sym_name", sym_name, MIE_ATTRMAP_F_REPLACE);
+	mie_attribute_map_put(
+		&op->op_attrib, "function_type", function_type,
+		MIE_ATTRMAP_F_REPLACE);
+
+	return op;
+}
+
+MIE_OP_DEFINITION_BEGIN(mie_func_func, "func")
+	MIE_OP_DEFINITION_PRINT(print);
+	MIE_OP_DEFINITION_PARSE(parse);
+	MIE_OP_DEFINITION_TRAIT("builtin", "isolated-from-above");
+	MIE_OP_DEFINITION_TRAIT("func", "function-like");
+	MIE_OP_INTERFACE_BEGIN("builtin", "symbol", struct mie_symbol)
+		MIE_OP_INTERFACE_FUNC(sym_get_name) = NULL;
+	MIE_OP_INTERFACE_END()
+MIE_OP_DEFINITION_END()

mie/dialect/func/op/return.c

@@ -0,0 +1,49 @@
+#include <mie/attribute/attribute-map.h>
+#include <mie/ctx.h>
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/dialect.h>
+#include <mie/interface/interface-definition.h>
+#include <mie/interface/interface.h>
+#include <mie/ir/block.h>
+#include <mie/ir/op-definition.h>
+#include <mie/ir/op.h>
+#include <mie/ir/region.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+#include <mie/type/function.h>
+
+static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
+{
+	b_stream_write_char(printer->p_stream, ' ');
+
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) {
+		if (i > 0) {
+			b_stream_write_string(printer->p_stream, ", ", NULL);
+		}
+
+		mie_printer_print_op_arg(printer, &op->op_args.items[i], false);
+	}
+
+	b_stream_write_string(printer->p_stream, " : ", NULL);
+
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) {
+		if (i > 0) {
+			b_stream_write_string(printer->p_stream, ", ", NULL);
+		}
+
+		mie_printer_print_type(
+			printer, mie_op_arg_get_type(&op->op_args.items[i]));
+	}
+
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+{
+	return MIE_SUCCESS;
+}
+
+MIE_OP_DEFINITION_BEGIN(mie_func_return, "return")
+	MIE_OP_DEFINITION_PRINT(print);
+	MIE_OP_DEFINITION_PARSE(parse);
+MIE_OP_DEFINITION_END()

mie/dialect/func/trait/function-like.c

@@ -0,0 +1,23 @@
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+#include <mie/trait/trait-definition.h>
+#include <mie/trait/trait.h>
+
+static enum mie_status validate(
+	const struct mie_trait_definition *trait_def,
+	const struct mie_trait *trait, const struct mie_trait_target *target)
+{
+	return MIE_SUCCESS;
+}
+
+/* func.function-like trait:
+ * the op behaves like a func.func. this means that it:
+ *   a) has a single region
+ *   b) that region has one or more blocks representing the body of a function.
+ *   c) the op has sym_name, function_type, and other function-related attributes.
+ */
+MIE_TRAIT_DEFINITION_BEGIN(mie_func_function_like, "function-like")
+	MIE_TRAIT_DEFINITION_TARGETS(MIE_TRAIT_TARGET_OP);
+	MIE_TRAIT_DEFINITION_STRUCT(struct mie_trait);
+	MIE_TRAIT_DEFINITION_VALIDATE(validate);
+MIE_TRAIT_DEFINITION_END()

mie/dialect/index/index.c

@@ -0,0 +1,10 @@
+#include <mie/ctx.h>
+#include <mie/dialect/dialect.h>
+#include <mie/dialect/index.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+#include <mie/type/type-definition.h>
+#include <mie/type/type.h>
+
+MIE_DIALECT_BEGIN(mie_index, struct mie_dialect, "index")
+MIE_DIALECT_END()

mie/dialect/memref/memref.c

@@ -0,0 +1,11 @@
+#include <mie/dialect/dialect.h>
+#include <mie/dialect/memref.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+#include <mie/type/type-definition.h>
+#include <mie/type/type.h>
+
+MIE_DIALECT_BEGIN(mie_memref, struct mie_dialect, "memref")
+	MIE_DIALECT_ADD_TYPE(mie_memref_memref);
+	MIE_DIALECT_ADD_OP(mie_memref_load);
+MIE_DIALECT_END()

mie/dialect/memref/op/load.c

@@ -0,0 +1,18 @@
+#include <mie/ctx.h>
+#include <mie/ir/op-definition.h>
+#include <mie/macros.h>
+
+static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
+{
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+{
+	return MIE_SUCCESS;
+}
+
+MIE_OP_DEFINITION_BEGIN(mie_memref_load, "load")
+	MIE_OP_DEFINITION_PRINT(print);
+	MIE_OP_DEFINITION_PARSE(parse);
+MIE_OP_DEFINITION_END()

mie/dialect/memref/type/memref.c

@@ -0,0 +1,52 @@
+#include <mie/dialect/dialect.h>
+#include <mie/dialect/memref.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+#include <mie/type/type-definition.h>
+#include <mie/type/type.h>
+
+enum memref_rank_type {
+	MEMREF_RANK_UNKNOWN = 0,
+	MEMREF_RANK_STATIC,
+	MEMREF_RANK_TYPE,
+};
+
+struct memref_rank {
+	enum memref_rank_type r_ranktype;
+	union {
+		size_t r_static;
+		const struct mie_type *r_type;
+	};
+};
+
+struct memref_type {
+	struct mie_type m_base;
+	MIE_VECTOR_DECLARE(struct memref_rank, m_rank);
+};
+
+static void type_init(
+	const struct mie_type_definition *type_info, struct mie_type *type)
+{
+}
+
+static enum mie_status print(const struct mie_type *ty, struct mie_printer *out)
+{
+	b_stream_write_string(
+		out->p_stream,
+		(out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "memref" : "memref.memref",
+		NULL);
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, const struct mie_type **out)
+{
+	printf("Parse memref!\n");
+
+	return MIE_ERR_BAD_FORMAT;
+}
+
+MIE_TYPE_DEFINITION_BEGIN(mie_memref_memref, "memref")
+	MIE_TYPE_DEFINITION_INIT(type_init);
+	MIE_TYPE_DEFINITION_PRINT(print);
+	MIE_TYPE_DEFINITION_PARSE(parse);
+MIE_TYPE_DEFINITION_END()

mie/dialect/meta/meta.c

@@ -0,0 +1,6 @@
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+
+MIE_DIALECT_BEGIN(mie_meta, struct mie_dialect, "meta")
+	MIE_DIALECT_ADD_OP(mie_meta_source_filename);
+MIE_DIALECT_END()

mie/dialect/meta/op/source-filename.c

@@ -0,0 +1,18 @@
+#include <mie/dialect/dialect.h>
+#include <mie/ir/op-definition.h>
+#include <mie/macros.h>
+
+static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
+{
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+{
+	return MIE_SUCCESS;
+}
+
+MIE_OP_DEFINITION_BEGIN(mie_meta_source_filename, "source-filename")
+	MIE_OP_DEFINITION_PRINT(print);
+	MIE_OP_DEFINITION_PARSE(parse);
+MIE_OP_DEFINITION_END()

mie/dialect/ptr/op/load.c

@@ -0,0 +1,18 @@
+#include <mie/dialect/dialect.h>
+#include <mie/ir/op-definition.h>
+#include <mie/macros.h>
+
+static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
+{
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+{
+	return MIE_SUCCESS;
+}
+
+MIE_OP_DEFINITION_BEGIN(mie_ptr_load, "load")
+	MIE_OP_DEFINITION_PRINT(print);
+	MIE_OP_DEFINITION_PARSE(parse);
+MIE_OP_DEFINITION_END()

mie/dialect/ptr/op/store.c

@@ -0,0 +1,18 @@
+#include <mie/dialect/dialect.h>
+#include <mie/ir/op-definition.h>
+#include <mie/macros.h>
+
+static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
+{
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+{
+	return MIE_SUCCESS;
+}
+
+MIE_OP_DEFINITION_BEGIN(mie_ptr_store, "store")
+	MIE_OP_DEFINITION_PRINT(print);
+	MIE_OP_DEFINITION_PARSE(parse);
+MIE_OP_DEFINITION_END()

mie/dialect/ptr/ptr.c

@@ -0,0 +1,9 @@
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+#include <mie/type/type-definition.h>
+
+MIE_DIALECT_BEGIN(mie_ptr, struct mie_dialect, "ptr")
+	MIE_DIALECT_ADD_OP(mie_ptr_load);
+	MIE_DIALECT_ADD_OP(mie_ptr_store);
+	MIE_DIALECT_ADD_TYPE(mie_ptr_ptr);
+MIE_DIALECT_END()

mie/dialect/ptr/type/ptr.c

@@ -0,0 +1,17 @@
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+#include <mie/type/type-definition.h>
+
+struct ptr_type {
+	struct mie_type_definition ptr_base;
+};
+
+static enum mie_status print(const struct mie_type *ty, struct mie_printer *out)
+{
+	return MIE_SUCCESS;
+}
+
+MIE_TYPE_DEFINITION_BEGIN(mie_ptr_ptr, "ptr")
+	MIE_TYPE_DEFINITION_STRUCT(struct ptr_type);
+	MIE_TYPE_DEFINITION_PRINT(print);
+MIE_TYPE_DEFINITION_END()

mie/dialect/scf/op/for.c

@@ -0,0 +1,18 @@
+#include <mie/dialect/dialect.h>
+#include <mie/ir/op-definition.h>
+#include <mie/macros.h>
+
+static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
+{
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+{
+	return MIE_SUCCESS;
+}
+
+MIE_OP_DEFINITION_BEGIN(mie_scf_for, "for")
+	MIE_OP_DEFINITION_PRINT(print);
+	MIE_OP_DEFINITION_PARSE(parse);
+MIE_OP_DEFINITION_END()

mie/dialect/scf/op/if.c

@@ -0,0 +1,86 @@
+#include <mie/dialect/dialect.h>
+#include <mie/ir/emit.h>
+#include <mie/ir/op-definition.h>
+#include <mie/ir/op.h>
+#include <mie/ir/region.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+
+static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
+{
+	b_stream_write_char(printer->p_stream, ' ');
+	mie_printer_print_op_arg(printer, &op->op_args.items[0], false);
+
+	if (MIE_VECTOR_COUNT(op->op_result) > 0) {
+		b_stream_write_string(printer->p_stream, " -> ", NULL);
+
+		if (MIE_VECTOR_COUNT(op->op_result) > 1) {
+			b_stream_write_char(printer->p_stream, '(');
+		}
+	}
+
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_result); i++) {
+		if (i > 0) {
+			b_stream_write_string(printer->p_stream, ", ", NULL);
+		}
+
+		mie_printer_print_type(printer, op->op_result.items[i].reg_type);
+	}
+
+	if (MIE_VECTOR_COUNT(op->op_result) > 1) {
+		b_stream_write_char(printer->p_stream, '(');
+	}
+
+	b_stream_write_char(printer->p_stream, ' ');
+
+	struct mie_region *if_region = mie_op_get_first_region(op);
+	struct mie_region *else_region = mie_op_get_next_region(op, if_region);
+
+	mie_printer_print_region(printer, if_region, 0);
+
+	if (else_region) {
+		b_stream_write_string(printer->p_stream, " else ", NULL);
+		mie_printer_print_region(printer, else_region, 0);
+	}
+
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+{
+	return MIE_SUCCESS;
+}
+
+struct mie_op *mie_scf_if_put(
+	struct mie_emitter *e, struct mie_register *cond,
+	const struct mie_type *result_type, struct mie_region **out_true,
+	struct mie_region **out_false, const char *name)
+{
+	struct mie_op *op = mie_emitter_put_op(e, "scf", "if", &cond, 1);
+	if (!op) {
+		return NULL;
+	}
+
+	if (result_type) {
+		struct mie_register *result = mie_op_add_result(op, result_type);
+		mie_emitter_put_name(e, &result->reg_name, name);
+	}
+
+	struct mie_region *r_true = mie_op_add_region(op);
+	struct mie_region *r_false = mie_op_add_region(op);
+
+	if (out_true) {
+		*out_true = r_true;
+	}
+
+	if (out_false) {
+		*out_false = r_false;
+	}
+
+	return op;
+}
+
+MIE_OP_DEFINITION_BEGIN(mie_scf_if, "if")
+	MIE_OP_DEFINITION_PRINT(print);
+	MIE_OP_DEFINITION_PARSE(parse);
+MIE_OP_DEFINITION_END()

mie/dialect/scf/op/yield.c

@@ -0,0 +1,46 @@
+#include <mie/dialect/dialect.h>
+#include <mie/ir/emit.h>
+#include <mie/ir/op-definition.h>
+#include <mie/ir/op.h>
+#include <mie/macros.h>
+#include <mie/print/printer.h>
+
+static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
+{
+	b_stream_write_char(printer->p_stream, ' ');
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) {
+		if (i > 0) {
+			b_stream_write_string(printer->p_stream, ", ", NULL);
+		}
+
+		mie_printer_print_op_arg(printer, &op->op_args.items[i], false);
+	}
+
+	b_stream_write_string(printer->p_stream, " : ", NULL);
+
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) {
+		if (i > 0) {
+			b_stream_write_string(printer->p_stream, ", ", NULL);
+		}
+
+		mie_printer_print_type(
+			printer, mie_op_arg_get_type(&op->op_args.items[i]));
+	}
+
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+{
+	return MIE_SUCCESS;
+}
+
+struct mie_op *mie_scf_yield_put(struct mie_emitter *e, struct mie_register *value)
+{
+	return mie_emitter_put_op(e, "scf", "yield", &value, 1);
+}
+
+MIE_OP_DEFINITION_BEGIN(mie_scf_yield, "yield")
+	MIE_OP_DEFINITION_PRINT(print);
+	MIE_OP_DEFINITION_PARSE(parse);
+MIE_OP_DEFINITION_END()

mie/dialect/scf/scf.c

@@ -0,0 +1,8 @@
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+
+MIE_DIALECT_BEGIN(mie_scf, struct mie_dialect, "scf")
+	MIE_DIALECT_ADD_OP(mie_scf_if);
+	MIE_DIALECT_ADD_OP(mie_scf_for);
+	MIE_DIALECT_ADD_OP(mie_scf_yield);
+MIE_DIALECT_END()

mie/dialect/select/attribute/graph-only.c

@@ -0,0 +1,21 @@
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+#include <mie/trait/trait-definition.h>
+#include <mie/trait/trait.h>
+
+static enum mie_status validate(
+	const struct mie_trait_definition *trait_def,
+	const struct mie_trait *trait, const struct mie_trait_target *target)
+{
+	return MIE_SUCCESS;
+}
+
+/* select.graph-only trait:
+ * this is a graph-only op. references to it by name must be prefixed with +
+ * and the op can only be used within graph regions.
+ * a graph op can have the same name as a regular or non-graph op. */
+MIE_TRAIT_DEFINITION_BEGIN(mie_select_graph_only, "graph-only")
+	MIE_TRAIT_DEFINITION_TARGETS(MIE_TRAIT_TARGET_OP | MIE_TRAIT_TARGET_TYPE);
+	MIE_TRAIT_DEFINITION_STRUCT(struct mie_trait);
+	MIE_TRAIT_DEFINITION_VALIDATE(validate);
+MIE_TRAIT_DEFINITION_END()

mie/dialect/select/attribute/graph-op.c

@@ -0,0 +1,21 @@
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+#include <mie/trait/trait-definition.h>
+#include <mie/trait/trait.h>
+
+static enum mie_status validate(
+	const struct mie_trait_definition *trait_def,
+	const struct mie_trait *trait, const struct mie_trait_target *target)
+{
+	return MIE_SUCCESS;
+}
+
+/* select.graph-op trait:
+ * ops with this trait can be used within graph regions. by default, ops cannot
+ * be used in graph regions unless they have the graph-op or graph-only traits.
+ */
+MIE_TRAIT_DEFINITION_BEGIN(mie_select_graph_op, "graph-op")
+	MIE_TRAIT_DEFINITION_TARGETS(MIE_TRAIT_TARGET_OP | MIE_TRAIT_TARGET_TYPE);
+	MIE_TRAIT_DEFINITION_STRUCT(struct mie_trait);
+	MIE_TRAIT_DEFINITION_VALIDATE(validate);
+MIE_TRAIT_DEFINITION_END()

mie/dialect/select/attribute/graph-scope.c

@@ -0,0 +1,21 @@
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+#include <mie/trait/trait-definition.h>
+#include <mie/trait/trait.h>
+
+static enum mie_status validate(
+	const struct mie_trait_definition *trait_def,
+	const struct mie_trait *trait, const struct mie_trait_target *target)
+{
+	return MIE_SUCCESS;
+}
+
+/* select.graph-scope trait:
+ * regions of an op that has this trait are graph regions. graph regions
+ * cannot have more than one block, and the entry block must be unnamed
+ * with no parameters. However, graph ops can be used. */
+MIE_TRAIT_DEFINITION_BEGIN(mie_select_graph_scope, "graph-scope")
+	MIE_TRAIT_DEFINITION_TARGETS(MIE_TRAIT_TARGET_OP | MIE_TRAIT_TARGET_TYPE);
+	MIE_TRAIT_DEFINITION_STRUCT(struct mie_trait);
+	MIE_TRAIT_DEFINITION_VALIDATE(validate);
+MIE_TRAIT_DEFINITION_END()

mie/dialect/select/op/graph.c

@@ -0,0 +1,21 @@
+#include <mie/ctx.h>
+#include <mie/dialect/dialect.h>
+#include <mie/ir/op-definition.h>
+#include <mie/macros.h>
+#include <mie/trait/trait.h>
+
+static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
+{
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+{
+	return MIE_SUCCESS;
+}
+
+MIE_OP_DEFINITION_BEGIN(mie_select_graph, "graph")
+	MIE_OP_DEFINITION_PRINT(print);
+	MIE_OP_DEFINITION_PARSE(parse);
+	MIE_OP_DEFINITION_TRAIT("select", "graph-scope");
+MIE_OP_DEFINITION_END()

mie/dialect/select/select.c

@@ -0,0 +1,9 @@
+#include <mie/dialect/dialect.h>
+#include <mie/macros.h>
+
+MIE_DIALECT_BEGIN(mie_select, struct mie_dialect, "select")
+	MIE_DIALECT_ADD_TRAIT(mie_select_graph_only);
+	MIE_DIALECT_ADD_TRAIT(mie_select_graph_op);
+	MIE_DIALECT_ADD_TRAIT(mie_select_graph_scope);
+	MIE_DIALECT_ADD_OP(mie_select_graph);
+MIE_DIALECT_END()

mie/id.c

@@ -0,0 +1,217 @@
+#include <blue/core/bstr.h>
+#include <blue/core/endian.h>
+#include <blue/core/hash.h>
+#include <blue/core/random.h>
+#include <mie/id.h>
+#include <string.h>
+
+static inline int id_memcmp(const uint8_t *a, const uint8_t *b)
+{
+	return memcmp(a, b, MIE_ID_NR_BYTES);
+}
+
+static mie_id *get_id(const b_btree *tree, mie_id *key)
+{
+	b_btree_node *cur = tree->b_root;
+	while (cur) {
+		mie_id *cur_node = b_unbox(mie_id, cur, e_node);
+		int cmp = memcmp(
+			key->id_bytes, cur_node->id_bytes, sizeof key->id_bytes);
+
+		if (cmp > 0) {
+			cur = b_btree_right(cur);
+		} else if (cmp < 0) {
+			cur = b_btree_left(cur);
+		} else {
+			return cur_node;
+		}
+	}
+
+	return NULL;
+}
+
+void put_id(b_btree *tree, mie_id *node)
+{
+	if (!tree->b_root) {
+		tree->b_root = &node->e_node;
+		b_btree_insert_fixup(tree, &node->e_node);
+		return;
+	}
+
+	b_btree_node *cur = tree->b_root;
+	while (1) {
+		mie_id *cur_node = b_unbox(mie_id, cur, e_node);
+		b_btree_node *next = NULL;
+		int cmp = memcmp(
+			node->id_bytes, cur_node->id_bytes, sizeof node->id_bytes);
+
+		if (cmp > 0) {
+			next = b_btree_right(cur);
+
+			if (!next) {
+				b_btree_put_right(cur, &node->e_node);
+				break;
+			}
+		} else if (cmp < 0) {
+			next = b_btree_left(cur);
+
+			if (!next) {
+				b_btree_put_left(cur, &node->e_node);
+				break;
+			}
+		} else {
+			return;
+		}
+
+		cur = next;
+	}
+
+	b_btree_insert_fixup(tree, &node->e_node);
+}
+
+void mie_id_init(
+	mie_id *out, uint32_t a, uint16_t b, uint16_t c, uint16_t d, uint64_t e)
+{
+	b_i32 x_a = b_i32_htob(a);
+	b_i16 x_b = b_i16_htob(b);
+	b_i16 x_c = b_i16_htob(c);
+	b_i16 x_d = b_i16_htob(d);
+	b_i64 x_e = b_i64_htob(e);
+
+	memcpy(&out->id_bytes[0], x_a.i_bytes, sizeof x_a.i_bytes);
+	memcpy(&out->id_bytes[4], x_b.i_bytes, sizeof x_b.i_bytes);
+	memcpy(&out->id_bytes[6], x_c.i_bytes, sizeof x_c.i_bytes);
+	memcpy(&out->id_bytes[8], x_d.i_bytes, sizeof x_d.i_bytes);
+	memcpy(&out->id_bytes[10], &x_e.i_bytes[2], sizeof x_e.i_bytes - 2);
+}
+
+void mie_id_init_zero(mie_id *out)
+{
+	memset(out, 0x0, sizeof *out);
+}
+
+void mie_id_init_random(mie_id *out)
+{
+	b_random_ctx *random = b_random_global_ctx();
+	b_random_next_bytes(
+		random, (unsigned char *)out->id_bytes, sizeof out->id_bytes);
+}
+
+void mie_id_init_ns(mie_id *out, const mie_id *ns, const b_rope *name)
+{
+	struct mie_id_builder ctx;
+	mie_id_builder_begin(&ctx, ns);
+	mie_id_builder_add_rope(&ctx, name);
+	mie_id_builder_end(&ctx, out);
+}
+
+void mie_id_to_string(const mie_id *id, char *out, size_t max)
+{
+	b_bstr str;
+	b_bstr_begin(&str, out, max);
+	for (size_t i = 0; i < sizeof id->id_bytes; i++) {
+		if (i == 4 || i == 6 || i == 8 || i == 10) {
+			b_bstr_write_char(&str, '-');
+		}
+
+		b_bstr_write_fmt(&str, NULL, "%02x", id->id_bytes[i]);
+	}
+}
+
+void mie_id_builder_begin(struct mie_id_builder *builder, const mie_id *ns)
+{
+	memset(builder, 0x0, sizeof *builder);
+	b_hash_ctx_init(&builder->b_hash, B_HASH_SHA1);
+	b_hash_ctx_update(&builder->b_hash, ns->id_bytes, sizeof ns->id_bytes);
+}
+
+void mie_id_builder_add(struct mie_id_builder *builder, const void *p, size_t len)
+{
+	b_hash_ctx_update(&builder->b_hash, p, len);
+}
+
+void mie_id_builder_add_rope(struct mie_id_builder *builder, const b_rope *rope)
+{
+	b_hash_ctx_update_rope(&builder->b_hash, rope);
+}
+
+void mie_id_builder_add_marker(
+	struct mie_id_builder *builder, enum mie_id_builder_marker marker)
+{
+	unsigned char c = marker;
+	b_hash_ctx_update(&builder->b_hash, &c, sizeof c);
+}
+
+void mie_id_builder_end(struct mie_id_builder *builder, mie_id *out)
+{
+	memset(out, 0x0, sizeof *out);
+	b_hash_ctx_finish(&builder->b_hash, out->id_bytes, sizeof out->id_bytes);
+
+	out->id_bytes[6] &= 0x0F;
+	out->id_bytes[6] |= 0x50;
+
+	out->id_bytes[8] &= 0x3F;
+	out->id_bytes[8] |= 0x80;
+}
+
+void mie_id_map_init(struct mie_id_map *map, const mie_id *ns)
+{
+	memset(map, 0x0, sizeof *map);
+
+	map->map_ns_id = *ns;
+}
+
+const mie_id *mie_id_map_get_ns(const struct mie_id_map *map)
+{
+	return &map->map_ns_id;
+}
+
+void mie_id_map_put(struct mie_id_map *map, mie_id *id, const b_rope *name)
+{
+	mie_id_init_ns(id, &map->map_ns_id, name);
+	put_id(&map->map_entries, id);
+}
+
+void mie_id_map_put_id(struct mie_id_map *map, mie_id *node)
+{
+	put_id(&map->map_entries, node);
+}
+
+mie_id *mie_id_map_get(const struct mie_id_map *map, mie_id *id)
+{
+	return get_id(&map->map_entries, id);
+}
+
+enum mie_status mie_id_map_iterator_begin(
+	struct mie_id_map_iterator *it, const struct mie_id_map *map)
+{
+	memset(it, 0x0, sizeof *it);
+
+	it->_n = b_btree_first(&map->map_entries);
+
+	if (!it->_n) {
+		return MIE_ERR_NO_DATA;
+	}
+
+	it->it_id = b_unbox(mie_id, it->_n, e_node);
+
+	return MIE_SUCCESS;
+}
+
+enum mie_status mie_id_map_iterator_move_next(struct mie_id_map_iterator *it)
+{
+	if (!it->_n) {
+		it->it_id = NULL;
+		return MIE_ERR_NO_DATA;
+	}
+
+	it->_n = b_btree_next(it->_n);
+	if (!it->_n) {
+		it->it_id = NULL;
+		return MIE_ERR_NO_DATA;
+	}
+
+	it->it_id = b_unbox(mie_id, it->_n, e_node);
+
+	return MIE_SUCCESS;
+}

mie/include/mie/attribute/attribute-definition.h

@@ -0,0 +1,33 @@
+#ifndef MIE_ATTRIBUTE_ATTRIBUTE_DEFINITION_H_
+#define MIE_ATTRIBUTE_ATTRIBUTE_DEFINITION_H_
+
+#include <mie/id.h>
+
+struct mie_dialect;
+struct mie_attribute;
+struct mie_parser;
+struct mie_printer;
+
+struct mie_attribute_definition {
+	mie_id a_id;
+	struct mie_dialect *a_parent;
+	char *a_name;
+
+	size_t a_data_size;
+
+	void (*a_init)(struct mie_attribute *);
+	void (*a_cleanup)(struct mie_attribute *);
+	enum mie_status (*a_print)(
+		const struct mie_attribute *, struct mie_printer *);
+	enum mie_status (*a_parse)(
+		struct mie_parser *, const struct mie_attribute **);
+};
+
+MIE_API struct mie_attribute_definition *mie_attribute_definition_create(
+	struct mie_dialect *parent, const char *name);
+
+MIE_API bool mie_attribute_definition_check_name(
+	const struct mie_attribute_definition *def, const char *dialect_name,
+	const char *attrib_name);
+
+#endif

mie/include/mie/attribute/attribute-map.h

@@ -0,0 +1,44 @@
+#ifndef MIE_ATTRIBUTE_ATTRIBUTE_MAP_H_
+#define MIE_ATTRIBUTE_ATTRIBUTE_MAP_H_
+
+#include <blue/core/btree.h>
+#include <mie/misc.h>
+#include <mie/status.h>
+
+struct b_queue_entry;
+
+struct mie_attribute_map {
+	b_btree m_entries;
+};
+
+enum mie_attribute_map_flags {
+	MIE_ATTRMAP_F_REPLACE = 0x01u,
+};
+
+struct mie_attribute_map_iterator {
+	const char *it_name;
+	const struct mie_attribute *it_value;
+	b_btree_node *_n;
+	struct b_queue_entry *_e;
+};
+
+MIE_API void mie_attribute_map_init(struct mie_attribute_map *map);
+MIE_API void mie_attribute_map_cleanup(struct mie_attribute_map *map);
+
+static inline bool mie_attribute_map_empty(const struct mie_attribute_map *map)
+{
+	return b_btree_empty(&map->m_entries);
+}
+
+MIE_API const struct mie_attribute *mie_attribute_map_get(
+	const struct mie_attribute_map *map, const char *name);
+MIE_API enum mie_status mie_attribute_map_put(
+	struct mie_attribute_map *map, const char *name,
+	const struct mie_attribute *value, enum mie_attribute_map_flags flags);
+
+MIE_API enum mie_status mie_attribute_map_iterator_begin(
+	struct mie_attribute_map_iterator *it, const struct mie_attribute_map *map);
+MIE_API enum mie_status mie_attribute_map_iterator_move_next(
+	struct mie_attribute_map_iterator *it);
+
+#endif

mie/include/mie/attribute/attribute.h

@@ -0,0 +1,17 @@
+#ifndef MIE_ATTRIBUTE_ATTRIBUTE_H_
+#define MIE_ATTRIBUTE_ATTRIBUTE_H_
+
+#include <mie/misc.h>
+#include <stdbool.h>
+
+struct mie_attribute_definition;
+
+struct mie_attribute {
+	const struct mie_attribute_definition *a_def;
+};
+
+MIE_API bool mie_attribute_check_name(
+	const struct mie_attribute *attrib, const char *dialect_name,
+	const char *attrib_name);
+
+#endif

mie/include/mie/ctx.h

@@ -3,30 +3,85 @@
 
 #include <blue/core/btree.h>
 #include <blue/ds/hashmap.h>
-#include <mie/type.h>
+#include <mie/id.h>
+
+struct mie_op;
+struct mie_pass;
+struct mie_diag;
+struct mie_file_cell;
+struct mie_int_cache;
+struct mie_line_source;
+struct mie_index_cache;
+struct mie_string_cache;
+struct mie_attribute_map;
+struct mie_pass_definition;
 
 struct mie_ctx {
+#if 0
 	struct mie_const *ctx_true, *ctx_false;
 	struct mie_value *ctx_null;
 	struct mie_type *ctx_types[__MIE_TYPE_COUNT];
-	b_btree ctx_int_cache;
 	b_hashmap *ctx_sel_cache;
 	b_hashmap *ctx_string_cache;
+#endif
+	/* map of struct mie_dialect */
+	struct mie_id_map ctx_dialects;
+	/* map of struct mie_type */
+	struct mie_id_map ctx_types;
+	/* map of struct mie_trait */
+	struct mie_id_map ctx_traits;
+	/* map of struct mie_attribute */
+	struct mie_id_map ctx_attributes;
+	/* map of struct mie_pass_definition */
+	struct mie_id_map ctx_passes;
+	/* queue of struct mie_diag */
+	b_queue ctx_diag;
 };
 
-extern struct mie_ctx *mie_ctx_create(void);
-extern void mie_ctx_destroy(struct mie_ctx *ctx);
+MIE_API struct mie_ctx *mie_ctx_create(void);
+MIE_API void mie_ctx_destroy(struct mie_ctx *ctx);
 
-extern struct mie_type *mie_ctx_get_type(
-	struct mie_ctx *ctx, enum mie_type_id type_id);
-extern struct mie_type *mie_ctx_get_int_type(
-	struct mie_ctx *ctx, unsigned int nr_bits);
-extern struct mie_value *mie_ctx_get_null(struct mie_ctx *ctx);
-extern struct mie_value *mie_ctx_get_bool(struct mie_ctx *ctx, bool val);
-extern struct mie_value *mie_ctx_get_int(
-	struct mie_ctx *ctx, long long val, unsigned int nr_bits);
-extern struct mie_value *mie_ctx_get_string(struct mie_ctx *ctx, const char *s);
-extern struct mie_value *mie_ctx_get_selector(struct mie_ctx *ctx, const char *sel);
-extern struct mie_value *mie_ctx_create_array(struct mie_ctx *ctx);
+MIE_API struct mie_op *mie_ctx_create_op(
+	const struct mie_ctx *ctx, const char *dialect, const char *op);
+
+MIE_API struct mie_dialect *mie_ctx_get_dialect(
+	const struct mie_ctx *ctx, const char *name);
+MIE_API struct mie_type_definition *mie_ctx_get_type_definition(
+	const struct mie_ctx *ctx, const char *dialect_name, const char *type_name);
+MIE_API const struct mie_op_definition *mie_ctx_get_op_definition(
+	const struct mie_ctx *ctx, const char *dialect_name, const char *op_name);
+MIE_API const struct mie_trait_definition *mie_ctx_get_trait_definition(
+	const struct mie_ctx *ctx, const char *dialect_name,
+	const char *trait_name);
+MIE_API const struct mie_attribute_definition *mie_ctx_get_attribute_definition(
+	const struct mie_ctx *ctx, const char *dialect_name,
+	const char *attrib_name);
+MIE_API const struct mie_interface_definition *mie_ctx_get_interface_definition(
+	const struct mie_ctx *ctx, const char *dialect_name,
+	const char *iface_name);
+MIE_API struct mie_type *mie_ctx_get_type(
+	struct mie_ctx *ctx, const char *dialect_name, const char *type_name);
+MIE_API const struct mie_trait *mie_ctx_get_trait(
+	struct mie_ctx *ctx, const char *dialect_name, const char *trait_name);
+MIE_API struct mie_type *mie_ctx_get_storage_type(
+	struct mie_ctx *ctx, const struct mie_type **parts, size_t nr_parts);
+MIE_API struct mie_type *mie_ctx_get_function_type(
+	struct mie_ctx *ctx, const struct mie_type **in, size_t nr_in,
+	const struct mie_type **out, size_t nr_out);
+
+MIE_API struct mie_value *mie_ctx_get_null(struct mie_ctx *ctx);
+
+MIE_API enum mie_status mie_ctx_register_pass(
+	struct mie_ctx *ctx, struct mie_pass_definition *pass);
+MIE_API enum mie_status mie_ctx_get_pass(
+	struct mie_ctx *ctx, const char *name,
+	const struct mie_attribute_map *args, struct mie_pass **out);
+
+MIE_API struct mie_diag *mie_ctx_push_diag(
+	struct mie_ctx *ctx, struct mie_line_source *src,
+	const struct mie_file_cell *loc, const char *dialect,
+	unsigned long diag_class);
+
+MIE_API struct mie_diag *mie_ctx_pop_diag(struct mie_ctx *ctx);
 
 #endif

mie/include/mie/diag/amendment.h

@@ -0,0 +1,36 @@
+#ifndef MIE_DIAG_AMENDMENT_H_
+#define MIE_DIAG_AMENDMENT_H_
+
+#include <mie/parse/file-span.h>
+
+enum mie_diag_amendment_type {
+	MIE_DIAG_AMENDMENT_NONE = 0,
+	MIE_DIAG_AMENDMENT_ADD,
+	MIE_DIAG_AMENDMENT_REMOVE,
+	MIE_DIAG_AMENDMENT_REPLACE,
+};
+
+struct mie_diag_amendment {
+	enum mie_diag_amendment_type a_type;
+	unsigned long __x;
+
+	union {
+		struct {
+			struct mie_file_cell a_loc;
+			char *a_str;
+		} a_add;
+
+		struct {
+			struct mie_file_cell a_loc;
+			unsigned long a_length;
+		} a_remove;
+
+		struct {
+			struct mie_file_cell a_loc;
+			unsigned long a_length;
+			char *a_str;
+		} a_replace;
+	};
+};
+
+#endif

mie/include/mie/diag/class.h

@@ -0,0 +1,18 @@
+#ifndef MIE_DIAG_CLASS_H_
+#define MIE_DIAG_CLASS_H_
+
+enum mie_diag_class_type {
+	MIE_DIAG_CLASS_NONE = 0,
+	MIE_DIAG_CLASS_HINT,
+	MIE_DIAG_CLASS_WARNING,
+	MIE_DIAG_CLASS_ERROR,
+};
+
+struct mie_diag_class {
+	unsigned int c_id;
+	const char *c_id_str_short, *c_id_str_long;
+	enum mie_diag_class_type c_type;
+	const char *c_title;
+};
+
+#endif

mie/include/mie/diag/component.h

@@ -0,0 +1,34 @@
+#ifndef MIE_DIAG_COMPONENT_H_
+#define MIE_DIAG_COMPONENT_H_
+
+#include <blue/core/queue.h>
+#include <stddef.h>
+
+enum mie_diag_component_type {
+	MIE_DIAG_COMPONENT_NONE = 0,
+	MIE_DIAG_COMPONENT_MSG,
+	MIE_DIAG_COMPONENT_SNIPPET,
+};
+
+struct mie_diag_component {
+	enum mie_diag_component_type c_type;
+	b_queue_entry c_entry;
+};
+
+struct mie_diag_c_snippet {
+	struct mie_diag_component s_base;
+	unsigned long s_first_line, s_last_line;
+
+	struct mie_diag_amendment *s_amendments;
+	size_t s_nr_amendments;
+
+	struct mie_diag_highlight *s_highlights;
+	size_t s_nr_highlights;
+};
+
+struct mie_diag_c_msg {
+	struct mie_diag_component msg_base;
+	char *msg_content;
+};
+
+#endif

mie/include/mie/diag/diag.h

@@ -0,0 +1,39 @@
+#ifndef MIE_DIAG_DIAG_H_
+#define MIE_DIAG_DIAG_H_
+
+#include <blue/core/queue.h>
+#include <mie/parse/file-span.h>
+
+struct mie_ctx;
+struct mie_diag_class;
+struct mie_diag_amendment;
+struct mie_diag_highlight;
+
+enum mie_diag_type {
+	MIE_DIAG_NONE = 0,
+	MIE_DIAG_HINT,
+	MIE_DIAG_WARNING,
+	MIE_DIAG_ERROR,
+};
+
+struct mie_diag {
+	struct mie_dialect *diag_parent;
+	const struct mie_diag_class *diag_class;
+
+	struct mie_line_source *diag_src;
+	struct mie_file_cell diag_loc;
+	b_queue_entry diag_entry;
+	b_queue diag_components;
+};
+
+MIE_API void mie_diag_set_location(
+	struct mie_diag *diag, unsigned long row, unsigned long col);
+MIE_API void mie_diag_push_msg(
+	struct mie_diag *diag, struct mie_ctx *ctx, const char *dialect,
+	unsigned long msg, ...);
+MIE_API void mie_diag_push_snippet(
+	struct mie_diag *diag, unsigned long first_line, unsigned long last_line,
+	const struct mie_diag_amendment *amendmends, size_t nr_amendments,
+	const struct mie_diag_highlight *highlights, size_t nr_highlights);
+
+#endif

mie/include/mie/diag/highlight.h

@@ -0,0 +1,18 @@
+#ifndef MIE_DIAG_HIGHLIGHT_H_
+#define MIE_DIAG_HIGHLIGHT_H_
+
+#include <mie/parse/file-span.h>
+
+enum mie_diag_highlight_type {
+	MIE_DIAG_HIGHLIGHT_NONE = 0,
+	MIE_DIAG_HIGHLIGHT_HINT,
+	MIE_DIAG_HIGHLIGHT_WARNING,
+	MIE_DIAG_HIGHLIGHT_ERROR,
+};
+
+struct mie_diag_highlight {
+	enum mie_diag_highlight_type hl_type;
+	struct mie_file_span hl_span;
+};
+
+#endif

mie/include/mie/diag/msg.h

@@ -0,0 +1,10 @@
+#ifndef MIE_DIAG_MSG_H_
+#define MIE_DIAG_MSG_H_
+
+struct mie_diag_msg {
+	unsigned int msg_id;
+	const char *msg_id_str_short, *msg_id_str_long;
+	const char *msg_content;
+};
+
+#endif

mie/include/mie/dialect/arith.h

@@ -0,0 +1,26 @@
+#ifndef MIE_DIALECT_ARITH_H_
+#define MIE_DIALECT_ARITH_H_
+
+#include <mie/attribute/attribute.h>
+#include <mie/misc.h>
+#include <stddef.h>
+#include <stdint.h>
+
+struct mie_ctx;
+struct mie_dialect;
+struct mie_emitter;
+
+MIE_API struct mie_dialect *mie_arith_dialect_create(struct mie_ctx *ctx);
+
+MIE_API struct mie_register *mie_arith_constant_i_put(
+	struct mie_emitter *e, long long value, const char *name);
+MIE_API struct mie_register *mie_arith_constant_f_put(
+	struct mie_emitter *e, long long value, const char *name);
+MIE_API struct mie_register *mie_arith_addi_put(
+	struct mie_emitter *e, struct mie_register *left,
+	struct mie_register *right, const char *name);
+MIE_API struct mie_register *mie_arith_addf_put(
+	struct mie_emitter *e, struct mie_register *left,
+	struct mie_register *right, const char *name);
+
+#endif

mie/include/mie/dialect/builtin.h

@@ -0,0 +1,146 @@
+#ifndef MIE_DIALECT_BUILTIN_H_
+#define MIE_DIALECT_BUILTIN_H_
+
+#include <blue/ds/string.h>
+#include <mie/attribute/attribute.h>
+#include <mie/interface/interface.h>
+#include <mie/misc.h>
+#include <mie/trait/trait.h>
+#include <mie/vector.h>
+
+struct mie_dialect;
+
+struct mie_ctx;
+struct mie_op;
+struct mie_int_type;
+struct mie_float_type;
+
+enum mie_builtin_diag {
+	MIE_BUILTIN_E_UNRECOGNISED_TOKEN,
+	MIE_BUILTIN_E_UNRESOLVED_VALUE,
+	MIE_BUILTIN_E_UNRESOLVED_SUCCESSOR,
+};
+
+enum mie_builtin_msg {
+	MIE_BUILTIN_MSG_UNRECOGNISED_TOKEN,
+	MIE_BUILTIN_MSG_UNRESOLVED_VALUE,
+	MIE_BUILTIN_MSG_CANNOT_FIND_BLOCK,
+	MIE_BUILTIN_MSG_VALUE_DEFINED_IN_NON_DOMINANT_BLOCK,
+	MIE_BUILTIN_MSG_VALUE_DEFINED_AFTER_USE,
+	MIE_BUILTIN_MSG_VALUE_DEFINED_OUTSIDE_ISOLATED_REGION,
+	MIE_BUILTIN_MSG_VALUE_DEFINED_IN_BLOCK,
+};
+
+enum mie_float_width {
+	MIE_FLOAT_32 = 32,
+	MIE_FLOAT_64 = 64,
+};
+
+struct mie_string {
+	struct mie_attribute str_base;
+	char *str_val;
+	size_t str_len;
+};
+
+struct mie_int {
+	struct mie_attribute i_base;
+	const struct mie_type *i_type;
+
+	union {
+		int64_t v_small;
+
+		struct {
+			long *a_parts;
+			size_t a_nr_parts;
+		} v_arbitrary;
+	} i_val;
+};
+
+struct mie_float {
+	struct mie_attribute f_base;
+	const struct mie_type *f_type;
+
+	union {
+		float v_32;
+		double v_64;
+	} f_val;
+};
+
+struct mie_index {
+	struct mie_attribute i_base;
+	size_t i_value;
+};
+
+struct mie_array {
+	struct mie_attribute a_base;
+	MIE_VECTOR_DECLARE(const struct mie_attribute *, a_items);
+};
+
+struct mie_type_attr {
+	struct mie_attribute ty_base;
+	const struct mie_type *ty_value;
+};
+
+struct mie_symbol {
+	struct mie_interface sym_base;
+	const char *(*sym_get_name)(const struct mie_op *);
+};
+
+struct mie_symbol_table {
+	struct mie_trait tab_base;
+};
+
+struct mie_int_cache;
+struct mie_float_cache;
+struct mie_string_cache;
+struct mie_index_cache;
+
+MIE_API struct mie_dialect *mie_builtin_dialect_create(struct mie_ctx *ctx);
+
+MIE_API struct mie_string_cache *mie_string_cache_create(void);
+MIE_API void mie_string_cache_destroy(struct mie_string_cache *cache);
+MIE_API struct mie_string *mie_string_cache_get(
+	struct mie_string_cache *cache, struct mie_ctx *ctx, const char *val);
+
+MIE_API struct mie_int_cache *mie_int_cache_create(void);
+MIE_API void mie_int_cache_destroy(struct mie_int_cache *cache);
+MIE_API struct mie_int *mie_int_cache_get(
+	struct mie_int_cache *cache, struct mie_ctx *ctx, size_t value,
+	size_t bit_width);
+
+MIE_API struct mie_float_cache *mie_float_cache_create(void);
+MIE_API void mie_float_cache_destroy(struct mie_float_cache *cache);
+MIE_API struct mie_float *mie_float_cache_get(
+	struct mie_float_cache *cache, struct mie_ctx *ctx, double value,
+	size_t bit_width);
+
+MIE_API struct mie_index_cache *mie_index_cache_create(void);
+MIE_API void mie_index_cache_destroy(struct mie_index_cache *cache);
+MIE_API struct mie_index *mie_index_cache_get(
+	struct mie_index_cache *cache, struct mie_ctx *ctx, size_t value);
+
+MIE_API struct mie_attribute *mie_ctx_get_int(
+	struct mie_ctx *ctx, long long val, size_t nr_bits);
+MIE_API struct mie_attribute *mie_ctx_get_float(
+	struct mie_ctx *ctx, double val, size_t nr_bits);
+MIE_API struct mie_attribute *mie_ctx_get_string(
+	struct mie_ctx *ctx, const char *s);
+MIE_API struct mie_attribute *mie_ctx_get_index(struct mie_ctx *ctx, size_t val);
+
+MIE_API const char *mie_string_get_cstr(const struct mie_attribute *attrib);
+MIE_API const struct mie_type *mie_type_attr_get_type(
+	const struct mie_attribute *attrib);
+MIE_API bool mie_int_get_value(const struct mie_attribute *attrib, long long *out);
+MIE_API bool mie_float_get_value(const struct mie_attribute *attrib, double *out);
+
+MIE_API struct mie_type *mie_ctx_get_int_type(struct mie_ctx *ctx, size_t bit_width);
+MIE_API struct mie_type *mie_ctx_get_float_type(
+	struct mie_ctx *ctx, size_t bit_width);
+
+MIE_API struct mie_attribute *mie_type_attr_create(
+	struct mie_ctx *ctx, const struct mie_type *ty);
+
+MIE_API size_t mie_int_type_get_width(const struct mie_type *type);
+MIE_API size_t mie_float_type_get_width(const struct mie_type *type);
+
+#endif

mie/include/mie/dialect/cf.h

@@ -0,0 +1,24 @@
+#ifndef MIE_DIALECT_CF_H_
+#define MIE_DIALECT_CF_H_
+
+#include <mie/misc.h>
+#include <stddef.h>
+
+struct mie_ctx;
+struct mie_block;
+struct mie_dialect;
+struct mie_emitter;
+struct mie_register;
+
+MIE_API struct mie_dialect *mie_cf_dialect_create(struct mie_ctx *ctx);
+
+MIE_API struct mie_op *mie_cf_br_put(
+	struct mie_emitter *e, struct mie_block *dest,
+	struct mie_register **dest_args, size_t nr_dest_args);
+MIE_API struct mie_op *mie_cf_br_cond_put(
+	struct mie_emitter *e, struct mie_register *cond,
+	struct mie_block *true_block, struct mie_register **true_args,
+	size_t nr_true_args, struct mie_block *false_block,
+	struct mie_register **false_args, size_t nr_false_args);
+
+#endif

mie/include/mie/dialect/dialect.h

@@ -0,0 +1,57 @@
+#ifndef MIE_DIALECT_DIALECT_H_
+#define MIE_DIALECT_DIALECT_H_
+
+#include <blue/core/btree.h>
+#include <blue/core/queue.h>
+#include <mie/id.h>
+#include <mie/misc.h>
+#include <mie/vector.h>
+
+struct mie_ctx;
+
+struct mie_op_definition;
+struct mie_type_definition;
+struct mie_trait_definition;
+
+struct mie_diag_class;
+struct mie_diag_msg;
+
+struct mie_dialect {
+	mie_id d_id;
+	char *d_name;
+
+	/* map of struct mie_op_definition */
+	struct mie_id_map d_ops;
+	/* map of struct mie_type_definition */
+	struct mie_id_map d_types;
+	/* map of struct mie_trait_definition */
+	struct mie_id_map d_traits;
+	/* map of struct mie_attribute_definition */
+	struct mie_id_map d_attributes;
+	/* map of struct mie_interface_definition */
+	struct mie_id_map d_interfaces;
+	/* array of mie_diag_class */
+	struct mie_diag_class *d_diag_classes;
+	size_t d_nr_diag_classes;
+	/* array of mie_diag_msg */
+	struct mie_diag_msg *d_diag_msgs;
+	size_t d_nr_diag_msgs;
+
+	enum mie_status (*d_cleanup)(struct mie_dialect *);
+};
+
+MIE_API struct mie_dialect *mie_dialect_create(
+	struct mie_ctx *ctx, const char *name, size_t size);
+
+MIE_API const struct mie_op_definition *mie_dialect_get_op(
+	const struct mie_dialect *dialect, const char *name);
+MIE_API const struct mie_type_definition *mie_dialect_get_type(
+	const struct mie_dialect *dialect, const char *name);
+MIE_API const struct mie_trait_definition *mie_dialect_get_trait(
+	const struct mie_dialect *dialect, const char *name);
+MIE_API const struct mie_attribute_definition *mie_dialect_get_attribute(
+	const struct mie_dialect *dialect, const char *name);
+MIE_API const struct mie_interface_definition *mie_dialect_get_interface(
+	const struct mie_dialect *dialect, const char *name);
+
+#endif

mie/include/mie/dialect/func.h

@@ -0,0 +1,25 @@
+#ifndef MIE_DIALECT_FUNC_H_
+#define MIE_DIALECT_FUNC_H_
+
+#include <mie/misc.h>
+#include <stddef.h>
+
+struct mie_ctx;
+struct mie_type;
+struct mie_dialect;
+struct mie_emitter;
+struct mie_register;
+
+struct mie_func_parameter {
+	const char *param_name;
+	const struct mie_type *param_type;
+	struct mie_register *param_reg;
+};
+
+MIE_API struct mie_dialect *mie_func_dialect_create(struct mie_ctx *ctx);
+
+MIE_API struct mie_op *mie_func_func_put(
+	struct mie_emitter *e, const char *name, struct mie_func_parameter *params,
+	size_t nr_params, const struct mie_type **ret_types, size_t nr_ret_types);
+
+#endif

mie/include/mie/dialect/index.h

@@ -0,0 +1,14 @@
+#ifndef MIE_DIALECT_INDEX_H_
+#define MIE_DIALECT_INDEX_H_
+
+#include <mie/attribute/attribute.h>
+#include <mie/misc.h>
+#include <stddef.h>
+#include <stdint.h>
+
+struct mie_ctx;
+struct mie_dialect;
+
+MIE_API struct mie_dialect *mie_index_dialect_create(struct mie_ctx *ctx);
+
+#endif

mie/include/mie/dialect/memref.h

@@ -0,0 +1,13 @@
+#ifndef MIE_DIALECT_MEMREF_H_
+#define MIE_DIALECT_MEMREF_H_
+
+#include <mie/misc.h>
+#include <stddef.h>
+#include <stdint.h>
+
+struct mie_ctx;
+struct mie_dialect;
+
+MIE_API struct mie_dialect *mie_memref_dialect_create(struct mie_ctx *ctx);
+
+#endif