meta: replace bluelib references with fx

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.

CMakeLists.txt

@@ -24,10 +24,10 @@ if (NOT MIE_STATIC)
 endif ()
 
 if (MIE_STATIC)
-	set(Bluelib_STATIC TRUE)
+	set(FX_STATIC TRUE)
 endif ()
 
-find_package(Bluelib REQUIRED)
+find_package(FX REQUIRED)
 
 add_subdirectory(mie)
 add_subdirectory(tool)

cmake/FindBluelib.cmake

@@ -1,189 +0,0 @@
-#[=======================================================================[.rst:
-FindBluelib
-------------
-
-Find the Bluelib library and header directories
-
-Imported Targets
-^^^^^^^^^^^^^^^^
-
-This module defines the following :prop_tgt:`IMPORTED` target:
-
-``Bluelib::Bluelib``
-The Bluelib library, if found
-
-Result Variables
-^^^^^^^^^^^^^^^^
-
-This module will set the following variables in your project:
-
-``Bluelib_FOUND``
-true if the Bluelib C headers and libraries were found
-``Bluelib_INCLUDE_DIR``
-directories containing the Bluelib C headers.
-
-``Bluelib_LIBRARY``
-the C library to link against
-
-Hints
-^^^^^
-
-The user may set the environment variable ``Bluelib_PREFIX`` to the root
-directory of a Bluelib library installation.
-#]=======================================================================]
-
-set (Bluelib_SEARCH_PATHS
-	~/Library/Frameworks
-	/Library/Frameworks
-	/usr/local
-	/usr/local/share
-	/usr
-	/sw # Fink
-	/opt/local # DarwinPorts
-	/opt/csw # Blastwave
-	/opt
-	${Bluelib_PREFIX}
-	$ENV{Bluelib_PREFIX})
-
-if (Bluelib_STATIC)
-	set(_lib_suffix "-s")
-endif ()
-
-set(supported_components Core Ds Term Cmd Io Serial Compress)
-set(components ${Bluelib_FIND_COMPONENTS})
-string(REPLACE ";" ", " supported_components_string_list "${supported_components}")
-
-if (NOT components)
-	set(components ${supported_components})
-endif ()
-
-set(required_vars)
-
-foreach (component ${components})
-	if (NOT "${component}" IN_LIST supported_components)
-		message(FATAL_ERROR "'${component}' is not a valid Bluelib module.\nSupported modules: ${supported_components_string_list}")
-	endif ()
-
-	string(TOLOWER ${component} header_name)
-	set(lib_name ${header_name}${_lib_suffix})
-
-	if (NOT Bluelib_${component}_INCLUDE_DIR)
-		find_path(Bluelib_${component}_INCLUDE_DIR
-			NAMES blue/${header_name}.h ${Bluelib_FIND_ARGS}
-			PATH_SUFFIXES include
-			PATHS ${Bluelib_SEARCH_PATHS})
-	endif ()
-
-	if (NOT Bluelib_${component}_LIBRARY)
-		find_library(Bluelib_${component}_LIBRARY
-			NAMES blue-${lib_name} ${Bluelib_FIND_ARGS}
-			PATH_SUFFIXES lib
-			PATHS ${Bluelib_SEARCH_PATHS})
-	else ()
-		# on Windows, ensure paths are in canonical format (forward slahes):
-		file(TO_CMAKE_PATH "${Bluelib_${component}_LIBRARY}" Bluelib_${component}_LIBRARY)
-	endif()
-
-	list(APPEND required_vars Bluelib_${component}_INCLUDE_DIR Bluelib_${component}_LIBRARY)
-endforeach (component)
-
-unset(Bluelib_FIND_ARGS)
-
-include(FindPackageHandleStandardArgs)
-
-find_package_handle_standard_args(Bluelib
-	REQUIRED_VARS ${required_vars})
-
-if (Bluelib_FOUND)
-	set(created_targets)
-	foreach (component ${components})
-		string(TOLOWER ${component} header_name)
-		set(lib_name ${header_name}${_lib_suffix})
-
-		if(NOT TARGET Bluelib::${component})
-			add_library(Bluelib::${component} UNKNOWN IMPORTED)
-			set_target_properties(Bluelib::${component} PROPERTIES
-				INTERFACE_INCLUDE_DIRECTORIES "${Bluelib_${component}_INCLUDE_DIR}")
-			target_compile_definitions(Bluelib::${component} INTERFACE _CRT_SECURE_NO_WARNINGS=1)
-
-			if (Bluelib_STATIC)
-				target_compile_definitions(Bluelib::${component} INTERFACE BLUELIB_STATIC=1)
-			endif ()
-
-			set_target_properties(Bluelib::${component} PROPERTIES
-				IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-				IMPORTED_LOCATION "${Bluelib_${component}_LIBRARY}")
-			set(created_targets ${created_targets} ${component})
-		endif ()
-	endforeach (component)
-
-	foreach (component ${created_targets})
-		if ("${component}" STREQUAL "Ds")
-			if (NOT TARGET Bluelib::Core)
-				message(FATAL_ERROR "Bluelib: Module 'Ds' depends on 'Core', which was not specified in find_package()")
-			endif ()
-
-			target_link_libraries(Bluelib::Ds INTERFACE Bluelib::Core)
-		endif ()
-
-		if ("${component}" STREQUAL "Term")
-			if (NOT TARGET Bluelib::Core)
-				message(FATAL_ERROR "Bluelib: Module 'Term' depends on 'Core', which was not specified in find_package()")
-			endif ()
-
-			if (NOT TARGET Bluelib::Ds)
-				message(FATAL_ERROR "Bluelib: Module 'Term' depends on 'Ds', which was not specified in find_package()")
-			endif ()
-
-			target_link_libraries(Bluelib::Term INTERFACE Bluelib::Core Bluelib::Ds)
-		endif ()
-
-		if ("${component}" STREQUAL "Serial")
-			if (NOT TARGET Bluelib::Core)
-				message(FATAL_ERROR "Bluelib: Module 'Serial' depends on 'Core', which was not specified in find_package()")
-			endif ()
-
-			if (NOT TARGET Bluelib::Ds)
-				message(FATAL_ERROR "Bluelib: Module 'Serial' depends on 'Ds', which was not specified in find_package()")
-			endif ()
-
-			target_link_libraries(Bluelib::Serial INTERFACE Bluelib::Core Bluelib::Ds)
-		endif ()
-
-		if ("${component}" STREQUAL "Cmd")
-			if (NOT TARGET Bluelib::Core)
-				message(FATAL_ERROR "Bluelib: Module 'Cmd' depends on 'Core', which was not specified in find_package()")
-			endif ()
-
-			if (NOT TARGET Bluelib::Ds)
-				message(FATAL_ERROR "Bluelib: Module 'Cmd' depends on 'Ds', which was not specified in find_package()")
-			endif ()
-
-			if (NOT TARGET Bluelib::Term)
-				message(FATAL_ERROR "Bluelib: Module 'Cmd' depends on 'Term', which was not specified in find_package()")
-			endif ()
-
-			target_link_libraries(Bluelib::Cmd INTERFACE Bluelib::Core Bluelib::Ds Bluelib::Term)
-		endif ()
-
-		if ("${component}" STREQUAL "Io")
-			if (NOT TARGET Bluelib::Core)
-				message(FATAL_ERROR "Bluelib: Module 'Io' depends on 'Core', which was not specified in find_package()")
-			endif ()
-
-			if (NOT TARGET Bluelib::Ds)
-				message(FATAL_ERROR "Bluelib: Module 'Io' depends on 'Ds', which was not specified in find_package()")
-			endif ()
-
-			target_link_libraries(Bluelib::Io INTERFACE Bluelib::Core Bluelib::Ds)
-		endif ()
-
-		if ("${component}" STREQUAL "Compress")
-			if (NOT TARGET Bluelib::Core)
-				message(FATAL_ERROR "Bluelib: Module 'Compress' depends on 'Core', which was not specified in find_package()")
-			endif ()
-
-			target_link_libraries(Bluelib::Compress INTERFACE Bluelib::Core Bluelib::Ds)
-		endif ()
-	endforeach (component)
-endif()

cmake/FindFX.cmake

@@ -0,0 +1,189 @@
+#[=======================================================================[.rst:
+FindFX
+------------
+
+Find the FX library and header directories
+
+Imported Targets
+^^^^^^^^^^^^^^^^
+
+This module defines the following :prop_tgt:`IMPORTED` target:
+
+``FX::FX``
+The FX library, if found
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This module will set the following variables in your project:
+
+``FX_FOUND``
+true if the FX C headers and libraries were found
+``FX_INCLUDE_DIR``
+directories containing the FX C headers.
+
+``FX_LIBRARY``
+the C library to link against
+
+Hints
+^^^^^
+
+The user may set the environment variable ``FX_PREFIX`` to the root
+directory of a FX library installation.
+#]=======================================================================]
+
+set (FX_SEARCH_PATHS
+	~/Library/Frameworks
+	/Library/Frameworks
+	/usr/local
+	/usr/local/share
+	/usr
+	/sw # Fink
+	/opt/local # DarwinPorts
+	/opt/csw # Blastwave
+	/opt
+	${FX_PREFIX}
+	$ENV{FX_PREFIX})
+
+if (FX_STATIC)
+	set(_lib_suffix "-s")
+endif ()
+
+set(supported_components Core Ds Term Cmd Io Serial Compress)
+set(components ${FX_FIND_COMPONENTS})
+string(REPLACE ";" ", " supported_components_string_list "${supported_components}")
+
+if (NOT components)
+	set(components ${supported_components})
+endif ()
+
+set(required_vars)
+
+foreach (component ${components})
+	if (NOT "${component}" IN_LIST supported_components)
+		message(FATAL_ERROR "'${component}' is not a valid FX module.\nSupported modules: ${supported_components_string_list}")
+	endif ()
+
+	string(TOLOWER ${component} header_name)
+	set(lib_name ${header_name}${_lib_suffix})
+
+	if (NOT FX_${component}_INCLUDE_DIR)
+		find_path(FX_${component}_INCLUDE_DIR
+			NAMES fx/${header_name}.h ${FX_FIND_ARGS}
+			PATH_SUFFIXES include
+			PATHS ${FX_SEARCH_PATHS})
+	endif ()
+
+	if (NOT FX_${component}_LIBRARY)
+		find_library(FX_${component}_LIBRARY
+			NAMES fx-${lib_name} ${FX_FIND_ARGS}
+			PATH_SUFFIXES lib
+			PATHS ${FX_SEARCH_PATHS})
+	else ()
+		# on Windows, ensure paths are in canonical format (forward slahes):
+		file(TO_CMAKE_PATH "${FX_${component}_LIBRARY}" FX_${component}_LIBRARY)
+	endif()
+
+	list(APPEND required_vars FX_${component}_INCLUDE_DIR FX_${component}_LIBRARY)
+endforeach (component)
+
+unset(FX_FIND_ARGS)
+
+include(FindPackageHandleStandardArgs)
+
+find_package_handle_standard_args(FX
+	REQUIRED_VARS ${required_vars})
+
+if (FX_FOUND)
+	set(created_targets)
+	foreach (component ${components})
+		string(TOLOWER ${component} header_name)
+		set(lib_name ${header_name}${_lib_suffix})
+
+		if(NOT TARGET FX::${component})
+			add_library(FX::${component} UNKNOWN IMPORTED)
+			set_target_properties(FX::${component} PROPERTIES
+				INTERFACE_INCLUDE_DIRECTORIES "${FX_${component}_INCLUDE_DIR}")
+			target_compile_definitions(FX::${component} INTERFACE _CRT_SECURE_NO_WARNINGS=1)
+
+			if (FX_STATIC)
+				target_compile_definitions(FX::${component} INTERFACE FX_STATIC=1)
+			endif ()
+
+			set_target_properties(FX::${component} PROPERTIES
+				IMPORTED_LINK_INTERFACE_LANGUAGES "C"
+				IMPORTED_LOCATION "${FX_${component}_LIBRARY}")
+			set(created_targets ${created_targets} ${component})
+		endif ()
+	endforeach (component)
+
+	foreach (component ${created_targets})
+		if ("${component}" STREQUAL "Ds")
+			if (NOT TARGET FX::Core)
+				message(FATAL_ERROR "FX: Module 'Ds' depends on 'Core', which was not specified in find_package()")
+			endif ()
+
+			target_link_libraries(FX::Ds INTERFACE FX::Core)
+		endif ()
+
+		if ("${component}" STREQUAL "Term")
+			if (NOT TARGET FX::Core)
+				message(FATAL_ERROR "FX: Module 'Term' depends on 'Core', which was not specified in find_package()")
+			endif ()
+
+			if (NOT TARGET FX::Ds)
+				message(FATAL_ERROR "FX: Module 'Term' depends on 'Ds', which was not specified in find_package()")
+			endif ()
+
+			target_link_libraries(FX::Term INTERFACE FX::Core FX::Ds)
+		endif ()
+
+		if ("${component}" STREQUAL "Serial")
+			if (NOT TARGET FX::Core)
+				message(FATAL_ERROR "FX: Module 'Serial' depends on 'Core', which was not specified in find_package()")
+			endif ()
+
+			if (NOT TARGET FX::Ds)
+				message(FATAL_ERROR "FX: Module 'Serial' depends on 'Ds', which was not specified in find_package()")
+			endif ()
+
+			target_link_libraries(FX::Serial INTERFACE FX::Core FX::Ds)
+		endif ()
+
+		if ("${component}" STREQUAL "Cmd")
+			if (NOT TARGET FX::Core)
+				message(FATAL_ERROR "FX: Module 'Cmd' depends on 'Core', which was not specified in find_package()")
+			endif ()
+
+			if (NOT TARGET FX::Ds)
+				message(FATAL_ERROR "FX: Module 'Cmd' depends on 'Ds', which was not specified in find_package()")
+			endif ()
+
+			if (NOT TARGET FX::Term)
+				message(FATAL_ERROR "FX: Module 'Cmd' depends on 'Term', which was not specified in find_package()")
+			endif ()
+
+			target_link_libraries(FX::Cmd INTERFACE FX::Core FX::Ds FX::Term)
+		endif ()
+
+		if ("${component}" STREQUAL "Io")
+			if (NOT TARGET FX::Core)
+				message(FATAL_ERROR "FX: Module 'Io' depends on 'Core', which was not specified in find_package()")
+			endif ()
+
+			if (NOT TARGET FX::Ds)
+				message(FATAL_ERROR "FX: Module 'Io' depends on 'Ds', which was not specified in find_package()")
+			endif ()
+
+			target_link_libraries(FX::Io INTERFACE FX::Core FX::Ds)
+		endif ()
+
+		if ("${component}" STREQUAL "Compress")
+			if (NOT TARGET FX::Core)
+				message(FATAL_ERROR "FX: Module 'Compress' depends on 'Core', which was not specified in find_package()")
+			endif ()
+
+			target_link_libraries(FX::Compress INTERFACE FX::Core FX::Ds)
+		endif ()
+	endforeach (component)
+endif()

doc/sample/graph/1.mie

@@ -1,22 +1,22 @@
 select.graph {
-	%entry = +select.entry -> #select.chain
+	%entry = +select.entry -> !select.chain
 
-	%0 = +select.register @0 : i32 -> #select.register
+	%0 = +select.register @0 : i32 -> !select.register
-	%1 = +select.register @1 : i32 -> #select.register
+	%1 = +select.register @1 : i32 -> !select.register
 
 	%v.0, %c.0 = +select.register.read %entry, %0 \
-		: (#select.chain, #select.register) \
+		: (!select.chain, !select.register) \
-		-> (i32, #select.chain)
+		-> (i32, !select.chain)
 
 	%v.1, %c.1 = +select.register.read %entry, %1 \
-		: (#select.chain, #select.register) \
+		: (!select.chain, !select.register) \
-		-> (i32, #select.chain)
+		-> (i32, !select.chain)
 
 	%2 = +select.register @2 : i32
 
 	%v.2, %c.2 = +select.register.read %entry, %2 \
-		: (#select.chain, #select.register) \
+		: (!select.chain, !select.register) \
-		-> (#select.register, #select.chain)
+		-> (!select.register, !select.chain)
 
 	%v.3 = arith.build-pair %v.0, %v.1 : (i32, i32) -> i64
 
@@ -24,15 +24,15 @@ select.graph {
 
 	%v.5 = arith.mul %v.4, %v.3 : (i32, i32) -> i32
 
-	%x0 = +select.mach-register @x0 : i32 -> #select.register
+	%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.register, i32) \
-		-> (#select.chain, #select.glue)
+		-> (!select.chain, !select.glue)
 
 	%c.4 = *risc-v.RET %c.3, %x0, %g.0 \
-		: (#select.chain, #select.register, #select.glue) \
+		: (!select.chain, !select.register, !select.glue) \
-		-> #select.chain
+		-> !select.chain
 
-	+select.graph-root %c.4 : #select.chain
+	+select.graph-root %c.4 : !select.chain
 }

doc/sample/graph/2.mie

@@ -1,31 +1,31 @@
 select.graph {
-	%entry = +select.entry -> #select.chain
+	%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
+	%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
+	%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)
+	%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
+	%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
+	%N10.c = +select.chain-group %N7.c, %N6.c : (!select.chain, !select.chain) -> !select.chain
 
-	%N11 = +select.block-ref @if.true -> #select.block
+	%N11 = +select.block-ref @if.true -> !select.block
 
-	%N12.c = +cf.br-cond %N10.c, %N9, %N11 : (#select.chain, i1, #select.block) -> #select.chain
+	%N12.c = +cf.br-cond %N10.c, %N9, %N11 : (!select.chain, i1, !select.block) -> !select.chain
 
-	%N13 = +select.block-ref @if.false -> #select.block
+	%N13 = +select.block-ref @if.false -> !select.block
 
 	%N14.c = cf.br %N12.c, %N13
 

doc/sample/ir/dominance-test.mie

@@ -0,0 +1,30 @@
+~func.func() ({
+^R:
+	%0 = ~arith.constant() {value = 0 : i32} : () -> i32
+	~cf.br-cond(%0) [ ^A, ^B, ^C ] : (i32) -> ()
+
+^A:
+	~cf.br() [ ^D ] : () -> ()
+^B:
+	~cf.br-cond(%0) [ ^D, ^A, ^E ] : (i32) -> ()
+^C:
+	~cf.br-cond(%0) [ ^G, ^F ] : (i32) -> ()
+^D:
+	~cf.br() [ ^L ] : () -> ()
+^E:
+	~cf.br() [ ^H ] : () -> ()
+^F:
+	~cf.br() [ ^I ] : () -> ()
+^G:
+	~cf.br-cond(%0) [ ^I, ^J ] : (i32) -> ()
+^H:
+	~cf.br-cond(%0) [ ^E, ^K ] : (i32) -> ()
+^I:
+	~cf.br() [ ^K ] : () -> ()
+^J:
+	~cf.br() [ ^I ] : () -> ()
+^K:
+	~cf.br-cond(%0) [ ^R, ^I ] : (i32) -> ()
+^L:
+	~cf.br() [ ^H ] : () -> ()
+}) {sym_name = "test", function_type = () -> () } : () -> ()

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

@@ -1,9 +1,10 @@
 ; Comment
+module {
 	func.func @reduce(%buffer: memref<1024*f32>, %lb: index, %ub: index, %step: index) -> f32 {
 		; Initial sum set to 0.
-	%sum.0 = f32.constant 0.0
+		%sum.0 = arith.constant 0.0 : 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) {
+		%sum = scf.for %iv = %lb to %ub step %step iter-args(%sum.iter = %sum.0) -> f32 {
 			%t = memref.load %buffer[%iv] : memref<1024*f32>
 			%sum.next = arith.addf %sum.iter, %t : f32
 			; Yield current iteration sum to next iteration %sum.iter or to %sum
@@ -13,3 +14,4 @@ func.func @reduce(%buffer: memref<1024*f32>, %lb: index, %ub: index, %step: inde
 
 		func.return %sum : f32
 	}
+}

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

@@ -1,25 +1,16 @@
-~func.func() ({
+module {
-^entry(%buffer: memref<1024*f32>, %lb: index, %ub: index, %step: index):
+        func.func @_reduce(%buffer: memref<1024*f32>, %lb: index, %ub: index, %step: index) -> f32 {
-	; Initial sum set to 0.
+                %sum.0 = arith.constant 0 : f32
-	%sum.0 = ~f32.constant() {value = 0.0 : f32} : () -> f32
+                cf.br ^for.entry(%lb: index, %sum.0: 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
+                %t = memref.load %buffer[%iv] : memref<1024*f32>
-	%sum.next = ~arith.addf(%sum.iter, %t) : (f32, f32) -> f32
+                %sum.next = arith.addf %sum.iter, %t : f32
-
+                cf.br ^for.cond(%iv: index, %sum.next: f32)
-	~cf.br [ ^for.cond:(%iv: index, %sum.next: f32) ] : () -> ()
+        ^for.cond(%iv.0: index, %sum.iter.0: index):
-
+                %iv.next = arith.addi %iv.0, %step : index
-^for.cond(%iv: index, %sum.next: f32):
+                %stop = arith.cmpi uge %iv.next, %ub : index
-	; Yield current iteration sum to next iteration %sum.iter or to %sum
+                cf.br-cond %stop, ^for.end(%sum.iter.0: index), ^for.entry(%iv.next: index, %sum.iter.0: index)
-	; 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) -> ()
+                func.return %sum : f32
-}) {sym_name = "reduce"} : (memref<1024*f32>, index, index, index) -> f32
+        }
-
+}

doc/sample/ir/parse-test-2.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 } : () -> ()
+}) : () -> ()

doc/sample/ir/parse-test.mie

@@ -1,26 +1,25 @@
-~builtin.module() ({
+module {
-	~func.func() ({
+	func.func @reduce(%buffer: memref<?*f32>, %lb: index, %ub: index, %step: index) -> f32 {
-	^entry(%buffer: i32, %lb: index, %ub: index, %step: index):
 		; Initial sum set to 0.
-		%sum.0 = ~arith.constant() {value = 0.0 : f32} : () -> f32
+		%sum.0 = arith.constant 0.0 : 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) ] : () -> ()
+		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)
+		%t = memref.load %buffer[%iv] : memref<?*f32>
-		%sum.next = ~arith.addf(%sum.iter, %t) : (f32, f32) -> f32
+		%sum.next =  arith.addf %sum.iter, %t : f32
 
-		~cf.br() [ ^for.cond:(%iv: index, %sum.next: 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
+		%iv.next = arith.addi %iv, %step : index
-		%stop = ~arith.cmpi(%iv.next, %ub) { predicate = 9 } : (index, index) -> i1
+		%stop = arith.cmpi uge %iv.next, %ub : index
-		~cf.br-cond(%stop) [ ^for.end, ^for.entry:(%iv.next: index, %sum.next: f32) ] : (i1) -> ()
+		cf.br-cond %stop, ^for.end, ^for.entry(%iv.next: index, %sum.next: f32)
 
 	^for.end(%sum: f32):
-		~func.return(%sum) : (f32) -> ()
+		func.return %sum : f32
-	}) {sym_name = "reduce", function_type = (i32, index, index, index) -> f32 } : () -> ()
+	}
-}) : () -> ()
+}

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 Bluelib::Io)
+target_link_libraries(mie FX::Core FX::Ds FX::Io)
 target_compile_definitions(mie PRIVATE MIE_EXPORT=1 MIE_STATIC=${MIE_STATIC})

mie/attribute/attribute-definition.c

@@ -1,4 +1,4 @@
-#include <blue/ds/string.h>
+#include <fx/ds/string.h>
 #include <mie/attribute/attribute-definition.h>
 #include <mie/dialect/dialect.h>
 
@@ -12,7 +12,7 @@ struct mie_attribute_definition *mie_attribute_definition_create(
 
 	memset(out, 0x0, sizeof *out);
 
-	out->a_name = b_strdup(name);
+	out->a_name = fx_strdup(name);
 	if (!out->a_name) {
 		free(out);
 		return NULL;
@@ -20,7 +20,7 @@ struct mie_attribute_definition *mie_attribute_definition_create(
 
 	out->a_parent = parent;
 
-	b_rope name_rope = B_ROPE_CSTR(name);
+	fx_rope name_rope = FX_ROPE_CSTR(name);
 	mie_id_map_put(&parent->d_attributes, &out->a_id, &name_rope);
 
 	return out;

mie/attribute/attribute-map.c

@@ -1,6 +1,6 @@
-#include <blue/core/hash.h>
+#include <fx/core/hash.h>
-#include <blue/core/queue.h>
+#include <fx/core/queue.h>
-#include <blue/ds/string.h>
+#include <fx/ds/string.h>
 #include <mie/attribute/attribute-map.h>
 
 enum attribute_map_entry_type {
@@ -13,14 +13,14 @@ struct attribute_map_entry {
 	enum attribute_map_entry_type e_type;
 	uint64_t e_hash;
 	union {
-		b_btree_node e_node;
+		fx_bst_node e_node;
-		b_queue_entry e_entry;
+		fx_queue_entry e_entry;
 	};
 };
 
 struct attribute_map_bucket {
 	struct attribute_map_entry b_base;
-	b_queue b_items;
+	fx_queue b_items;
 };
 
 struct attribute_map_item {
@@ -29,9 +29,9 @@ struct attribute_map_item {
 	const struct mie_attribute *i_value;
 };
 
-static B_BTREE_DEFINE_SIMPLE_INSERT(
+static FX_BST_DEFINE_SIMPLE_INSERT(
 	struct attribute_map_entry, e_node, e_hash, put_entry);
-static B_BTREE_DEFINE_SIMPLE_GET(
+static FX_BST_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)
@@ -57,16 +57,16 @@ static const struct mie_attribute *get_attribute_from_item(
 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);
+	fx_queue_entry *cur = fx_queue_first(&bucket->b_items);
 	while (cur) {
-		const struct attribute_map_item *item = b_unbox(
+		const struct attribute_map_item *item = fx_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);
+		cur = fx_queue_next(cur);
 	}
 
 	return NULL;
@@ -90,7 +90,7 @@ static const struct mie_attribute *get_attribute_from_entry(
 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);
+	uint64_t name_hash = fx_hash_cstr(name);
 	struct attribute_map_entry *entry = get_entry(&map->m_entries, name_hash);
 	if (!entry) {
 		return NULL;
@@ -107,13 +107,13 @@ static struct attribute_map_bucket *convert_item_to_bucket(
 		return NULL;
 	}
 
-	b_btree_delete(&map->m_entries, &item->i_base.e_node);
+	fx_bst_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);
+	fx_queue_push_back(&bucket->b_items, &item->i_base.e_entry);
 	put_entry(&map->m_entries, &bucket->b_base);
 
 	return bucket;
@@ -132,7 +132,7 @@ static struct attribute_map_item *create_item(
 	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);
+	out->i_name = fx_strdup(name);
 	if (!out->i_name) {
 		free(out);
 		return NULL;
@@ -145,7 +145,7 @@ 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);
+	uint64_t name_hash = fx_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;
@@ -184,7 +184,7 @@ enum mie_status mie_attribute_map_put(
 		return MIE_ERR_NO_MEMORY;
 	}
 
-	b_queue_push_back(&bucket->b_items, &item->i_base.e_entry);
+	fx_queue_push_back(&bucket->b_items, &item->i_base.e_entry);
 	return MIE_SUCCESS;
 }
 
@@ -192,13 +192,13 @@ 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);
+	it->_n = fx_bst_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);
+		= fx_unbox(struct attribute_map_entry, it->_n, e_node);
 	struct attribute_map_item *item = NULL;
 	struct attribute_map_bucket *bucket = NULL;
 
@@ -210,8 +210,8 @@ enum mie_status mie_attribute_map_iterator_begin(
 		return MIE_SUCCESS;
 	case ATTRMAP_ENTRY_BUCKET:
 		bucket = (struct attribute_map_bucket *)entry;
-		it->_e = b_queue_first(&bucket->b_items);
+		it->_e = fx_queue_first(&bucket->b_items);
-		item = b_unbox(struct attribute_map_item, it->_e, i_base.e_entry);
+		item = fx_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;
@@ -228,11 +228,11 @@ enum mie_status mie_attribute_map_iterator_move_next(
 	struct attribute_map_bucket *next_bucket = NULL;
 
 	if (it->_e) {
-		it->_e = b_queue_next(it->_e);
+		it->_e = fx_queue_next(it->_e);
-		next_entry = b_unbox(struct attribute_map_entry, it->_e, e_entry);
+		next_entry = fx_unbox(struct attribute_map_entry, it->_e, e_entry);
 	} else if (it->_n) {
-		it->_n = b_btree_next(it->_n);
+		it->_n = fx_bst_next(it->_n);
-		next_entry = b_unbox(struct attribute_map_entry, it->_n, e_node);
+		next_entry = fx_unbox(struct attribute_map_entry, it->_n, e_node);
 	} else {
 		memset(it, 0x0, sizeof *it);
 		return MIE_ERR_NO_DATA;
@@ -249,8 +249,8 @@ enum mie_status mie_attribute_map_iterator_move_next(
 		break;
 	case ATTRMAP_ENTRY_BUCKET:
 		next_bucket = (struct attribute_map_bucket *)next_item;
-		it->_e = b_queue_first(&next_bucket->b_items);
+		it->_e = fx_queue_first(&next_bucket->b_items);
-		next_item = b_unbox(
+		next_item = fx_unbox(
 			struct attribute_map_item, it->_e, i_base.e_entry);
 		break;
 	default:

mie/ctx.c

@@ -1,9 +1,11 @@
-#include <blue/core/bstr.h>
+#include <fx/core/bstr.h>
-#include <blue/ds/hashmap.h>
+#include <fx/ds/hashmap.h>
-#include <blue/ds/list.h>
+#include <fx/ds/list.h>
-#include <blue/ds/string.h>
+#include <fx/ds/string.h>
 #include <mie/attribute/attribute-definition.h>
 #include <mie/ctx.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>
@@ -86,7 +88,6 @@ struct mie_op *mie_ctx_create_op(
 
 	out->op_flags |= MIE_OP_F_OP_RESOLVED;
 	out->op_info = def;
-	out->op_dialect = def->op_parent;
 
 	return out;
 }
@@ -127,7 +128,6 @@ bool mie_ctx_resolve_op(const struct mie_ctx *ctx, struct mie_op *op)
 		return false;
 	}
 
-	op->op_dialect = dialect;
 	op->op_info = op_info;
 
 	free(op->op_name);
@@ -140,123 +140,123 @@ bool mie_ctx_resolve_op(const struct mie_ctx *ctx, struct mie_op *op)
 
 struct mie_dialect *mie_ctx_get_dialect(const struct mie_ctx *ctx, const char *name)
 {
-	b_rope name_rope = B_ROPE_CSTR(name);
+	fx_rope name_rope = FX_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);
+	return fx_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);
+	fx_rope dialect_name_rope = FX_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);
+	struct mie_dialect *dialect = fx_unbox(struct mie_dialect, target, d_id);
 	if (!dialect) {
 		return NULL;
 	}
 
-	b_rope op_name_rope = B_ROPE_CSTR(op_name);
+	fx_rope op_name_rope = FX_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);
+	return fx_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);
+	fx_rope dialect_name_rope = FX_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);
+	struct mie_dialect *dialect = fx_unbox(struct mie_dialect, target, d_id);
 	if (!dialect) {
 		return NULL;
 	}
 
-	b_rope type_name_rope = B_ROPE_CSTR(type_name);
+	fx_rope type_name_rope = FX_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);
+	return fx_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);
+	fx_rope dialect_name_rope = FX_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);
+	struct mie_dialect *dialect = fx_unbox(struct mie_dialect, target, d_id);
 	if (!dialect) {
 		return NULL;
 	}
 
-	b_rope trait_name_rope = B_ROPE_CSTR(trait_name);
+	fx_rope trait_name_rope = FX_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);
+	return fx_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);
+	fx_rope dialect_name_rope = FX_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);
+	struct mie_dialect *dialect = fx_unbox(struct mie_dialect, target, d_id);
 	if (!dialect) {
 		return NULL;
 	}
 
-	b_rope attribute_name_rope = B_ROPE_CSTR(attribute_name);
+	fx_rope attribute_name_rope = FX_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);
+	return fx_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);
+	fx_rope dialect_name_rope = FX_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);
+	struct mie_dialect *dialect = fx_unbox(struct mie_dialect, target, d_id);
 	if (!dialect) {
 		return NULL;
 	}
 
-	b_rope interface_name_rope = B_ROPE_CSTR(interface_name);
+	fx_rope interface_name_rope = FX_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);
+	return fx_unbox(struct mie_interface_definition, target, if_id);
 }
 
 struct mie_type *mie_ctx_get_type(
@@ -264,13 +264,13 @@ struct mie_type *mie_ctx_get_type(
 {
 	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);
+	fx_rope full_name_rope = FX_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);
+	struct mie_type *type = fx_unbox(struct mie_type, target, ty_id);
 	if (type) {
 		return type;
 	}
@@ -295,7 +295,7 @@ struct mie_type *mie_ctx_get_type(
 	memset(type, 0x0, sizeof *type);
 
 	type->ty_def = type_info;
-	type->ty_name = b_bstr_fmt(NULL, "%s.%s", dialect_name, type_name);
+	type->ty_name = fx_bstr_fmt(NULL, "%s.%s", dialect_name, type_name);
 
 	if (type_info->ty_init) {
 		type_info->ty_init(type_info, type);
@@ -311,13 +311,13 @@ const struct mie_trait *mie_ctx_get_trait(
 {
 	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);
+	fx_rope full_name_rope = FX_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);
+	struct mie_trait *trait = fx_unbox(struct mie_trait, target, tr_id);
 	if (trait) {
 		return trait;
 	}
@@ -342,7 +342,7 @@ const struct mie_trait *mie_ctx_get_trait(
 	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);
+	trait->tr_name = fx_bstr_fmt(NULL, "%s.%s", dialect_name, trait_name);
 
 	if (trait_info->tr_init) {
 		trait_info->tr_init(trait_info, trait);
@@ -363,7 +363,7 @@ struct mie_type *mie_ctx_get_storage_type(
 	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);
+	struct mie_type *type = fx_unbox(struct mie_type, target, ty_id);
 	if (type) {
 		return type;
 	}
@@ -389,7 +389,7 @@ struct mie_type *mie_ctx_get_function_type(
 	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);
+	struct mie_type *type = fx_unbox(struct mie_type, target, ty_id);
 	if (type) {
 		return type;
 	}
@@ -456,7 +456,7 @@ enum mie_status mie_ctx_get_pass(
 	}
 
 	struct mie_pass_definition *pass_def
-		= b_unbox(struct mie_pass_definition, target, p_id);
+		= fx_unbox(struct mie_pass_definition, target, p_id);
 
 	if (pass_def->p_data_size < sizeof(struct mie_pass)) {
 		return MIE_ERR_BAD_STATE;
@@ -484,3 +484,44 @@ enum mie_status mie_ctx_get_pass(
 	*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];
+
+	fx_queue_push_back(&ctx->ctx_diag, &diag->diag_entry);
+
+	return diag;
+}
+
+struct mie_diag *mie_ctx_pop_diag(struct mie_ctx *ctx)
+{
+	fx_queue_entry *entry = fx_queue_pop_front(&ctx->ctx_diag);
+	if (!entry) {
+		return NULL;
+	}
+
+	return fx_unbox(struct mie_diag, entry, diag_entry);
+}

mie/diag/diag.c

@@ -0,0 +1,124 @@
+#include <fx/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 = fx_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
+	    || !dialect->d_diag_msgs[msg].msg_content) {
+		fprintf(stderr, "FATAL: %lu is not a valid %s diag msg\n", msg,
+		        dialect_name);
+		abort();
+		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;
+	}
+
+	fx_queue_push_back(&diag->diag_components, &c_msg->msg_base.c_entry);
+}
+
+void mie_diag_push_string(struct mie_diag *diag, const char *str)
+{
+	struct mie_diag_c_msg *c_msg = malloc(sizeof *c_msg);
+	if (!c_msg) {
+		return;
+	}
+
+	memset(c_msg, 0x0, sizeof *c_msg);
+	c_msg->msg_base.c_type = MIE_DIAG_COMPONENT_MSG;
+	c_msg->msg_content = fx_strdup(str);
+
+	fx_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;
+	}
+
+	fx_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 <fx/core/queue.h>
+
+#endif

mie/dialect/arith/arith.c

@@ -1,9 +1,16 @@
 #include <mie/ctx.h>
+#include <mie/diag/class.h>
+#include <mie/diag/msg.h>
 #include <mie/dialect/arith.h>
 #include <mie/dialect/dialect.h>
 #include <mie/macros.h>
 
+MIE_DIAG_CLASS_LIST_EXTERN(mie_arith_diag);
+MIE_DIAG_MSG_LIST_EXTERN(mie_arith_msg);
+
 MIE_DIALECT_BEGIN(mie_arith, struct mie_dialect, "arith")
+	MIE_DIALECT_DIAG_CLASS_LIST(mie_arith_diag);
+	MIE_DIALECT_DIAG_MSG_LIST(mie_arith_msg);
 	MIE_DIALECT_ADD_OP(mie_arith_addi);
 	MIE_DIALECT_ADD_OP(mie_arith_cmpi);
 	MIE_DIALECT_ADD_OP(mie_arith_addf);

mie/dialect/arith/diag.c

@@ -0,0 +1,29 @@
+#include <mie/diag/class.h>
+#include <mie/diag/msg.h>
+#include <mie/dialect/arith.h>
+#include <mie/macros.h>
+
+#define MIE_DIAG_CLASS_PREFIX MIE_ARITH_E
+#define MIE_DIAG_MSG_PREFIX   MIE_ARITH_MSG
+
+MIE_DIAG_CLASS_LIST_BEGIN(mie_arith_diag)
+	MIE_DIAG_CLASS(INVALID_INTEGER_TYPE, ERROR, "Invalid integer type")
+	MIE_DIAG_CLASS(INVALID_FLOAT_TYPE, ERROR, "Invalid floating-point type")
+	MIE_DIAG_CLASS(
+		INVALID_COMPARISON_PREDICATE, ERROR,
+		"Invalid comparison predicate")
+MIE_DIAG_CLASS_LIST_END(mie_arith_diag)
+
+MIE_DIAG_MSG_LIST_BEGIN(mie_arith_msg)
+	MIE_DIAG_MSG(EXPECTED_INTEGER_TYPE, "expected an integer or index type.")
+	MIE_DIAG_MSG(EXPECTED_FLOAT_TYPE, "expected a floating-point type.")
+	MIE_DIAG_MSG(
+		INVALID_COMPARISON_PREDICATE,
+		"this is not a valid comparison predicate.")
+	MIE_DIAG_MSG(
+		VALID_COMPARISON_PREDICATES,
+		"valid comparison predicates include: [blue]eq[reset], "
+	        "[blue]ne[reset], [blue]slt[reset], [blue]sle[reset], "
+	        "[blue]sgt[reset], [blue]sge[reset], [blue]ult[reset], "
+	        "[blue]ule[reset], [blue]ugt[reset], [blue]uge[reset]")
+MIE_DIAG_MSG_LIST_END(mie_arith_msg)

mie/dialect/arith/float-cache.c

@@ -1,4 +1,4 @@
-#include <blue/core/btree.h>
+#include <fx/core/bst.h>
 #include <mie/ctx.h>
 #include <mie/dialect/builtin.h>
 #include <stdlib.h>
@@ -10,19 +10,19 @@ typedef union float_key {
 } float_key;
 
 struct float_width_cache_entry {
-	b_btree_node e_node;
+	fx_bst_node e_node;
 	float_key e_key;
 	struct mie_float e_value;
 };
 
 struct float_width_cache {
-	b_btree_node c_node;
+	fx_bst_node c_node;
 	size_t c_width;
-	b_btree c_floats;
+	fx_bst c_floats;
 };
 
 struct mie_float_cache {
-	b_btree c_widths;
+	fx_bst c_widths;
 };
 
 static int float_key_compare(const float_key *a, const float_key *b)
@@ -30,38 +30,38 @@ 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(
+static FX_BST_DEFINE_SIMPLE_INSERT(
 	struct float_width_cache, c_node, c_width, put_width_cache);
-static B_BTREE_DEFINE_SIMPLE_GET(
+static FX_BST_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)
+void put_float(fx_bst *tree, struct float_width_cache_entry *node)
 {
-	if (!tree->b_root) {
+	if (!tree->bst_root) {
-		tree->b_root = &node->e_node;
+		tree->bst_root = &node->e_node;
-		b_btree_insert_fixup(tree, &node->e_node);
+		fx_bst_insert_fixup(tree, &node->e_node);
 		return;
 	}
 
-	b_btree_node *cur = tree->b_root;
+	fx_bst_node *cur = tree->bst_root;
 	while (1) {
 		struct float_width_cache_entry *cur_node
-			= b_unbox(struct float_width_cache_entry, cur, e_node);
+			= fx_unbox(struct float_width_cache_entry, cur, e_node);
-		b_btree_node *next = NULL;
+		fx_bst_node *next = NULL;
 		int cmp = float_key_compare(&node->e_key, &cur_node->e_key);
 
 		if (cmp >= 0) {
-			next = b_btree_right(cur);
+			next = fx_bst_right(cur);
 
 			if (!next) {
-				b_btree_put_right(cur, &node->e_node);
+				fx_bst_put_right(cur, &node->e_node);
 				break;
 			}
 		} else if (cmp < 0) {
-			next = b_btree_left(cur);
+			next = fx_bst_left(cur);
 
 			if (!next) {
-				b_btree_put_left(cur, &node->e_node);
+				fx_bst_put_left(cur, &node->e_node);
 				break;
 			}
 		} else {
@@ -71,20 +71,20 @@ void put_float(b_btree *tree, struct float_width_cache_entry *node)
 		cur = next;
 	}
 
-	b_btree_insert_fixup(tree, &node->e_node);
+	fx_bst_insert_fixup(tree, &node->e_node);
 }
 
-static struct float_width_cache_entry *get_float(const b_btree *tree, float_key key)
+static struct float_width_cache_entry *get_float(const fx_bst *tree, float_key key)
 {
-	b_btree_node *cur = tree->b_root;
+	fx_bst_node *cur = tree->bst_root;
 	while (cur) {
 		struct float_width_cache_entry *cur_node
-			= b_unbox(struct float_width_cache_entry, cur, e_node);
+			= fx_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);
+			cur = fx_bst_right(cur);
 		} else if (cmp < 0) {
-			cur = b_btree_left(cur);
+			cur = fx_bst_left(cur);
 		} else {
 			return cur_node;
 		}
@@ -109,13 +109,13 @@ static struct float_width_cache *float_width_cache_create(size_t width)
 
 static void float_width_cache_destroy(struct float_width_cache *cache)
 {
-	b_btree_node *cur = b_btree_first(&cache->c_floats);
+	fx_bst_node *cur = fx_bst_first(&cache->c_floats);
 	while (cur) {
-		b_btree_node *next = b_btree_next(cur);
+		fx_bst_node *next = fx_bst_next(cur);
-		b_btree_delete(&cache->c_floats, cur);
+		fx_bst_delete(&cache->c_floats, cur);
 
 		struct float_width_cache_entry *entry
-			= b_unbox(struct float_width_cache_entry, cur, e_node);
+			= fx_unbox(struct float_width_cache_entry, cur, e_node);
 		free(entry);
 
 		cur = next;
@@ -170,13 +170,13 @@ struct mie_float_cache *mie_float_cache_create(void)
 
 void mie_float_cache_destroy(struct mie_float_cache *cache)
 {
-	b_btree_node *cur = b_btree_first(&cache->c_widths);
+	fx_bst_node *cur = fx_bst_first(&cache->c_widths);
 	while (cur) {
-		b_btree_node *next = b_btree_next(cur);
+		fx_bst_node *next = fx_bst_next(cur);
-		b_btree_delete(&cache->c_widths, cur);
+		fx_bst_delete(&cache->c_widths, cur);
 
 		struct float_width_cache *width_cache
-			= b_unbox(struct float_width_cache, cur, c_node);
+			= fx_unbox(struct float_width_cache, cur, c_node);
 		float_width_cache_destroy(width_cache);
 
 		cur = next;

mie/dialect/arith/int-cache.c

@@ -1,32 +1,32 @@
-#include <blue/core/btree.h>
+#include <fx/core/bst.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;
+	fx_bst_node e_node;
 	struct mie_int e_value;
 };
 
 struct int_width_cache {
-	b_btree_node c_node;
+	fx_bst_node c_node;
 	size_t c_width;
-	b_btree c_ints;
+	fx_bst c_ints;
 };
 
 struct mie_int_cache {
-	b_btree c_widths;
+	fx_bst c_widths;
 };
 
-static B_BTREE_DEFINE_SIMPLE_INSERT(
+static FX_BST_DEFINE_SIMPLE_INSERT(
 	struct int_width_cache, c_node, c_width, put_width_cache);
-static B_BTREE_DEFINE_SIMPLE_GET(
+static FX_BST_DEFINE_SIMPLE_GET(
 	struct int_width_cache, size_t, c_node, c_width, get_width_cache);
 
-static B_BTREE_DEFINE_SIMPLE_INSERT(
+static FX_BST_DEFINE_SIMPLE_INSERT(
 	struct int_width_cache_entry, e_node, e_value.i_val.v_small, put_int);
-static B_BTREE_DEFINE_SIMPLE_GET(
+static FX_BST_DEFINE_SIMPLE_GET(
 	struct int_width_cache_entry, uint64_t, e_node, e_value.i_val.v_small,
 	get_int);
 
@@ -46,13 +46,13 @@ static struct int_width_cache *int_width_cache_create(size_t width)
 
 static void int_width_cache_destroy(struct int_width_cache *cache)
 {
-	b_btree_node *cur = b_btree_first(&cache->c_ints);
+	fx_bst_node *cur = fx_bst_first(&cache->c_ints);
 	while (cur) {
-		b_btree_node *next = b_btree_next(cur);
+		fx_bst_node *next = fx_bst_next(cur);
-		b_btree_delete(&cache->c_ints, cur);
+		fx_bst_delete(&cache->c_ints, cur);
 
 		struct int_width_cache_entry *entry
-			= b_unbox(struct int_width_cache_entry, cur, e_node);
+			= fx_unbox(struct int_width_cache_entry, cur, e_node);
 		free(entry);
 
 		cur = next;
@@ -96,13 +96,13 @@ struct mie_int_cache *mie_int_cache_create(void)
 
 void mie_int_cache_destroy(struct mie_int_cache *cache)
 {
-	b_btree_node *cur = b_btree_first(&cache->c_widths);
+	fx_bst_node *cur = fx_bst_first(&cache->c_widths);
 	while (cur) {
-		b_btree_node *next = b_btree_next(cur);
+		fx_bst_node *next = fx_bst_next(cur);
-		b_btree_delete(&cache->c_widths, cur);
+		fx_bst_delete(&cache->c_widths, cur);
 
 		struct int_width_cache *width_cache
-			= b_unbox(struct int_width_cache, cur, c_node);
+			= fx_unbox(struct int_width_cache, cur, c_node);
 		int_width_cache_destroy(width_cache);
 
 		cur = next;

mie/dialect/arith/op/addf.c

@@ -1,8 +1,12 @@
+#include <mie/dialect/arith.h>
+#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/parse/parser.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)
 {
@@ -13,18 +17,70 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
 	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, ' ');
+	fx_stream_write_char(printer->p_stream, ' ');
 	mie_printer_print_op_arg(printer, left, false);
-	b_stream_write_string(printer->p_stream, ", ", NULL);
+	fx_stream_write_string(printer->p_stream, ", ", NULL);
 	mie_printer_print_op_arg(printer, right, false);
-	b_stream_write_string(printer->p_stream, " : ", NULL);
+	fx_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)
+static enum mie_status parse(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out)
 {
+	struct mie_file_span span;
+	if (MIE_VECTOR_COUNT(out->op_result) != 1) {
+		mie_op_get_results_span(out, &span);
+		mie_parser_report_error_simple(
+			parser, "builtin",
+			MIE_BUILTIN_E_INCORRECT_NUMBER_OF_RESULTS,
+			MIE_BUILTIN_MSG_OP_INCORRECT_NUMBER_OF_RESULTS, &span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_parameter_list(
+		    parser, false, MIE_VECTOR_REF(out->op_args),
+		    "arithmetic operation arguments")) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (MIE_VECTOR_COUNT(out->op_args) != 2) {
+		mie_op_get_args_span(out, &span);
+		mie_parser_report_error_simple(
+			parser, "builtin",
+			MIE_BUILTIN_E_INCORRECT_NUMBER_OF_ARGUMENTS,
+			MIE_BUILTIN_MSG_OP_INCORRECT_NUMBER_OF_ARGS, &span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_COLON)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_COLON, "arithmetic operation type");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	const struct mie_type *type = NULL;
+	if (!mie_parser_parse_type(
+		    parser, "arithmetic operation type", &type, &span)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_type_is(type, "builtin", "float")) {
+		mie_parser_report_error_simple(
+			parser, "arith", MIE_ARITH_E_INVALID_FLOAT_TYPE,
+			MIE_ARITH_MSG_EXPECTED_FLOAT_TYPE, &span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(out->op_args); i++) {
+		out->op_args.items[i].arg_unresolved.reg_type = type;
+	}
+
+	out->op_result.items[0].reg_type = type;
+
 	return MIE_SUCCESS;
 }
 

mie/dialect/arith/op/addi.c

@@ -1,10 +1,12 @@
 #include <mie/ctx.h>
+#include <mie/dialect/arith.h>
 #include <mie/dialect/builtin.h>
 #include <mie/dialect/dialect.h>
-#include <mie/ir/builder.h>
+#include <mie/ir/emit.h>
 #include <mie/ir/op-definition.h>
 #include <mie/ir/op.h>
 #include <mie/macros.h>
+#include <mie/parse/parser.h>
 #include <mie/print/printer.h>
 #include <mie/type/type.h>
 
@@ -17,35 +19,88 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
 	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, ' ');
+	fx_stream_write_char(printer->p_stream, ' ');
 	mie_printer_print_op_arg(printer, left, false);
-	b_stream_write_string(printer->p_stream, ", ", NULL);
+	fx_stream_write_string(printer->p_stream, ", ", NULL);
 	mie_printer_print_op_arg(printer, right, false);
-	b_stream_write_string(printer->p_stream, " : ", NULL);
+	fx_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)
+static enum mie_status parse(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out)
 {
+	struct mie_file_span span;
+	if (MIE_VECTOR_COUNT(out->op_result) != 1) {
+		mie_op_get_results_span(out, &span);
+		mie_parser_report_error_simple(
+			parser, "builtin",
+			MIE_BUILTIN_E_INCORRECT_NUMBER_OF_RESULTS,
+			MIE_BUILTIN_MSG_OP_INCORRECT_NUMBER_OF_RESULTS, &span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_parameter_list(
+		    parser, false, MIE_VECTOR_REF(out->op_args),
+		    "arithmetic operation arguments")) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (MIE_VECTOR_COUNT(out->op_args) != 2) {
+		mie_op_get_args_span(out, &span);
+		mie_parser_report_error_simple(
+			parser, "builtin",
+			MIE_BUILTIN_E_INCORRECT_NUMBER_OF_ARGUMENTS,
+			MIE_BUILTIN_MSG_OP_INCORRECT_NUMBER_OF_ARGS, &span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_COLON)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_COLON, "arithmetic operation type");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	const struct mie_type *type = NULL;
+	if (!mie_parser_parse_type(
+		    parser, "arithmetic operation type", &type, &span)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	bool is_int_type = mie_type_is(type, "builtin", "int")
+	                || mie_type_is(type, "builtin", "index");
+
+	if (!is_int_type) {
+		mie_parser_report_error_simple(
+			parser, "arith", MIE_ARITH_E_INVALID_INTEGER_TYPE,
+			MIE_ARITH_MSG_EXPECTED_INTEGER_TYPE, &span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(out->op_args); i++) {
+		out->op_args.items[i].arg_unresolved.reg_type = type;
+	}
+
+	out->op_result.items[0].reg_type = type;
+
 	return MIE_SUCCESS;
 }
 
-struct mie_register *mie_arith_put_addi(
+struct mie_register *mie_arith_addi_put(
-	struct mie_builder *builder, struct mie_register *left,
+	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
+	struct mie_op *op = mie_emitter_put_op(e, "arith", "addi", args, nr_args);
-		= mie_builder_put_op(builder, "arith", "addi", args, nr_args);
 	const struct mie_type *ty = left->reg_type;
 
 	struct mie_register *result = mie_op_add_result(op, ty);
-	result->reg_block = mie_builder_get_current_block(builder);
+	mie_emitter_put_name(e, &result->reg_name, name);
-	mie_builder_put_name(builder, &result->reg_name, name);
 
 	return result;
 }

mie/dialect/arith/op/cmpi.c

@@ -1,9 +1,34 @@
+#include <mie/diag/diag.h>
+#include <mie/dialect/arith.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/parse/parser.h>
 #include <mie/print/printer.h>
+#include <mie/type/type.h>
+
+#define PREDICATE(id, str) [MIE_ARITH_CMPI_##id] = str
+static const char *predicates[] = {
+	PREDICATE(EQ, "eq"),   PREDICATE(NE, "ne"),   PREDICATE(SLT, "slt"),
+	PREDICATE(SLE, "sle"), PREDICATE(SGT, "sgt"), PREDICATE(SGE, "sge"),
+	PREDICATE(ULT, "ult"), PREDICATE(ULE, "ule"), PREDICATE(UGT, "ugt"),
+	PREDICATE(UGE, "uge"),
+};
+static const size_t nr_predicates = sizeof predicates / sizeof predicates[0];
+
+static int find_predicate(const char *pred)
+{
+	for (size_t i = 0; i < nr_predicates; i++) {
+		if (!strcmp(pred, predicates[i])) {
+			return i;
+		}
+	}
+
+	return -1;
+}
 
 static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
 {
@@ -22,58 +47,129 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
 		return MIE_SUCCESS;
 	}
 
-	b_stream_write_char(printer->p_stream, ' ');
+	fx_stream_write_char(printer->p_stream, ' ');
 
-	switch (pred) {
+	if (pred < 0 || pred >= nr_predicates) {
-	case 0:
+		return MIE_ERR_BAD_STATE;
-		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, ' ');
+	fx_stream_write_string(printer->p_stream, predicates[pred], NULL);
+
+	fx_stream_write_char(printer->p_stream, ' ');
 	mie_printer_print_op_arg(printer, left, false);
-	b_stream_write_string(printer->p_stream, ", ", NULL);
+	fx_stream_write_string(printer->p_stream, ", ", NULL);
 	mie_printer_print_op_arg(printer, right, false);
-	b_stream_write_string(printer->p_stream, " : ", NULL);
+	fx_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)
+static enum mie_status parse(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out)
 {
+	struct mie_file_span span;
+	if (MIE_VECTOR_COUNT(out->op_result) != 1) {
+		mie_op_get_results_span(out, &span);
+		mie_parser_report_error_simple(
+			parser, "builtin",
+			MIE_BUILTIN_E_INCORRECT_NUMBER_OF_RESULTS,
+			MIE_BUILTIN_MSG_OP_INCORRECT_NUMBER_OF_RESULTS, &span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	fx_string *tmp = mie_parser_get_tempstr(parser);
+	if (!mie_parser_parse_word(parser, tmp, &span)) {
+		mie_parser_report_unexpected_token_s(
+			parser, "predicate word", "comparison operation");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	int pred = find_predicate(fx_string_ptr(tmp));
+	if (pred == -1) {
+		struct mie_diag *diag = mie_parser_report_error_simple(
+			parser, "arith", MIE_ARITH_E_INVALID_COMPARISON_PREDICATE,
+			MIE_ARITH_MSG_INVALID_COMPARISON_PREDICATE, &span);
+		mie_diag_push_msg(
+			diag, mie_parser_get_mie_ctx(parser), "arith",
+			MIE_ARITH_MSG_VALID_COMPARISON_PREDICATES);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_parameter_list(
+		    parser, false, MIE_VECTOR_REF(out->op_args),
+		    "comparison operands")) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (MIE_VECTOR_COUNT(out->op_args) != 2) {
+		mie_op_get_args_span(out, &span);
+		mie_parser_report_error_simple(
+			parser, "builtin",
+			MIE_BUILTIN_E_INCORRECT_NUMBER_OF_ARGUMENTS,
+			MIE_BUILTIN_MSG_OP_INCORRECT_NUMBER_OF_ARGS, &span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_COLON)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_COLON, "comparison operand type");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	const struct mie_type *type;
+	if (!mie_parser_parse_type(parser, "comparison operand type", &type, &span)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	bool is_int_type = mie_type_is(type, "builtin", "int")
+	                || mie_type_is(type, "builtin", "index");
+
+	if (!is_int_type) {
+		mie_parser_report_error_simple(
+			parser, "arith", MIE_ARITH_E_INVALID_INTEGER_TYPE,
+			MIE_ARITH_MSG_EXPECTED_INTEGER_TYPE, &span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(out->op_args); i++) {
+		out->op_args.items[i].arg_unresolved.reg_type = type;
+	}
+
+	out->op_result.items[0].reg_type
+		= mie_ctx_get_int_type(mie_parser_get_mie_ctx(parser), 1);
+
+	struct mie_attribute *pred_attribute
+		= mie_ctx_get_int(mie_parser_get_mie_ctx(parser), pred, 64);
+	mie_attribute_map_put(
+		&out->op_attrib, "predicate", pred_attribute,
+		MIE_ATTRMAP_F_REPLACE);
+
 	return MIE_SUCCESS;
 }
 
+struct mie_register *mie_arith_cmpi_put(
+	struct mie_emitter *e, enum mie_arith_cmpi_predicate pred,
+	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", "cmpi", 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);
+
+	struct mie_attribute *pred_attribute
+		= mie_ctx_get_int(mie_emitter_get_ctx(e), pred, 64);
+	mie_attribute_map_put(
+		&op->op_attrib, "predicate", pred_attribute, MIE_ATTRMAP_F_REPLACE);
+
+	return result;
+}
+
 MIE_OP_DEFINITION_BEGIN(mie_arith_cmpi, "cmpi")
 	MIE_OP_DEFINITION_PRINT(print);
 	MIE_OP_DEFINITION_PARSE(parse);

mie/dialect/arith/op/constant.c

@@ -1,11 +1,14 @@
 #include <mie/attribute/attribute.h>
+#include <mie/dialect/arith.h>
 #include <mie/dialect/builtin.h>
 #include <mie/dialect/dialect.h>
-#include <mie/ir/builder.h>
+#include <mie/ir/emit.h>
 #include <mie/ir/op-definition.h>
 #include <mie/ir/op.h>
 #include <mie/macros.h>
+#include <mie/parse/parser.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)
 {
@@ -18,14 +21,14 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
 	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(
+		fx_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);
+		fx_stream_write_fmt(printer->p_stream, NULL, " %g : ", d);
 		type = f->f_type;
 	} else {
 		return MIE_SUCCESS;
@@ -36,44 +39,155 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
 	return MIE_SUCCESS;
 }
 
-static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+static enum mie_status parse_int(
+	struct mie_parser *parser, long long i, struct mie_file_span *loc,
+	struct mie_op *out)
 {
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_COLON)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_COLON, "arithmetic constant type");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	const struct mie_type *type = NULL;
+	struct mie_file_span type_span;
+	if (!mie_parser_parse_type(
+		    parser, "arithmetic constant type", &type, &type_span)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_TOK_TYPENAME, "arithmetic constant type");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	struct mie_attribute *value = NULL;
+
+	if (mie_type_is(type, "builtin", "int")) {
+		value = mie_ctx_get_int(
+			mie_parser_get_mie_ctx(parser), i,
+			mie_int_type_get_width(type));
+	} else if (mie_type_is(type, "builtin", "index")) {
+		value = mie_ctx_get_index(mie_parser_get_mie_ctx(parser), i);
+	} else {
+		mie_parser_report_error_simple(
+			parser, "arith", MIE_ARITH_E_INVALID_INTEGER_TYPE,
+			MIE_ARITH_MSG_EXPECTED_INTEGER_TYPE, &type_span);
+	}
+
+	if (MIE_VECTOR_COUNT(out->op_result) != 1) {
+		mie_parser_report_error_simple(
+			parser, "builtin",
+			MIE_BUILTIN_E_INCORRECT_NUMBER_OF_RESULTS,
+			MIE_BUILTIN_MSG_OP_EXPECTS_X_RESULTS, &type_span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	mie_attribute_map_put(
+		&out->op_attrib, "value", value, MIE_ATTRMAP_F_REPLACE);
+
+	out->op_result.items[0].reg_type = type;
+
 	return MIE_SUCCESS;
 }
 
-struct mie_register *mie_arith_put_constant_i(
+static enum mie_status parse_float(
-	struct mie_builder *builder, long long value, const char *name)
+	struct mie_parser *parser, double d, struct mie_file_span *loc,
+	struct mie_op *out)
 {
-	struct mie_op *op
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_COLON)) {
-		= mie_builder_put_op(builder, "arith", "constant", NULL, 0);
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_COLON, "arithmetic constant type");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	const struct mie_type *type = NULL;
+	struct mie_file_span type_span;
+	if (!mie_parser_parse_type(
+		    parser, "arithmetic constant type", &type, &type_span)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_TOK_TYPENAME, "arithmetic constant type");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	struct mie_attribute *value = NULL;
+
+	if (mie_type_is(type, "builtin", "float")) {
+		value = mie_ctx_get_float(
+			mie_parser_get_mie_ctx(parser), d,
+			mie_float_type_get_width(type));
+	} else {
+		mie_parser_report_error_simple(
+			parser, "arith", MIE_ARITH_E_INVALID_FLOAT_TYPE,
+			MIE_ARITH_MSG_EXPECTED_FLOAT_TYPE, &type_span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (MIE_VECTOR_COUNT(out->op_result) != 1) {
+		mie_parser_report_error_simple(
+			parser, "builtin",
+			MIE_BUILTIN_E_INCORRECT_NUMBER_OF_RESULTS,
+			MIE_BUILTIN_MSG_OP_EXPECTS_X_RESULTS, &type_span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	mie_attribute_map_put(
+		&out->op_attrib, "value", value, MIE_ATTRMAP_F_REPLACE);
+
+	out->op_result.items[0].reg_type = type;
+
+	return MIE_SUCCESS;
+}
+
+static enum mie_status parse(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out)
+{
+	double d;
+	long long i;
+	struct mie_file_span span;
+	if (mie_parser_parse_int(parser, &i, &span)) {
+		return parse_int(parser, i, &span, out);
+	} else if (mie_parser_parse_float(parser, &d, &span)) {
+		return parse_float(parser, d, &span, out);
+	} else {
+		struct mie_parser_item required[] = {
+			MIE_PARSE_ITEM_TOKEN(MIE_TOK_INT),
+			MIE_PARSE_ITEM_TOKEN(MIE_TOK_FLOAT),
+			MIE_PARSE_ITEM_NONE,
+		};
+		mie_parser_report_unexpected_token_v(
+			parser, required, "arithmetic constant");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+}
+
+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_builder_get_ctx(builder), 32);
+		= mie_ctx_get_int_type(mie_emitter_get_ctx(e), 32);
 	struct mie_register *result = mie_op_add_result(op, ty);
 
-	result->reg_block = mie_builder_get_current_block(builder);
+	mie_emitter_put_name(e, &result->reg_name, name);
-	mie_builder_put_name(builder, &result->reg_name, name);
 
 	struct mie_attribute *val
-		= mie_ctx_get_int(mie_builder_get_ctx(builder), value, 32);
+		= 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_put_constant_f(
+struct mie_register *mie_arith_constant_f_put(
-	struct mie_builder *builder, long long value, const char *name)
+	struct mie_emitter *e, long long value, const char *name)
 {
-	struct mie_op *op
+	struct mie_op *op = mie_emitter_put_op(e, "arith", "constant", NULL, 0);
-		= mie_builder_put_op(builder, "arith", "constant", NULL, 0);
 	const struct mie_type *ty
-		= mie_ctx_get_int_type(mie_builder_get_ctx(builder), 32);
+		= mie_ctx_get_int_type(mie_emitter_get_ctx(e), 32);
 	struct mie_register *result = mie_op_add_result(op, ty);
 
-	result->reg_block = mie_builder_get_current_block(builder);
+	mie_emitter_put_name(e, &result->reg_name, name);
-	mie_builder_put_name(builder, &result->reg_name, name);
 
 	struct mie_attribute *val
-		= mie_ctx_get_float(mie_builder_get_ctx(builder), value, 32);
+		= 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/dialect/builtin/attribute/array.c

@@ -13,27 +13,27 @@ static enum mie_status print(
 	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);
+		fx_stream_write_string(out->p_stream, "#builtin.array<", NULL);
 	}
 
-	b_stream_write_char(out->p_stream, '[');
+	fx_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, ',');
+			fx_stream_write_char(out->p_stream, ',');
 		}
 
-		b_stream_write_char(out->p_stream, ' ');
+		fx_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, ' ');
+		fx_stream_write_char(out->p_stream, ' ');
 	}
-	b_stream_write_char(out->p_stream, ']');
+	fx_stream_write_char(out->p_stream, ']');
 
 	if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) {
-		b_stream_write_char(out->p_stream, '>');
+		fx_stream_write_char(out->p_stream, '>');
 	}
 
 	return MIE_SUCCESS;

mie/dialect/builtin/attribute/float.c

@@ -1,6 +1,6 @@
 #include "../float.h"
 
-#include <blue/core/bstr.h>
+#include <fx/core/bstr.h>
 #include <mie/attribute/attribute-definition.h>
 #include <mie/attribute/attribute.h>
 #include <mie/ctx.h>
@@ -17,28 +17,28 @@ static enum mie_status print(
 	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);
+		fx_stream_write_string(out->p_stream, "#builtin.float<", NULL);
 	}
 
 	switch (float_ty->f_width) {
 	case MIE_FLOAT_32:
-		b_stream_write_fmt(
+		fx_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(
+		fx_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(
+		fx_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);
+		fx_stream_write_string(out->p_stream, ">", NULL);
 	}
 
 	return MIE_SUCCESS;
@@ -59,7 +59,7 @@ static enum mie_status parse(
 	}
 
 	const struct mie_type *type = NULL;
-	if (!mie_parser_parse_type(ctx, &type)) {
+	if (!mie_parser_parse_type(ctx, NULL, &type, NULL)) {
 		return MIE_ERR_BAD_SYNTAX;
 	}
 

mie/dialect/builtin/attribute/int.c

@@ -1,6 +1,6 @@
 #include "../int.h"
 
-#include <blue/core/bstr.h>
+#include <fx/core/bstr.h>
 #include <mie/attribute/attribute-definition.h>
 #include <mie/attribute/attribute.h>
 #include <mie/ctx.h>
@@ -18,32 +18,32 @@ static enum mie_status print(
 	bool abbrev = ((out->p_flags & MIE_PRINT_F_ABBREVIATED) != 0);
 
 	if (!abbrev) {
-		b_stream_write_string(out->p_stream, "#builtin.int<", NULL);
+		fx_stream_write_string(out->p_stream, "#builtin.int<", NULL);
 	}
 
 	if (int_ty->i_width <= 64) {
-		b_stream_write_fmt(
+		fx_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);
+		fx_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);
+		fx_stream_write_string(out->p_stream, " : ", NULL);
 
 		if (abbrev) {
-			b_stream_write_fmt(
+			fx_stream_write_fmt(
 				out->p_stream, NULL, "i%zu", int_ty->i_width);
 		} else {
-			b_stream_write_fmt(
+			fx_stream_write_fmt(
 				out->p_stream, NULL, "!builtin.int<%zu>",
 				int_ty->i_width);
 		}
 	}
 
 	if (!abbrev) {
-		b_stream_write_string(out->p_stream, ">", NULL);
+		fx_stream_write_string(out->p_stream, ">", NULL);
 	}
 
 	return MIE_SUCCESS;
@@ -64,7 +64,7 @@ static enum mie_status parse(
 
 	if (!mie_parser_parse_symbol(ctx, MIE_SYM_COLON)) {
 		width = 64;
-	} else if (!mie_parser_parse_type(ctx, &type)) {
+	} else if (!mie_parser_parse_type(ctx, NULL, &type, NULL)) {
 		return false;
 	} else {
 		width = mie_int_type_get_width(type);

mie/dialect/builtin/attribute/string.c

@@ -11,9 +11,9 @@ static enum mie_status print(
 {
 	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);
+		fx_stream_write_fmt(out->p_stream, NULL, "\"%s\"", str->str_val);
 	} else {
-		b_stream_write_fmt(
+		fx_stream_write_fmt(
 			out->p_stream, NULL, "#builtin.string<\"%s\">",
 			str->str_val);
 	}
@@ -23,14 +23,14 @@ static enum mie_status print(
 static enum mie_status parse(
 	struct mie_parser *ctx, const struct mie_attribute **out)
 {
-	b_string *str = mie_parser_get_tempstr(ctx);
+	fx_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));
+		mie_parser_get_mie_ctx(ctx), fx_string_ptr(str));
 
 	if (!v) {
 		return MIE_ERR_NO_MEMORY;

mie/dialect/builtin/attribute/type.c

@@ -30,13 +30,13 @@ static enum mie_status print(
 	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);
+		fx_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, '>');
+		fx_stream_write_char(out->p_stream, '>');
 	}
 
 	return MIE_SUCCESS;
@@ -53,7 +53,7 @@ static enum mie_status parse(
 
 	const struct mie_type *type = NULL;
 
-	if (!mie_parser_parse_type(ctx, &type)) {
+	if (!mie_parser_parse_type(ctx, NULL, &type, NULL)) {
 		free(ty);
 		return MIE_ERR_BAD_FORMAT;
 	}

mie/dialect/builtin/builtin.c

@@ -1,4 +1,6 @@
 #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>
@@ -81,20 +83,26 @@ struct mie_attribute *mie_ctx_get_index(struct mie_ctx *ctx, size_t val)
 		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_ADD_OP(mie_builtin_module);
+	MIE_DIALECT_DIAG_CLASS_LIST(mie_builtin_diag);
-	MIE_DIALECT_ADD_TYPE(mie_builtin_string);
+	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_ATTRIBUTE(mie_builtin_string);
+	MIE_DIALECT_ADD_TYPE(mie_builtin_string);
+	MIE_DIALECT_ADD_TYPE(mie_builtin_memref);
 	MIE_DIALECT_ADD_ATTRIBUTE(mie_builtin_int);
 	MIE_DIALECT_ADD_ATTRIBUTE(mie_builtin_float);
-	MIE_DIALECT_ADD_ATTRIBUTE(mie_builtin_array);
 	MIE_DIALECT_ADD_ATTRIBUTE(mie_builtin_type);
-	MIE_DIALECT_ADD_TRAIT(mie_builtin_isolated_from_above);
+	MIE_DIALECT_ADD_ATTRIBUTE(mie_builtin_string);
-	MIE_DIALECT_ADD_TRAIT(mie_builtin_symbol_table);
 	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,99 @@
+#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(UNEXPECTED_TOKEN, ERROR, "Unexpected token")
+	MIE_DIAG_CLASS(UNRESOLVED_TYPE, ERROR, "Unresolved type")
+	MIE_DIAG_CLASS(UNRESOLVED_VALUE, ERROR, "Unresolved value")
+	MIE_DIAG_CLASS(UNRESOLVED_SUCCESSOR, ERROR, "Unresolved successor")
+	MIE_DIAG_CLASS(UNKNOWN_OP, ERROR, "Unknown op")
+	MIE_DIAG_CLASS(
+		OP_REQUIRES_PARENT_SCOPE, ERROR, "Op requires parent scope")
+	MIE_DIAG_CLASS(
+		INCORRECT_NUMBER_OF_RESULTS, ERROR,
+		"Incorrect number of results")
+	MIE_DIAG_CLASS(
+		INCORRECT_NUMBER_OF_ARGUMENTS, ERROR,
+		"Incorrect number of arguments")
+	MIE_DIAG_CLASS(
+		INCORRECT_NUMBER_OF_TYPES, ERROR, "Incorrect number of types")
+	MIE_DIAG_CLASS(INCORRECT_TYPE, ERROR, "Incorrect type")
+	MIE_DIAG_CLASS(INVALID_TYPE, ERROR, "Invalid type")
+	MIE_DIAG_CLASS(NAME_ALREADY_IN_USE, ERROR, "Name already in use")
+	MIE_DIAG_CLASS(INTERNAL_ERROR, ERROR, "Internal error")
+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(UNEXPECTED_TOKEN, "encountered an unexpected token.")
+	MIE_DIAG_MSG(UNRESOLVED_VALUE, "cannot resolve this value reference.")
+	MIE_DIAG_MSG(
+		UNRESOLVED_BUILTIN_TYPE,
+		"cannot resolve this builtin type reference.")
+	MIE_DIAG_MSG(
+		UNRESOLVED_DIALECT_TYPE,
+		"cannot resolve this dialect type 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(UNKNOWN_OP, "encountered an unknown operation.")
+	MIE_DIAG_MSG(
+		OP_REQUIRES_PARENT_SCOPE,
+		"this operation requires a parent scope.")
+	MIE_DIAG_MSG(
+		OP_PARENT_SCOPE_EXAMPLE,
+		"operations that require a parent scope cannot be used as a "
+		"top-level operation. try wrapping this operation in a "
+		"[blue]module[reset].")
+	MIE_DIAG_MSG(
+		USE_GENERIC_OP_SYNTAX,
+		"if this op belongs to an unknown dialect, you can use generic "
+		"op syntax to represent it.")
+	MIE_DIAG_MSG(
+		OP_HAS_NO_PARSER,
+		"this operation has no associated parser functionality.")
+	MIE_DIAG_MSG(
+		DIALECT_INTERNAL_ERROR,
+		"this error is caused by an internal problem with the relevant "
+		"dialect. please report the issue to the dialect vendor.")
+	MIE_DIAG_MSG(
+		COMPILER_INTERNAL_ERROR,
+		"this error is caused by an internal compiler issue. please "
+		"report the issue to the compiler vendor.")
+	MIE_DIAG_MSG(
+		NR_RESULT_NAME_OUTPUT_MISMATCH,
+		"the number of [red]output value names[reset] does not match "
+		"the number of results.")
+	MIE_DIAG_MSG(
+		OP_INCORRECT_NUMBER_OF_ARGS,
+		"this operation does not have the correct number of arguments.")
+	MIE_DIAG_MSG(
+		OP_NR_TYPES_DOESNT_MATCH_NR_ARGS,
+		"the number of types specified does not match the number of "
+		"arguments.")
+	MIE_DIAG_MSG(
+		OP_NR_TYPES_DOESNT_MATCH_NR_RESULTS,
+		"the number of types specified does not match the number of "
+		"results.")
+MIE_DIAG_MSG_LIST_END(mie_builtin_msg)

mie/dialect/builtin/index-cache.c

@@ -1,21 +1,21 @@
-#include <blue/core/btree.h>
+#include <fx/core/bst.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;
+	fx_bst_node e_node;
 	struct mie_index e_value;
 };
 
 struct mie_index_cache {
-	b_btree c_entries;
+	fx_bst c_entries;
 };
 
-static B_BTREE_DEFINE_SIMPLE_INSERT(
+static FX_BST_DEFINE_SIMPLE_INSERT(
 	struct index_cache_entry, e_node, e_value.i_value, put_index);
-static B_BTREE_DEFINE_SIMPLE_GET(
+static FX_BST_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(
@@ -48,13 +48,13 @@ struct mie_index_cache *mie_index_cache_create(void)
 
 void mie_index_cache_destroy(struct mie_index_cache *cache)
 {
-	b_btree_node *cur = b_btree_first(&cache->c_entries);
+	fx_bst_node *cur = fx_bst_first(&cache->c_entries);
 	while (cur) {
-		b_btree_node *next = b_btree_next(cur);
+		fx_bst_node *next = fx_bst_next(cur);
-		b_btree_delete(&cache->c_entries, cur);
+		fx_bst_delete(&cache->c_entries, cur);
 
 		struct index_cache_entry *entry
-			= b_unbox(struct index_cache_entry, cur, e_node);
+			= fx_unbox(struct index_cache_entry, cur, e_node);
 		free(entry);
 
 		cur = next;

mie/dialect/builtin/op/module.c

@@ -1,29 +1,44 @@
+#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/parse/parser.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, ' ');
+	fx_stream_write_char(out->p_stream, ' ');
-	if (MIE_VECTOR_COUNT(op->op_regions) == 0) {
-		return MIE_SUCCESS;
-	}
 
-	struct mie_region *region = &op->op_regions.items[0];
+	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)
+static enum mie_status parse(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out)
 {
+	struct mie_region *region = mie_op_add_region(out);
+	if (mie_parser_peek_symbol(parser) != MIE_SYM_LEFT_BRACE) {
+		mie_parser_report_unexpected_token_s(
+			parser, "region", "module body");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_region(parser, out, region, NULL)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
 	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

@@ -1,12 +1,12 @@
-#include <blue/core/btree.h>
+#include <fx/core/bst.h>
-#include <blue/ds/hashmap.h>
+#include <fx/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;
+	fx_hashmap *c_entries;
 };
 
 static struct mie_string *mie_string_create(
@@ -19,7 +19,7 @@ static struct mie_string *mie_string_create(
 
 	out->str_base.a_def
 		= mie_ctx_get_attribute_definition(ctx, "builtin", "string");
-	out->str_val = b_strdup(s);
+	out->str_val = fx_strdup(s);
 	if (!out->str_val) {
 		return NULL;
 	}
@@ -42,8 +42,8 @@ struct mie_string_cache *mie_string_cache_create(void)
 
 	memset(out, 0x0, sizeof *out);
 
-	out->c_entries = b_hashmap_create(
+	out->c_entries = fx_hashmap_create(
-		NULL, (b_hashmap_value_destructor)mie_string_destroy);
+		NULL, (fx_hashmap_value_destructor)mie_string_destroy);
 	if (!out->c_entries) {
 		free(out);
 		return NULL;
@@ -54,7 +54,7 @@ struct mie_string_cache *mie_string_cache_create(void)
 
 void mie_string_cache_destroy(struct mie_string_cache *cache)
 {
-	b_hashmap_unref(cache->c_entries);
+	fx_hashmap_unref(cache->c_entries);
 	free(cache);
 }
 
@@ -62,8 +62,8 @@ 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};
+	fx_hashmap_key key = {.key_data = s, .key_size = s_len};
-	const b_hashmap_value *value = b_hashmap_get(cache->c_entries, &key);
+	const fx_hashmap_value *value = fx_hashmap_get(cache->c_entries, &key);
 	if (value) {
 		return value->value_data;
 	}
@@ -73,8 +73,8 @@ struct mie_string *mie_string_cache_get(
 		return NULL;
 	}
 
-	b_hashmap_value new_val = {.value_data = str, .value_size = sizeof *str};
+	fx_hashmap_value new_val = {.value_data = str, .value_size = sizeof *str};
-	b_hashmap_put(cache->c_entries, &key, &new_val);
+	fx_hashmap_put(cache->c_entries, &key, &new_val);
 
 	return str;
 }

mie/dialect/builtin/type/float.c

@@ -1,6 +1,6 @@
 #include "../float.h"
 
-#include <blue/core/bstr.h>
+#include <fx/core/bstr.h>
 #include <mie/ctx.h>
 #include <mie/dialect/builtin.h>
 #include <mie/dialect/dialect.h>
@@ -17,16 +17,16 @@ struct mie_type *mie_ctx_get_float_type(struct mie_ctx *ctx, size_t bit_width)
 		return NULL;
 	}
 
-	b_rope rope_i = B_ROPE_CHAR('f'), rope_width = B_ROPE_UINT(bit_width);
+	fx_rope rope_i = FX_ROPE_CHAR('f'), rope_width = FX_ROPE_UINT(bit_width);
-	b_rope type_name;
+	fx_rope type_name;
-	b_rope_concat(&type_name, &rope_i, &rope_width);
+	fx_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);
+		return fx_unbox(struct mie_type, target, ty_id);
 	}
 
 	struct float_type *type = (struct float_type *)mie_type_create(type_info);
@@ -34,7 +34,7 @@ struct mie_type *mie_ctx_get_float_type(struct mie_ctx *ctx, size_t bit_width)
 		return NULL;
 	}
 
-	type->f_base.ty_name = b_bstr_fmt(NULL, "builtin.float<%zu>", bit_width);
+	type->f_base.ty_name = fx_bstr_fmt(NULL, "builtin.float<%zu>", bit_width);
 	type->f_base.ty_instance_size = sizeof(struct mie_float);
 	type->f_width = bit_width;
 
@@ -59,7 +59,7 @@ size_t mie_float_type_get_width(const struct mie_type *type)
 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(
+	fx_stream_write_fmt(
 		out->p_stream, NULL,
 		(out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "f%zu" : "!builtin.float<%zu>",
 		float_type->f_width);

mie/dialect/builtin/type/int.c

@@ -1,6 +1,6 @@
 #include "../int.h"
 
-#include <blue/core/bstr.h>
+#include <fx/core/bstr.h>
 #include <mie/ctx.h>
 #include <mie/dialect/builtin.h>
 #include <mie/dialect/dialect.h>
@@ -17,16 +17,16 @@ struct mie_type *mie_ctx_get_int_type(struct mie_ctx *ctx, size_t bit_width)
 		return NULL;
 	}
 
-	b_rope rope_i = B_ROPE_CHAR('i'), rope_width = B_ROPE_UINT(bit_width);
+	fx_rope rope_i = FX_ROPE_CHAR('i'), rope_width = FX_ROPE_UINT(bit_width);
-	b_rope type_name;
+	fx_rope type_name;
-	b_rope_concat(&type_name, &rope_i, &rope_width);
+	fx_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);
+		return fx_unbox(struct mie_type, target, ty_id);
 	}
 
 	struct int_type *type = (struct int_type *)mie_type_create(type_info);
@@ -34,7 +34,7 @@ struct mie_type *mie_ctx_get_int_type(struct mie_ctx *ctx, size_t bit_width)
 		return NULL;
 	}
 
-	type->i_base.ty_name = b_bstr_fmt(NULL, "builtin.int<%zu>", bit_width);
+	type->i_base.ty_name = fx_bstr_fmt(NULL, "builtin.int<%zu>", bit_width);
 	type->i_base.ty_instance_size = sizeof(struct mie_int);
 	type->i_width = bit_width;
 
@@ -59,7 +59,7 @@ size_t mie_int_type_get_width(const struct mie_type *type)
 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(
+	fx_stream_write_fmt(
 		out->p_stream, NULL,
 		(out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "i%zu"
 							 : "!builtin.int<%zu>",

mie/dialect/builtin/type/memref.c

@@ -0,0 +1,290 @@
+#include <fx/core/bstr.h>
+#include <mie/ctx.h>
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/dialect.h>
+#include <mie/dialect/memref.h>
+#include <mie/macros.h>
+#include <mie/parse/parser.h>
+#include <mie/print/printer.h>
+#include <mie/type/type-definition.h>
+#include <mie/type/type.h>
+
+struct memref_type {
+	struct mie_type m_base;
+	MIE_VECTOR_DECLARE(struct mie_memref_rank, m_rank);
+};
+
+struct mie_type *mie_ctx_get_memref_type(
+	struct mie_ctx *ctx, const struct mie_memref_rank *ranks, size_t nr_ranks)
+{
+	struct mie_type_definition *type_info
+		= mie_ctx_get_type_definition(ctx, "builtin", "memref");
+	if (!type_info) {
+		return NULL;
+	}
+
+	struct mie_id_builder id_ctx;
+	mie_id_builder_begin(&id_ctx, mie_id_map_get_ns(&ctx->ctx_types));
+	mie_id_builder_add_cstr(&id_ctx, "memref");
+
+	for (size_t i = 0; i < nr_ranks; i++) {
+		switch (ranks[i].r_ranktype) {
+		case MIE_MEMREF_RANK_UNKNOWN:
+			mie_id_builder_add_char(&id_ctx, '?');
+			break;
+		case MIE_MEMREF_RANK_TYPE:
+			mie_id_builder_add_id(&id_ctx, &ranks[i].r_type->ty_id);
+			break;
+		case MIE_MEMREF_RANK_STATIC:
+			mie_id_builder_add_int(&id_ctx, ranks[i].r_static);
+			break;
+		default:
+			return NULL;
+		}
+	}
+
+	mie_id id;
+	mie_id_builder_end(&id_ctx, &id);
+
+	mie_id *target = mie_id_map_get(&ctx->ctx_types, &id);
+	if (target) {
+		return fx_unbox(struct mie_type, target, ty_id);
+	}
+
+	struct memref_type *type
+		= (struct memref_type *)mie_type_create(type_info);
+	if (!type) {
+		return NULL;
+	}
+
+	fx_bstr type_name;
+	fx_bstr_begin_dynamic(&type_name);
+	fx_bstr_write_cstr(&type_name, "builtin.memref<", NULL);
+
+	struct mie_printer printer;
+	mie_printer_init(
+		&printer, ctx, (fx_stream *)&type_name, MIE_PRINT_F_ABBREVIATED);
+
+	for (size_t i = 0; i < nr_ranks; i++) {
+		mie_vector_push_back(type->m_rank, &ranks[i], NULL);
+
+		if (i > 0) {
+			fx_bstr_write_char(&type_name, '*');
+		}
+
+		switch (ranks[i].r_ranktype) {
+		case MIE_MEMREF_RANK_UNKNOWN:
+			fx_bstr_write_char(&type_name, '?');
+			break;
+		case MIE_MEMREF_RANK_TYPE:
+			mie_printer_print_type(&printer, ranks[i].r_type);
+			break;
+		case MIE_MEMREF_RANK_STATIC:
+			fx_bstr_write_fmt(&type_name, NULL, "%zu", ranks[i].r_static);
+			break;
+		default:
+			break;
+		}
+	}
+
+	fx_bstr_write_char(&type_name, '>');
+	type->m_base.ty_name = fx_bstr_end(&type_name);
+	type->m_base.ty_instance_size = 0;
+	fx_rope name_rope = FX_ROPE_CSTR(type->m_base.ty_name);
+
+	mie_id_map_put(&ctx->ctx_types, &type->m_base.ty_id, &name_rope);
+	return (struct mie_type *)type;
+}
+
+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)
+{
+	const struct memref_type *memref_ty = (const struct memref_type *)ty;
+	fx_stream_write_string(
+		out->p_stream,
+		(out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "memref"
+							 : "builtin.memref",
+		NULL);
+
+	fx_stream_write_char(out->p_stream, '<');
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(memref_ty->m_rank); i++) {
+		const struct mie_memref_rank *rank = &memref_ty->m_rank.items[i];
+
+		if (i > 0) {
+			fx_stream_write_char(out->p_stream, '*');
+		}
+
+		switch (rank->r_ranktype) {
+		case MIE_MEMREF_RANK_UNKNOWN:
+			fx_stream_write_char(out->p_stream, '?');
+			break;
+		case MIE_MEMREF_RANK_TYPE:
+			mie_printer_print_type(out, rank->r_type);
+			break;
+		case MIE_MEMREF_RANK_STATIC:
+			fx_stream_write_fmt(
+				out->p_stream, NULL, "%zu", rank->r_static);
+			break;
+		default:
+			break;
+		}
+	}
+	fx_stream_write_char(out->p_stream, '>');
+
+	return MIE_SUCCESS;
+}
+
+static bool parse_rank(struct mie_parser *parser, struct mie_memref_rank *out)
+{
+	enum mie_token_type tok_type = mie_parser_peek_type(parser);
+	struct mie_parser_item expected_tokens[] = {
+		MIE_PARSE_ITEM_TOKEN(MIE_TOK_TYPENAME),
+		MIE_PARSE_ITEM_TOKEN(MIE_TOK_INT),
+		MIE_PARSE_ITEM_TOKEN(MIE_SYM_QUESTION),
+		MIE_PARSE_ITEM_NONE,
+	};
+
+	long long v;
+
+	switch (tok_type) {
+	case MIE_TOK_INT:
+		out->r_ranktype = MIE_MEMREF_RANK_STATIC;
+		out->r_type = mie_ctx_get_type(
+			mie_parser_get_mie_ctx(parser), "builtin", "index");
+		mie_parser_parse_int(parser, &v, &out->r_span);
+		out->r_static = v;
+		break;
+	case MIE_TOK_SYMBOL:
+		switch (mie_parser_peek_symbol(parser)) {
+		case MIE_SYM_QUESTION:
+			out->r_span = mie_parser_peek(parser)->tok_location;
+			mie_parser_parse_symbol(parser, MIE_SYM_QUESTION);
+			out->r_ranktype = MIE_MEMREF_RANK_UNKNOWN;
+			break;
+		case MIE_SYM_LEFT_PAREN:
+			out->r_ranktype = MIE_MEMREF_RANK_TYPE;
+			if (!mie_parser_parse_type(
+				    parser, "memref type rank", &out->r_type,
+				    &out->r_span)) {
+				return false;
+			}
+			break;
+		default:
+			mie_parser_report_unexpected_token_v(
+				parser, expected_tokens, "memref rank");
+			return false;
+		}
+		break;
+	case MIE_TOK_WORD:
+	case MIE_TOK_TYPENAME:
+		out->r_ranktype = MIE_MEMREF_RANK_TYPE;
+		if (!mie_parser_parse_type(
+			    parser, "memref type rank", &out->r_type, &out->r_span)) {
+			return false;
+		}
+		break;
+	default:
+		mie_parser_report_unexpected_token_v(
+			parser, expected_tokens, "memref rank");
+		return false;
+	}
+	return true;
+}
+
+static bool parse_ranks(
+	struct mie_parser *parser,
+	MIE_VECTOR_REF_PARAM(struct mie_memref_rank, ranks))
+{
+	struct mie_memref_rank rank;
+	if (!parse_rank(parser, &rank)) {
+		return false;
+	}
+
+	mie_vector_ref_push_back(ranks, &rank, NULL);
+
+	while (1) {
+		if (mie_parser_peek_symbol(parser) == MIE_SYM_RIGHT_ANGLE) {
+			break;
+		}
+
+		if (!mie_parser_parse_symbol(parser, MIE_SYM_ASTERISK)) {
+			mie_parser_report_unexpected_token(
+				parser, MIE_SYM_ASTERISK, "memref rank list");
+			return false;
+		}
+
+		if (!parse_rank(parser, &rank)) {
+			return false;
+		}
+
+		mie_vector_ref_push_back(ranks, &rank, NULL);
+	}
+
+	return true;
+}
+
+static enum mie_status parse(struct mie_parser *parser, const struct mie_type **out)
+{
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_LEFT_ANGLE)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_LEFT_ANGLE, "memref type");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	MIE_VECTOR_DEFINE(struct mie_memref_rank, ranks);
+	if (!parse_ranks(parser, MIE_VECTOR_REF(ranks))) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_RIGHT_ANGLE)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_RIGHT_ANGLE, "memref type");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	const struct mie_type *type = mie_ctx_get_memref_type(
+		mie_parser_get_mie_ctx(parser), ranks.items, ranks.count);
+	mie_vector_destroy(ranks, NULL);
+
+	*out = type;
+	return MIE_SUCCESS;
+}
+
+size_t mie_memref_type_get_nr_ranks(const struct mie_type *type)
+{
+	if (!mie_type_is(type, "builtin", "memref")) {
+		return 0;
+	}
+
+	const struct memref_type *memref = (const struct memref_type *)type;
+	return MIE_VECTOR_COUNT(memref->m_rank);
+}
+
+const struct mie_memref_rank *mie_memref_type_get_rank(
+	const struct mie_type *type, size_t i)
+{
+	if (!mie_type_is(type, "builtin", "memref")) {
+		return 0;
+	}
+
+	const struct memref_type *memref = (const struct memref_type *)type;
+	if (i >= MIE_VECTOR_COUNT(memref->m_rank)) {
+		return NULL;
+	}
+
+	return &memref->m_rank.items[i];
+}
+
+const struct mie_memref_rank *mie_memref_type_get_rank(
+	const struct mie_type *type, size_t i);
+
+MIE_TYPE_DEFINITION_BEGIN(mie_builtin_memref, "memref")
+	MIE_TYPE_DEFINITION_INIT(type_init);
+	MIE_TYPE_DEFINITION_STRUCT(struct memref_type);
+	MIE_TYPE_DEFINITION_PRINT(print);
+	MIE_TYPE_DEFINITION_PARSE(parse);
+MIE_TYPE_DEFINITION_END()

mie/dialect/builtin/type/string.c

@@ -1,4 +1,4 @@
-#include <blue/core/bstr.h>
+#include <fx/core/bstr.h>
 #include <mie/ctx.h>
 #include <mie/dialect/builtin.h>
 #include <mie/dialect/dialect.h>
@@ -15,7 +15,7 @@ static void type_init(
 
 static enum mie_status print(const struct mie_type *ty, struct mie_printer *out)
 {
-	b_stream_write_string(
+	fx_stream_write_string(
 		out->p_stream,
 		(out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "str" : "!builtin.string",
 		NULL);

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

@@ -1,7 +1,10 @@
+#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/parse/parser.h>
 #include <mie/print/printer.h>
 
 static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
@@ -18,21 +21,134 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
 	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, ' ');
+	fx_stream_write_char(printer->p_stream, ' ');
 	mie_printer_print_op_arg(printer, cond, false);
-	b_stream_write_string(printer->p_stream, ", ", NULL);
+	fx_stream_write_string(printer->p_stream, ", ", NULL);
 	mie_printer_print_op_successor(printer, if_true, true);
-	b_stream_write_string(printer->p_stream, ", ", NULL);
+	fx_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)
+static bool parse_successor(struct mie_parser *ctx, struct mie_op_successor *out)
 {
+	memset(out, 0x0, sizeof *out);
+	fx_string *str = mie_parser_get_tempstr(ctx);
+	bool result = false;
+
+	if (!mie_parser_parse_blockname(ctx, str, &out->s_name_span)) {
+		mie_parser_report_unexpected_token(
+			ctx, MIE_TOK_BLOCKNAME, "branch destination");
+		return false;
+	}
+
+	out->s_block_name = fx_string_steal(str);
+
+	if (mie_parser_peek_type(ctx) == MIE_TOK_LINEFEED
+	    || mie_parser_peek_symbol(ctx) == MIE_SYM_COMMA) {
+		goto ok;
+	}
+
+	if (!mie_parser_parse_symbol(ctx, MIE_SYM_LEFT_PAREN)) {
+		struct mie_parser_item expected[] = {
+			MIE_PARSE_ITEM_TOKEN(MIE_SYM_COMMA),
+			MIE_PARSE_ITEM_TOKEN(MIE_SYM_LEFT_PAREN),
+			MIE_PARSE_ITEM_TOKEN(MIE_TOK_LINEFEED),
+			MIE_PARSE_ITEM_NONE,
+		};
+
+		mie_parser_report_unexpected_token_v(
+			ctx, expected, "branch destination/arguments");
+		goto fail;
+	}
+
+	if (!mie_parser_parse_parameter_list(
+		    ctx, true, MIE_VECTOR_REF(out->s_args),
+		    "branch successor arguments")) {
+		goto fail;
+	}
+
+	if (!mie_parser_parse_symbol(ctx, MIE_SYM_RIGHT_PAREN)) {
+		mie_parser_report_unexpected_token(
+			ctx, MIE_SYM_RIGHT_PAREN, "branch arguments");
+		goto fail;
+	}
+
+ok:
+	return true;
+
+fail:
+	if (out->s_block_name) {
+		free(out->s_block_name);
+		out->s_block_name = NULL;
+	}
+
+	if (MIE_VECTOR_MAX(out->s_args) > 0) {
+		mie_vector_destroy(out->s_args, NULL);
+	}
+
+	return false;
+}
+
+static enum mie_status parse(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out)
+{
+	struct mie_op_arg *cond = mie_op_add_arg(out);
+	struct mie_file_span span;
+	if (!mie_parser_parse_parameter(
+		    parser, false, cond, "branch condition")) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_COMMA)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_COMMA, "branch destination list");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	struct mie_op_successor *true_branch
+		= mie_vector_emplace_back(out->op_successors, NULL);
+	if (!parse_successor(parser, true_branch)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_COMMA)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_COMMA, "branch destination list");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	struct mie_op_successor *false_branch
+		= mie_vector_emplace_back(out->op_successors, NULL);
+	if (!parse_successor(parser, false_branch)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	cond->arg_unresolved.reg_type
+		= mie_ctx_get_int_type(mie_parser_get_mie_ctx(parser), 1);
+
 	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/dialect/cf/op/br.c

@@ -1,13 +1,15 @@
 #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/parse/parser.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, ' ');
+	fx_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);
@@ -15,11 +17,96 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
 	return MIE_SUCCESS;
 }
 
-static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+static bool parse_successor(struct mie_parser *ctx, struct mie_op_successor *out)
 {
+	memset(out, 0x0, sizeof *out);
+	fx_string *str = mie_parser_get_tempstr(ctx);
+	bool result = false;
+
+	if (!mie_parser_parse_blockname(ctx, str, &out->s_name_span)) {
+		mie_parser_report_unexpected_token(
+			ctx, MIE_TOK_BLOCKNAME, "branch destination");
+		return false;
+	}
+
+	out->s_block_name = fx_string_steal(str);
+
+	if (mie_parser_peek_type(ctx) == MIE_TOK_LINEFEED) {
+		goto ok;
+	}
+
+	if (!mie_parser_parse_symbol(ctx, MIE_SYM_LEFT_PAREN)) {
+		struct mie_parser_item expected[] = {
+			MIE_PARSE_ITEM_TOKEN(MIE_TOK_LINEFEED),
+			MIE_PARSE_ITEM_TOKEN(MIE_SYM_LEFT_PAREN),
+			MIE_PARSE_ITEM_NONE,
+		};
+
+		mie_parser_report_unexpected_token_v(
+			ctx, expected, "branch destination/arguments");
+		goto fail;
+	}
+
+	if (!mie_parser_parse_parameter_list(
+		    ctx, true, MIE_VECTOR_REF(out->s_args),
+		    "branch successor arguments")) {
+		goto fail;
+	}
+
+	if (!mie_parser_parse_symbol(ctx, MIE_SYM_RIGHT_PAREN)) {
+		mie_parser_report_unexpected_token(
+			ctx, MIE_SYM_RIGHT_PAREN, "branch arguments");
+		goto fail;
+	}
+
+ok:
+	return true;
+
+fail:
+	if (out->s_block_name) {
+		free(out->s_block_name);
+		out->s_block_name = NULL;
+	}
+
+	if (MIE_VECTOR_MAX(out->s_args) > 0) {
+		mie_vector_destroy(out->s_args, NULL);
+	}
+
+	return false;
+}
+
+static enum mie_status parse(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out)
+{
+	struct mie_op_successor *s
+		= mie_vector_emplace_back(out->op_successors, NULL);
+	if (!s) {
+		return MIE_ERR_NO_MEMORY;
+	}
+
+	if (!parse_successor(parser, s)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
 	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/dialect/dialect.c

@@ -1,4 +1,4 @@
-#include <blue/ds/string.h>
+#include <fx/ds/string.h>
 #include <mie/ctx.h>
 #include <mie/dialect/dialect.h>
 #include <mie/ir/op-definition.h>
@@ -37,7 +37,7 @@ struct mie_dialect *mie_dialect_create(
 
 	memset(out, 0x0, size);
 
-	out->d_name = b_strdup(name);
+	out->d_name = fx_strdup(name);
 	if (!out->d_name) {
 		free(out);
 		return NULL;
@@ -58,7 +58,7 @@ struct mie_dialect *mie_dialect_create(
 	mie_id interface_ns = INTERFACE_NS_ID;
 	mie_id_map_init(&out->d_interfaces, &interface_ns);
 
-	b_rope name_rope = B_ROPE_CSTR(name);
+	fx_rope name_rope = FX_ROPE_CSTR(name);
 	mie_id_map_put(&ctx->ctx_dialects, &out->d_id, &name_rope);
 
 	return out;
@@ -67,21 +67,21 @@ struct mie_dialect *mie_dialect_create(
 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);
+	fx_rope name_rope = FX_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);
+	return fx_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);
+	fx_rope name_rope = FX_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);
+	return fx_unbox(struct mie_type_definition, target, ty_id);
 }

mie/dialect/func/func.c

@@ -3,6 +3,7 @@
 #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

@@ -1,16 +1,18 @@
 #include <mie/attribute/attribute-map.h>
 #include <mie/ctx.h>
+#include <mie/diag/diag.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/builder.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/parse/parser.h>
 #include <mie/print/printer.h>
 #include <mie/type/function.h>
 
@@ -26,14 +28,14 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
 	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);
+	fx_stream_write_fmt(printer->p_stream, NULL, " @%s(", sym_name_cstr);
 
-	const struct mie_region *code = &op->op_regions.items[0];
+	const struct mie_region *code = mie_op_get_first_region(op);
-	const struct mie_block *entry = &code->r_blocks.items[0];
+	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);
+			fx_stream_write_string(printer->p_stream, ", ", NULL);
 		}
 
 		const struct mie_register *param = &entry->b_params.items[i];
@@ -41,15 +43,15 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
 		mie_printer_print_register(printer, param, MIE_PRINT_F_INCLUDE_TYPE);
 	}
 
-	b_stream_write_string(printer->p_stream, ") -> ", NULL);
+	fx_stream_write_string(printer->p_stream, ") -> ", NULL);
 
 	if (MIE_VECTOR_COUNT(function_ty->func_out) != 1) {
-		b_stream_write_char(printer->p_stream, '(');
+		fx_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);
+			fx_stream_write_string(printer->p_stream, ", ", NULL);
 		}
 
 		const struct mie_type *ty = function_ty->func_out.items[i];
@@ -58,10 +60,10 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
 	}
 
 	if (MIE_VECTOR_COUNT(function_ty->func_out) != 1) {
-		b_stream_write_char(printer->p_stream, ')');
+		fx_stream_write_char(printer->p_stream, ')');
 	}
 
-	b_stream_write_char(printer->p_stream, ' ');
+	fx_stream_write_char(printer->p_stream, ' ');
 
 	mie_printer_print_region(
 		printer, code, MIE_PRINT_F_EXCLUDE_FIRST_BLOCK_HEADER);
@@ -69,15 +71,132 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
 	return MIE_SUCCESS;
 }
 
-static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+static enum mie_status parse_return_type(
+	struct mie_parser *parser,
+	MIE_VECTOR_REF_PARAM(const struct mie_type *, out))
 {
+	bool ok = true;
+	if (mie_parser_peek_symbol(parser) == MIE_SYM_LEFT_PAREN) {
+		ok = mie_parser_parse_type_list(
+			parser, "function return type", MIE_VECTOR_REF2(out), NULL);
+	} else {
+		const struct mie_type *tmp;
+		ok = mie_parser_parse_type(
+			parser, "function return type", &tmp, NULL);
+
+		if (ok) {
+			mie_vector_ref_push_back(out, &tmp, NULL);
+		}
+	}
+
+	return ok ? MIE_SUCCESS : MIE_ERR_BAD_SYNTAX;
+}
+
+static enum mie_status parse(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out)
+{
+	if (!scope) {
+		struct mie_diag *diag = mie_parser_report_error_simple(
+			parser, "builtin", MIE_BUILTIN_E_OP_REQUIRES_PARENT_SCOPE,
+			MIE_BUILTIN_MSG_OP_REQUIRES_PARENT_SCOPE,
+			&out->op_name_span);
+		mie_diag_push_msg(
+			diag, mie_parser_get_mie_ctx(parser), "builtin",
+			MIE_BUILTIN_MSG_OP_PARENT_SCOPE_EXAMPLE);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	fx_string *temp = mie_parser_get_tempstr(parser);
+	if (!mie_parser_parse_symname(parser, temp, NULL)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_TOK_SYMNAME, "function signature");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	struct mie_attribute *sym_name = mie_ctx_get_string(
+		mie_parser_get_mie_ctx(parser), fx_string_ptr(temp));
+
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_LEFT_PAREN)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_LEFT_PAREN, "function parameter list");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	MIE_VECTOR_DEFINE(struct mie_op_arg, block_params);
+	MIE_VECTOR_DEFINE(const struct mie_type *, in_types);
+	MIE_VECTOR_DEFINE(const struct mie_type *, out_types);
+
+	if (!mie_parser_parse_parameter_list(
+		    parser, true, MIE_VECTOR_REF(block_params),
+		    "function parameter list")) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_RIGHT_PAREN)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_LEFT_PAREN, "function parameter list");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	struct mie_region *body = mie_op_add_region(out);
+	struct mie_block *entry = mie_region_add_block(body);
+
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(block_params); i++) {
+		struct mie_register *param_reg = mie_vector_emplace_back(
+			entry->b_params, &mie_register_vector_ops);
+
+		param_reg->reg_flags = block_params.items[i].arg_unresolved.reg_flags
+		                     | MIE_REGISTER_F_BLOCK_PARAM;
+		param_reg->reg_type = block_params.items[i].arg_unresolved.reg_type;
+		param_reg->reg_block = entry;
+		if (!mie_parser_scope_put_name(
+			    scope, &param_reg->reg_name,
+			    block_params.items[i].arg_unresolved.reg_name,
+			    MIE_NAME_MAP_F_STRICT)) {
+			return false;
+		}
+
+		mie_vector_push_back(in_types, &param_reg->reg_type, NULL);
+	}
+
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_HYPHEN_RIGHT_ANGLE)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_HYPHEN_RIGHT_ANGLE,
+			"function signature");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (parse_return_type(parser, MIE_VECTOR_REF(out_types)) != MIE_SUCCESS) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	const struct mie_type *func_type = mie_ctx_get_function_type(
+		mie_parser_get_mie_ctx(parser), in_types.items, in_types.count,
+		out_types.items, out_types.count);
+
+	mie_vector_destroy(in_types, NULL);
+	mie_vector_destroy(out_types, NULL);
+
+	struct mie_attribute *function_type
+		= mie_type_attr_create(mie_parser_get_mie_ctx(parser), func_type);
+
+	mie_attribute_map_put(
+		&out->op_attrib, "sym_name", sym_name, MIE_ATTRMAP_F_REPLACE);
+	mie_attribute_map_put(
+		&out->op_attrib, "function_type", function_type,
+		MIE_ATTRMAP_F_REPLACE);
+
+	if (!mie_parser_parse_region(parser, out, body, entry)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
 	return MIE_SUCCESS;
 }
 
-struct mie_op *mie_func_put_func(
+struct mie_op *mie_func_func_put(
-	struct mie_builder *builder, const char *name,
+	struct mie_emitter *e, const char *name, struct mie_func_parameter *params,
-	struct mie_func_parameter *params, size_t nr_params,
+	size_t nr_params, const struct mie_type **ret_types, size_t nr_ret_types)
-	const struct mie_type **ret_types, size_t nr_ret_types)
 {
 	const struct mie_type **param_types
 		= calloc(nr_params, sizeof *param_types);
@@ -90,7 +209,7 @@ struct mie_op *mie_func_put_func(
 	}
 
 	const struct mie_type *func_type = mie_ctx_get_function_type(
-		mie_builder_get_ctx(builder), param_types, nr_params, ret_types,
+		mie_emitter_get_ctx(e), param_types, nr_params, ret_types,
 		nr_ret_types);
 	free(param_types);
 
@@ -98,7 +217,7 @@ struct mie_op *mie_func_put_func(
 		return NULL;
 	}
 
-	struct mie_op *op = mie_builder_put_op(builder, "func", "func", NULL, 0);
+	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);
@@ -114,9 +233,9 @@ struct mie_op *mie_func_put_func(
 	}
 
 	struct mie_attribute *sym_name
-		= mie_ctx_get_string(mie_builder_get_ctx(builder), name);
+		= mie_ctx_get_string(mie_emitter_get_ctx(e), name);
 	struct mie_attribute *function_type
-		= mie_type_attr_create(mie_builder_get_ctx(builder), func_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);
@@ -130,6 +249,8 @@ struct mie_op *mie_func_put_func(
 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/dialect/func/op/return.c

@@ -9,26 +9,27 @@
 #include <mie/ir/op.h>
 #include <mie/ir/region.h>
 #include <mie/macros.h>
+#include <mie/parse/parser.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, ' ');
+	fx_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);
+			fx_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);
+	fx_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);
+			fx_stream_write_string(printer->p_stream, ", ", NULL);
 		}
 
 		mie_printer_print_type(
@@ -38,8 +39,81 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
 	return MIE_SUCCESS;
 }
 
-static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+static enum mie_status parse(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out)
 {
+	if (!mie_parser_parse_parameter_list(
+		    parser, false, MIE_VECTOR_REF(out->op_args),
+		    "function return values")) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_COLON)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_COLON, "function return type");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	MIE_VECTOR_DEFINE(const struct mie_type *, types);
+	const struct mie_type *tmp = NULL;
+	struct mie_file_span first_span, last_span;
+
+	if (!mie_parser_parse_type(
+		    parser, "function return type", &tmp, &first_span)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	mie_vector_push_back(types, &tmp, NULL);
+	bool ok = true;
+
+	while (1) {
+		if (mie_parser_peek_type(parser) == MIE_TOK_LINEFEED) {
+			break;
+		}
+
+		if (!mie_parser_parse_symbol(parser, MIE_SYM_COMMA)) {
+			struct mie_parser_item expected[] = {
+				MIE_PARSE_ITEM_TOKEN(MIE_SYM_COMMA),
+				MIE_PARSE_ITEM_TOKEN(MIE_TOK_LINEFEED),
+				MIE_PARSE_ITEM_NONE,
+			};
+
+			mie_parser_report_unexpected_token_v(
+				parser, expected, "function return type list");
+			ok = false;
+			break;
+		}
+
+		if (!mie_parser_parse_type(
+			    parser, "function return type", &tmp, &last_span)) {
+			ok = false;
+			break;
+		}
+
+		mie_vector_push_back(types, &tmp, NULL);
+	}
+
+	if (!ok) {
+		mie_vector_destroy(types, NULL);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (MIE_VECTOR_COUNT(types) != MIE_VECTOR_COUNT(out->op_args)) {
+		struct mie_file_span span = {
+			.s_start = first_span.s_start,
+			.s_end = last_span.s_end,
+		};
+		mie_parser_report_error_simple(
+			parser, "builtin", MIE_BUILTIN_E_INCORRECT_NUMBER_OF_TYPES,
+			MIE_BUILTIN_MSG_OP_NR_TYPES_DOESNT_MATCH_NR_ARGS, &span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(types); i++) {
+		out->op_args.items[i].arg_unresolved.reg_type = types.items[i];
+	}
+
 	return MIE_SUCCESS;
 }
 

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/memref/diag.c

@@ -0,0 +1,27 @@
+#include <mie/diag/class.h>
+#include <mie/diag/msg.h>
+#include <mie/dialect/memref.h>
+#include <mie/macros.h>
+
+#define MIE_DIAG_CLASS_PREFIX MIE_MEMREF_E
+#define MIE_DIAG_MSG_PREFIX   MIE_MEMREF_MSG
+
+MIE_DIAG_CLASS_LIST_BEGIN(mie_memref_diag)
+MIE_DIAG_CLASS_LIST_END(mie_memref_diag)
+
+MIE_DIAG_MSG_LIST_BEGIN(mie_memref_msg)
+	MIE_DIAG_MSG(
+		OP_EXPECTS_MEMREF_ARGUMENT,
+		"this operation requires a memref parameter.")
+	MIE_DIAG_MSG(
+		LAST_MEMREF_RANK_MUST_BE_TYPE,
+		"the last rank of a memref type must be a type.")
+	MIE_DIAG_MSG(
+		MEMREF_MUST_HAVE_AT_LEAST_ONE_RANK,
+		"memref type must have at least one rank.")
+	MIE_DIAG_MSG(
+		OP_RESULT_DETERMINED_BY_LAST_MEMREF_RANK,
+		"the number and type of operation results is determined by "
+	        "[blue]the "
+		"type of the last memref rank[reset].")
+MIE_DIAG_MSG_LIST_END(mie_memref_msg)

mie/dialect/memref/memref.c

@@ -1,3 +1,5 @@
+#include <mie/diag/class.h>
+#include <mie/diag/msg.h>
 #include <mie/dialect/dialect.h>
 #include <mie/dialect/memref.h>
 #include <mie/macros.h>
@@ -5,6 +7,11 @@
 #include <mie/type/type-definition.h>
 #include <mie/type/type.h>
 
+MIE_DIAG_CLASS_LIST_EXTERN(mie_memref_diag);
+MIE_DIAG_MSG_LIST_EXTERN(mie_memref_msg);
+
 MIE_DIALECT_BEGIN(mie_memref, struct mie_dialect, "memref")
-	MIE_DIALECT_ADD_TYPE(mie_memref_memref);
+	MIE_DIALECT_DIAG_CLASS_LIST(mie_memref_diag);
+	MIE_DIALECT_DIAG_MSG_LIST(mie_memref_msg);
+	MIE_DIALECT_ADD_OP(mie_memref_load);
 MIE_DIALECT_END()

mie/dialect/memref/op/load.c

@@ -0,0 +1,214 @@
+#include <mie/ctx.h>
+#include <mie/diag/diag.h>
+#include <mie/diag/highlight.h>
+#include <mie/dialect/builtin.h>
+#include <mie/dialect/memref.h>
+#include <mie/ir/op-definition.h>
+#include <mie/ir/op.h>
+#include <mie/macros.h>
+#include <mie/parse/parser.h>
+#include <mie/print/printer.h>
+#include <mie/type/storage.h>
+#include <mie/type/type.h>
+
+static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
+{
+	fx_stream_write_char(printer->p_stream, ' ');
+	const struct mie_type *memref_type = NULL;
+	if (MIE_VECTOR_COUNT(op->op_args) > 0) {
+		mie_printer_print_op_arg(printer, &op->op_args.items[0], false);
+		memref_type = mie_op_arg_get_type(&op->op_args.items[0]);
+	}
+
+	fx_stream_write_char(printer->p_stream, '[');
+
+	for (size_t i = 1; i < MIE_VECTOR_COUNT(op->op_args); i++) {
+		if (i > 1) {
+			fx_stream_write_string(printer->p_stream, ", ", NULL);
+		}
+
+		mie_printer_print_op_arg(printer, &op->op_args.items[i], false);
+	}
+	fx_stream_write_char(printer->p_stream, ']');
+
+	if (memref_type) {
+		fx_stream_write_string(printer->p_stream, " : ", NULL);
+		mie_printer_print_type(printer, memref_type);
+	}
+
+	return MIE_SUCCESS;
+}
+
+static bool parse_param_name(
+	struct mie_parser *ctx, struct mie_op_arg *out, const char *context)
+{
+	memset(out, 0x0, sizeof *out);
+	fx_string *str = mie_parser_get_tempstr(ctx);
+
+	struct mie_file_span loc;
+	if (mie_parser_parse_vregname(ctx, str, &loc)) {
+		out->arg_unresolved.reg_name = fx_string_steal(str);
+		out->arg_unresolved.reg_flags = MIE_REGISTER_F_VIRTUAL;
+	} else if (mie_parser_parse_mregname(ctx, str, &loc)) {
+		out->arg_unresolved.reg_name = fx_string_steal(str);
+		out->arg_unresolved.reg_flags = MIE_REGISTER_F_MACHINE;
+	} else {
+		struct mie_parser_item required[] = {
+			MIE_PARSE_ITEM_TOKEN(MIE_TOK_VREGNAME),
+			MIE_PARSE_ITEM_TOKEN(MIE_TOK_MREGNAME),
+			MIE_PARSE_ITEM_NONE,
+		};
+		mie_parser_report_unexpected_token_v(ctx, required, context);
+		return false;
+	}
+
+	out->arg_span = loc;
+
+	return true;
+}
+
+static bool apply_op_result_types(
+	const struct mie_op *op, const struct mie_type *result_type)
+{
+	size_t nr_results = 0;
+	if (!mie_type_is_storage(result_type)) {
+		if (MIE_VECTOR_COUNT(op->op_result) != 1) {
+			return false;
+		}
+
+		op->op_result.items[0].reg_type = result_type;
+		return true;
+	}
+
+	const struct mie_storage_type *storage
+		= (const struct mie_storage_type *)result_type;
+	nr_results = mie_storage_type_get_nr_parts(storage);
+
+	if (MIE_VECTOR_COUNT(op->op_result) != nr_results) {
+		return false;
+	}
+
+	for (size_t i = 0; i < nr_results; i++) {
+		op->op_result.items[i].reg_type = storage->st_parts.items[i];
+	}
+
+	return true;
+}
+
+static enum mie_status parse(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out)
+{
+	struct mie_op_arg *buf_arg = mie_op_add_arg(out);
+	if (!mie_parser_parse_parameter(
+		    parser, false, buf_arg, "memref load source")) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_LEFT_BRACKET)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_LEFT_BRACKET, "memref load index list");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_parameter_list(
+		    parser, false, MIE_VECTOR_REF(out->op_args),
+		    "memref load index")) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+#if 0
+	while (1) {
+		if (mie_parser_parse_symbol(parser, MIE_SYM_RIGHT_BRACKET)) {
+			break;
+		}
+
+		if (!mie_parser_parse_symbol(parser, MIE_SYM_COMMA)) {
+			unsigned int expected[] = {
+				MIE_SYM_COMMA,
+				MIE_SYM_RIGHT_BRACKET,
+				MIE_TOK_NONE,
+			};
+			mie_parser_report_unexpected_token_v(
+				parser, expected, "memref load index list");
+			return MIE_ERR_BAD_SYNTAX;
+		}
+
+		struct mie_op_arg *index_arg = mie_op_add_arg(out);
+		if (!parse_param_name(parser, index_arg, "memref load index")) {
+			return MIE_ERR_BAD_SYNTAX;
+		}
+	}
+#endif
+
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_RIGHT_BRACKET)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_RIGHT_BRACKET, "memref load index list");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_COLON)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_COLON, "memref type");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	const struct mie_type *type = NULL;
+	struct mie_file_span type_span;
+	if (!mie_parser_parse_type(parser, "memref type", &type, &type_span)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_type_is(type, "builtin", "memref")) {
+		mie_parser_report_error_simple(
+			parser, "builtin", MIE_BUILTIN_E_INCORRECT_TYPE,
+			MIE_MEMREF_MSG_OP_EXPECTS_MEMREF_ARGUMENT, &type_span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	size_t nr_ranks = mie_memref_type_get_nr_ranks(type);
+	if (!nr_ranks) {
+		mie_parser_report_error_simple(
+			parser, "builtin", MIE_BUILTIN_E_INVALID_TYPE,
+			MIE_MEMREF_MSG_MEMREF_MUST_HAVE_AT_LEAST_ONE_RANK,
+			&type_span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	const struct mie_memref_rank *type_rank
+		= mie_memref_type_get_rank(type, nr_ranks - 1);
+	if (type_rank->r_ranktype != MIE_MEMREF_RANK_TYPE) {
+		mie_parser_report_error_simple(
+			parser, "builtin", MIE_BUILTIN_E_INVALID_TYPE,
+			MIE_MEMREF_MSG_LAST_MEMREF_RANK_MUST_BE_TYPE,
+			&type_rank->r_span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!apply_op_result_types(out, type_rank->r_type)) {
+		struct mie_file_span results_span;
+		mie_op_get_results_span(out, &results_span);
+		struct mie_diag *diag = mie_parser_report_error_simple(
+			parser, "builtin",
+			MIE_BUILTIN_E_INCORRECT_NUMBER_OF_RESULTS,
+			MIE_BUILTIN_MSG_NR_RESULT_NAME_OUTPUT_MISMATCH,
+			&results_span);
+		mie_diag_push_msg(
+			diag, mie_parser_get_mie_ctx(parser), "memref",
+			MIE_MEMREF_MSG_OP_RESULT_DETERMINED_BY_LAST_MEMREF_RANK);
+		struct mie_diag_highlight hl[] = {
+			MIE_DIAG_HL(HINT, type_rank->r_span),
+		};
+		mie_diag_push_snippet(
+			diag, type_rank->r_span.s_start.c_row,
+			type_rank->r_span.s_end.c_row, NULL, 0, hl, 1);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	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

@@ -1,52 +0,0 @@
-#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/op/source-filename.c

@@ -7,7 +7,9 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
 	return MIE_SUCCESS;
 }
 
-static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+static enum mie_status parse(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out)
 {
 	return MIE_SUCCESS;
 }

mie/dialect/ptr/op/load.c

@@ -7,7 +7,9 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
 	return MIE_SUCCESS;
 }
 
-static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+static enum mie_status parse(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out)
 {
 	return MIE_SUCCESS;
 }

mie/dialect/ptr/op/store.c

@@ -7,7 +7,9 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
 	return MIE_SUCCESS;
 }
 
-static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+static enum mie_status parse(
+	struct mie_parser *parser, struct mie_parser_scope *names,
+	struct mie_op *out)
 {
 	return MIE_SUCCESS;
 }

mie/dialect/scf/op/for.c

@@ -1,14 +1,281 @@
+#include <mie/ctx.h>
+#include <mie/dialect/builtin.h>
 #include <mie/dialect/dialect.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/parse/parser.h>
+#include <mie/print/printer.h>
+#include <mie/type/function.h>
+#include <mie/type/storage.h>
 
 static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
 {
+	struct mie_region *body = mie_op_get_first_region(op);
+	struct mie_block *entry = NULL;
+	struct mie_register *iv = NULL;
+	struct mie_op_arg *lb = NULL, *ub = NULL, *step = NULL;
+
+	if (!body) {
+		return MIE_ERR_BAD_STATE;
+	}
+
+	entry = mie_region_get_first_block(body);
+	if (!entry) {
+		return MIE_ERR_BAD_STATE;
+	}
+
+	if (MIE_VECTOR_COUNT(op->op_args) < 3) {
+		return MIE_ERR_BAD_STATE;
+	}
+
+	if (MIE_VECTOR_COUNT(entry->b_params) < 1) {
+		return MIE_ERR_BAD_STATE;
+	}
+
+	iv = &entry->b_params.items[0];
+	lb = &op->op_args.items[0];
+	ub = &op->op_args.items[1];
+	step = &op->op_args.items[2];
+
+	fx_stream_write_char(printer->p_stream, ' ');
+	mie_printer_print_register(printer, iv, 0);
+	fx_stream_write_string(printer->p_stream, " = ", NULL);
+	mie_printer_print_op_arg(printer, lb, 0);
+	fx_stream_write_string(printer->p_stream, " to ", NULL);
+	mie_printer_print_op_arg(printer, ub, 0);
+	fx_stream_write_string(printer->p_stream, " step ", NULL);
+	mie_printer_print_op_arg(printer, step, 0);
+
+	if (MIE_VECTOR_COUNT(entry->b_params) > 1) {
+		fx_stream_write_string(printer->p_stream, " iter-args(", NULL);
+		for (size_t i = 1; i < MIE_VECTOR_COUNT(entry->b_params); i++) {
+			if (i > 1) {
+				fx_stream_write_string(printer->p_stream, ", ", NULL);
+			}
+
+			mie_printer_print_register(
+				printer, &entry->b_params.items[i], 0);
+			fx_stream_write_string(printer->p_stream, " = ", NULL);
+			mie_printer_print_op_arg(
+				printer, &op->op_args.items[i + 2], false);
+		}
+		fx_stream_write_char(printer->p_stream, ')');
+	}
+
+	if (MIE_VECTOR_COUNT(op->op_result) > 0) {
+		fx_stream_write_string(printer->p_stream, " -> ", NULL);
+		if (MIE_VECTOR_COUNT(op->op_result) > 1) {
+			fx_stream_write_char(printer->p_stream, '(');
+		}
+
+		for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_result); i++) {
+			mie_printer_print_type(
+				printer, op->op_result.items[i].reg_type);
+		}
+
+		if (MIE_VECTOR_COUNT(op->op_result) > 1) {
+			fx_stream_write_char(printer->p_stream, ')');
+		}
+	}
+
+	fx_stream_write_char(printer->p_stream, ' ');
+	mie_printer_print_region(
+		printer, body, MIE_PRINT_F_EXCLUDE_FIRST_BLOCK_HEADER);
+
 	return MIE_SUCCESS;
 }
 
-static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+static bool parse_result_type(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out, struct mie_block *entry)
 {
+	const struct mie_type *type = NULL;
+	struct mie_file_span span;
+	if (!mie_parser_parse_type(parser, "loop result type", &type, &span)) {
+		return false;
+	}
+
+	const struct mie_type **types;
+	size_t nr_types;
+
+	if (mie_type_is_storage(type)) {
+		const struct mie_storage_type *storage
+			= (const struct mie_storage_type *)type;
+
+		types = storage->st_parts.items;
+		nr_types = storage->st_parts.count;
+	} else if (!mie_type_is_function(type)) {
+		types = &type;
+		nr_types = 1;
+	} else {
+		mie_parser_report_error_simple(
+			parser, "builtin", MIE_BUILTIN_E_INVALID_TYPE,
+			MIE_BUILTIN_MSG_CANNOT_USE_FUNCTION_TYPE_HERE, &span);
+	}
+
+	if (MIE_VECTOR_COUNT(out->op_result) != nr_types) {
+		mie_parser_report_error_simple(
+			parser, "builtin", MIE_BUILTIN_E_INCORRECT_NUMBER_OF_TYPES,
+			MIE_BUILTIN_MSG_OP_NR_TYPES_DOESNT_MATCH_NR_RESULTS,
+			&span);
+		return false;
+	}
+
+	for (size_t i = 0; i < nr_types; i++) {
+		out->op_result.items[i].reg_type = types[i];
+	}
+
+	return true;
+}
+
+static bool parse_iter_arg(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out, struct mie_block *entry)
+{
+	struct mie_register *reg = mie_block_add_param(entry);
+	struct mie_op_arg *arg = mie_op_add_arg(out);
+
+	if (!mie_parser_parse_register(
+		    parser, scope, "iterator parameter name", reg)) {
+		return false;
+	}
+
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_EQUAL)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_EQUAL, "iterator parameter");
+		return false;
+	}
+
+	if (!mie_parser_parse_parameter(
+		    parser, false, arg, "iterator parameter value")) {
+		return false;
+	}
+
+	struct mie_register *value = mie_parser_scope_find_value(
+		scope, arg->arg_unresolved.reg_name);
+	if (value) {
+		reg->reg_type = value->reg_type;
+	}
+
+	return true;
+}
+
+static bool parse_iter_args(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out, struct mie_block *entry)
+{
+	if (!mie_parser_parse_keyword(parser, "iter-args", NULL)) {
+		return true;
+	}
+
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_LEFT_PAREN)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_LEFT_PAREN, "iterator parameter list");
+		return false;
+	}
+
+	if (!parse_iter_arg(parser, scope, out, entry)) {
+		return false;
+	}
+
+	while (1) {
+		if (mie_parser_parse_symbol(parser, MIE_SYM_RIGHT_PAREN)) {
+			break;
+		}
+
+		if (!mie_parser_parse_symbol(parser, MIE_SYM_COMMA)) {
+			struct mie_parser_item expected[] = {
+				MIE_PARSE_ITEM_TOKEN(MIE_SYM_COMMA),
+				MIE_PARSE_ITEM_TOKEN(MIE_SYM_RIGHT_PAREN),
+				MIE_PARSE_ITEM_NONE,
+			};
+			mie_parser_report_unexpected_token_v(
+				parser, expected, "iterator parameter list");
+			return false;
+		}
+
+		if (!parse_iter_arg(parser, scope, out, entry)) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+static enum mie_status parse(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out)
+{
+	struct mie_region *body = mie_op_add_region(out);
+	struct mie_block *entry = mie_region_add_block(body);
+	struct mie_register *iv = mie_block_add_param(entry);
+
+	mie_parser_scope_put_name(scope, &entry->b_name, "for.entry", 0);
+
+	if (!mie_parser_parse_register(parser, scope, "induction variable", iv)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	iv->reg_type = mie_ctx_get_type(
+		mie_parser_get_mie_ctx(parser), "builtin", "index");
+
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_EQUAL)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_EQUAL, "for-loop");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	struct mie_op_arg *lb = mie_op_add_arg(out);
+	if (!mie_parser_parse_parameter(parser, false, lb, "lower bound")) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_keyword(parser, "to", NULL)) {
+		mie_parser_report_unexpected_token_s(parser, "to", "for-loop");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	struct mie_op_arg *ub = mie_op_add_arg(out);
+	if (!mie_parser_parse_parameter(parser, false, ub, "upper bound")) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_keyword(parser, "step", NULL)) {
+		mie_parser_report_unexpected_token_s(parser, "step", "for-loop");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	struct mie_op_arg *step = mie_op_add_arg(out);
+	if (!mie_parser_parse_parameter(parser, false, step, "step")) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!parse_iter_args(parser, scope, out, entry)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (mie_parser_parse_symbol(parser, MIE_SYM_HYPHEN_RIGHT_ANGLE)) {
+		if (!parse_result_type(parser, scope, out, entry)) {
+			return MIE_ERR_BAD_SYNTAX;
+		}
+	} else if (MIE_VECTOR_COUNT(out->op_result) > 0) {
+		struct mie_file_span span;
+		mie_op_get_results_span(out, &span);
+		mie_parser_report_error_simple(
+			parser, "builtin",
+			MIE_BUILTIN_E_INCORRECT_NUMBER_OF_RESULTS,
+			MIE_BUILTIN_MSG_OP_NR_TYPES_DOESNT_MATCH_NR_RESULTS,
+			&span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_region(parser, out, body, entry)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
 	return MIE_SUCCESS;
 }
 

mie/dialect/scf/op/if.c

@@ -1,15 +1,85 @@
 #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)
+{
+	fx_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) {
+		fx_stream_write_string(printer->p_stream, " -> ", NULL);
+
+		if (MIE_VECTOR_COUNT(op->op_result) > 1) {
+			fx_stream_write_char(printer->p_stream, '(');
+		}
+	}
+
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_result); i++) {
+		if (i > 0) {
+			fx_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) {
+		fx_stream_write_char(printer->p_stream, '(');
+	}
+
+	fx_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) {
+		fx_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_parser_scope *names,
+	struct mie_op *out)
 {
 	return MIE_SUCCESS;
 }
 
-static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+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)
 {
-	return MIE_SUCCESS;
+	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/dialect/scf/op/yield.c

@@ -1,17 +1,120 @@
+#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/parse/parser.h>
+#include <mie/print/printer.h>
 
 static enum mie_status print(struct mie_printer *printer, const struct mie_op *op)
 {
+	fx_stream_write_char(printer->p_stream, ' ');
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) {
+		if (i > 0) {
+			fx_stream_write_string(printer->p_stream, ", ", NULL);
+		}
+
+		mie_printer_print_op_arg(printer, &op->op_args.items[i], false);
+	}
+
+	fx_stream_write_string(printer->p_stream, " : ", NULL);
+
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) {
+		if (i > 0) {
+			fx_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)
+static enum mie_status parse(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out)
 {
+	if (!mie_parser_parse_parameter_list(
+		    parser, false, MIE_VECTOR_REF(out->op_args),
+		    "yield value(s)")) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (!mie_parser_parse_symbol(parser, MIE_SYM_COLON)) {
+		mie_parser_report_unexpected_token(
+			parser, MIE_SYM_COLON, "yield value type(s)");
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	MIE_VECTOR_DEFINE(const struct mie_type *, types);
+	const struct mie_type *tmp = NULL;
+	struct mie_file_span first_span, last_span;
+
+	if (!mie_parser_parse_type(
+		    parser, "yield value type(s)", &tmp, &first_span)) {
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	mie_vector_push_back(types, &tmp, NULL);
+	bool ok = true;
+
+	while (1) {
+		if (mie_parser_peek_type(parser) == MIE_TOK_LINEFEED) {
+			break;
+		}
+
+		if (!mie_parser_parse_symbol(parser, MIE_SYM_COMMA)) {
+			struct mie_parser_item expected[] = {
+				MIE_PARSE_ITEM_TOKEN(MIE_SYM_COMMA),
+				MIE_PARSE_ITEM_TOKEN(MIE_TOK_LINEFEED),
+				MIE_PARSE_ITEM_NONE,
+			};
+
+			mie_parser_report_unexpected_token_v(
+				parser, expected, "yield value type list");
+			ok = false;
+			break;
+		}
+
+		if (!mie_parser_parse_type(
+			    parser, "yield value type", &tmp, &last_span)) {
+			ok = false;
+			break;
+		}
+
+		mie_vector_push_back(types, &tmp, NULL);
+	}
+
+	if (!ok) {
+		mie_vector_destroy(types, NULL);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	if (MIE_VECTOR_COUNT(types) != MIE_VECTOR_COUNT(out->op_args)) {
+		struct mie_file_span span = {
+			.s_start = first_span.s_start,
+			.s_end = last_span.s_end,
+		};
+		mie_parser_report_error_simple(
+			parser, "builtin", MIE_BUILTIN_E_INCORRECT_NUMBER_OF_TYPES,
+			MIE_BUILTIN_MSG_OP_NR_TYPES_DOESNT_MATCH_NR_ARGS, &span);
+		return MIE_ERR_BAD_SYNTAX;
+	}
+
+	for (size_t i = 0; i < MIE_VECTOR_COUNT(types); i++) {
+		out->op_args.items[i].arg_unresolved.reg_type = types.items[i];
+	}
+
 	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/dialect/select/op/graph.c

@@ -9,7 +9,9 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
 	return MIE_SUCCESS;
 }
 
-static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
+static enum mie_status parse(
+	struct mie_parser *parser, struct mie_parser_scope *scope,
+	struct mie_op *out)
 {
 	return MIE_SUCCESS;
 }

mie/id.c

@@ -1,7 +1,7 @@
-#include <blue/core/bstr.h>
+#include <fx/core/bstr.h>
-#include <blue/core/endian.h>
+#include <fx/core/endian.h>
-#include <blue/core/hash.h>
+#include <fx/core/hash.h>
-#include <blue/core/random.h>
+#include <fx/core/random.h>
 #include <mie/id.h>
 #include <string.h>
 
@@ -10,18 +10,18 @@ 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)
+static mie_id *get_id(const fx_bst *tree, mie_id *key)
 {
-	b_btree_node *cur = tree->b_root;
+	fx_bst_node *cur = tree->bst_root;
 	while (cur) {
-		mie_id *cur_node = b_unbox(mie_id, cur, e_node);
+		mie_id *cur_node = fx_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);
+			cur = fx_bst_right(cur);
 		} else if (cmp < 0) {
-			cur = b_btree_left(cur);
+			cur = fx_bst_left(cur);
 		} else {
 			return cur_node;
 		}
@@ -30,33 +30,33 @@ static mie_id *get_id(const b_btree *tree, mie_id *key)
 	return NULL;
 }
 
-void put_id(b_btree *tree, mie_id *node)
+void put_id(fx_bst *tree, mie_id *node)
 {
-	if (!tree->b_root) {
+	if (!tree->bst_root) {
-		tree->b_root = &node->e_node;
+		tree->bst_root = &node->e_node;
-		b_btree_insert_fixup(tree, &node->e_node);
+		fx_bst_insert_fixup(tree, &node->e_node);
 		return;
 	}
 
-	b_btree_node *cur = tree->b_root;
+	fx_bst_node *cur = tree->bst_root;
 	while (1) {
-		mie_id *cur_node = b_unbox(mie_id, cur, e_node);
+		mie_id *cur_node = fx_unbox(mie_id, cur, e_node);
-		b_btree_node *next = NULL;
+		fx_bst_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);
+			next = fx_bst_right(cur);
 
 			if (!next) {
-				b_btree_put_right(cur, &node->e_node);
+				fx_bst_put_right(cur, &node->e_node);
 				break;
 			}
 		} else if (cmp < 0) {
-			next = b_btree_left(cur);
+			next = fx_bst_left(cur);
 
 			if (!next) {
-				b_btree_put_left(cur, &node->e_node);
+				fx_bst_put_left(cur, &node->e_node);
 				break;
 			}
 		} else {
@@ -66,17 +66,17 @@ void put_id(b_btree *tree, mie_id *node)
 		cur = next;
 	}
 
-	b_btree_insert_fixup(tree, &node->e_node);
+	fx_bst_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);
+	fx_i32 x_a = fx_i32_htob(a);
-	b_i16 x_b = b_i16_htob(b);
+	fx_i16 x_b = fx_i16_htob(b);
-	b_i16 x_c = b_i16_htob(c);
+	fx_i16 x_c = fx_i16_htob(c);
-	b_i16 x_d = b_i16_htob(d);
+	fx_i16 x_d = fx_i16_htob(d);
-	b_i64 x_e = b_i64_htob(e);
+	fx_i64 x_e = fx_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);
@@ -92,12 +92,12 @@ void mie_id_init_zero(mie_id *out)
 
 void mie_id_init_random(mie_id *out)
 {
-	b_random_ctx *random = b_random_global_ctx();
+	fx_random_ctx *random = fx_random_global_ctx();
-	b_random_next_bytes(
+	fx_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)
+void mie_id_init_ns(mie_id *out, const mie_id *ns, const fx_rope *name)
 {
 	struct mie_id_builder ctx;
 	mie_id_builder_begin(&ctx, ns);
@@ -107,45 +107,45 @@ void mie_id_init_ns(mie_id *out, const mie_id *ns, const b_rope *name)
 
 void mie_id_to_string(const mie_id *id, char *out, size_t max)
 {
-	b_bstr str;
+	fx_bstr str;
-	b_bstr_begin(&str, out, max);
+	fx_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, '-');
+			fx_bstr_write_char(&str, '-');
 		}
 
-		b_bstr_write_fmt(&str, NULL, "%02x", id->id_bytes[i]);
+		fx_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);
+	fx_hash_ctx_init(&builder->b_hash, FX_HASH_SHA1);
-	b_hash_ctx_update(&builder->b_hash, ns->id_bytes, sizeof ns->id_bytes);
+	fx_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);
+	fx_hash_ctx_update(&builder->b_hash, p, len);
 }
 
-void mie_id_builder_add_rope(struct mie_id_builder *builder, const b_rope *rope)
+void mie_id_builder_add_rope(struct mie_id_builder *builder, const fx_rope *rope)
 {
-	b_hash_ctx_update_rope(&builder->b_hash, rope);
+	fx_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);
+	fx_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);
+	fx_hash_ctx_finish(&builder->b_hash, out->id_bytes, sizeof out->id_bytes);
 
 	out->id_bytes[6] &= 0x0F;
 	out->id_bytes[6] |= 0x50;
@@ -166,7 +166,7 @@ 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)
+void mie_id_map_put(struct mie_id_map *map, mie_id *id, const fx_rope *name)
 {
 	mie_id_init_ns(id, &map->map_ns_id, name);
 	put_id(&map->map_entries, id);
@@ -187,13 +187,13 @@ enum mie_status mie_id_map_iterator_begin(
 {
 	memset(it, 0x0, sizeof *it);
 
-	it->_n = b_btree_first(&map->map_entries);
+	it->_n = fx_bst_first(&map->map_entries);
 
 	if (!it->_n) {
 		return MIE_ERR_NO_DATA;
 	}
 
-	it->it_id = b_unbox(mie_id, it->_n, e_node);
+	it->it_id = fx_unbox(mie_id, it->_n, e_node);
 
 	return MIE_SUCCESS;
 }
@@ -205,13 +205,13 @@ enum mie_status mie_id_map_iterator_move_next(struct mie_id_map_iterator *it)
 		return MIE_ERR_NO_DATA;
 	}
 
-	it->_n = b_btree_next(it->_n);
+	it->_n = fx_bst_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);
+	it->it_id = fx_unbox(mie_id, it->_n, e_node);
 
 	return MIE_SUCCESS;
 }

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

@@ -1,14 +1,14 @@
 #ifndef MIE_ATTRIBUTE_ATTRIBUTE_MAP_H_
 #define MIE_ATTRIBUTE_ATTRIBUTE_MAP_H_
 
-#include <blue/core/btree.h>
+#include <fx/core/bst.h>
 #include <mie/misc.h>
 #include <mie/status.h>
 
-struct b_queue_entry;
+struct fx_queue_entry;
 
 struct mie_attribute_map {
-	b_btree m_entries;
+	fx_bst m_entries;
 };
 
 enum mie_attribute_map_flags {
@@ -18,8 +18,8 @@ enum mie_attribute_map_flags {
 struct mie_attribute_map_iterator {
 	const char *it_name;
 	const struct mie_attribute *it_value;
-	b_btree_node *_n;
+	fx_bst_node *_n;
-	struct b_queue_entry *_e;
+	struct fx_queue_entry *_e;
 };
 
 MIE_API void mie_attribute_map_init(struct mie_attribute_map *map);
@@ -27,7 +27,7 @@ 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);
+	return fx_bst_empty(&map->m_entries);
 }
 
 MIE_API const struct mie_attribute *mie_attribute_map_get(

mie/include/mie/ctx.h

@@ -1,13 +1,16 @@
 #ifndef MIE_CTX_H_
 #define MIE_CTX_H_
 
-#include <blue/core/btree.h>
+#include <fx/core/bst.h>
-#include <blue/ds/hashmap.h>
+#include <fx/ds/hashmap.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;
@@ -18,8 +21,8 @@ struct mie_ctx {
 	struct mie_const *ctx_true, *ctx_false;
 	struct mie_value *ctx_null;
 	struct mie_type *ctx_types[__MIE_TYPE_COUNT];
-	b_hashmap *ctx_sel_cache;
+	fx_hashmap *ctx_sel_cache;
-	b_hashmap *ctx_string_cache;
+	fx_hashmap *ctx_string_cache;
 #endif
 	/* map of struct mie_dialect */
 	struct mie_id_map ctx_dialects;
@@ -31,6 +34,8 @@ struct mie_ctx {
 	struct mie_id_map ctx_attributes;
 	/* map of struct mie_pass_definition */
 	struct mie_id_map ctx_passes;
+	/* queue of struct mie_diag */
+	fx_queue ctx_diag;
 };
 
 MIE_API struct mie_ctx *mie_ctx_create(void);
@@ -38,7 +43,6 @@ MIE_API void mie_ctx_destroy(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 bool mie_ctx_resolve_op(const struct mie_ctx *ctx, struct mie_op *op);
 
 MIE_API struct mie_dialect *mie_ctx_get_dialect(
 	const struct mie_ctx *ctx, const char *name);
@@ -73,4 +77,11 @@ 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 <fx/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;
+	fx_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,73 @@
+#ifndef MIE_DIAG_DIAG_H_
+#define MIE_DIAG_DIAG_H_
+
+#include <fx/core/queue.h>
+#include <mie/parse/file-span.h>
+
+#define MIE_DIAG_HL(type, span)                                                \
+	{                                                                      \
+		.hl_type = MIE_DIAG_HIGHLIGHT_##type,                          \
+		.hl_span = (span),                                             \
+	}
+
+#define MIE_DIAG_ADD(str, loc)                                                 \
+	{                                                                      \
+		.a_type = MIE_DIAG_AMENDMENT_ADD, .__x = strlen(str),          \
+		.a_add = {                                                     \
+			.a_loc = (loc),                                        \
+				.a_str = (str), \
+		},                                                             \
+	}
+
+#define MIE_DIAG_REMOVE(len, llc)                                              \
+	{                                                                      \
+		.a_type = MIE_DIAG_AMENDMENT_REMOVE,                           \
+		.a_remove = {                                                  \
+			.a_loc = (loc),                                        \
+			.a_length = (len),                                     \
+		},                                                             \
+	}
+#define MIE_DIAG_REPLACE(len, str, loc)                                        \
+	{                                                                      \
+		.a_type = MIE_DIAG_AMENDMENT_REPLACE, .__x = strlen(str),      \
+		.a_replace = {                                                 \
+			.a_loc = (loc),                                        \
+			.a_length = (len),                                     \
+			.a_str = (str),                                        \
+		},                                                             \
+	}
+
+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;
+	fx_queue_entry diag_entry;
+	fx_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_string(struct mie_diag *diag, const char *str);
+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

@@ -8,19 +8,48 @@
 
 struct mie_ctx;
 struct mie_dialect;
-struct mie_builder;
+struct mie_emitter;
+
+enum mie_arith_diag {
+	MIE_ARITH_E_INVALID_INTEGER_TYPE,
+	MIE_ARITH_E_INVALID_FLOAT_TYPE,
+	MIE_ARITH_E_INVALID_COMPARISON_PREDICATE,
+};
+
+enum mie_arith_msg {
+	MIE_ARITH_MSG_EXPECTED_INTEGER_TYPE,
+	MIE_ARITH_MSG_EXPECTED_FLOAT_TYPE,
+	MIE_ARITH_MSG_INVALID_COMPARISON_PREDICATE,
+	MIE_ARITH_MSG_VALID_COMPARISON_PREDICATES,
+};
+
+enum mie_arith_cmpi_predicate {
+	MIE_ARITH_CMPI_EQ = 0,
+	MIE_ARITH_CMPI_NE = 1,
+	MIE_ARITH_CMPI_SLT = 2,
+	MIE_ARITH_CMPI_SLE = 3,
+	MIE_ARITH_CMPI_SGT = 4,
+	MIE_ARITH_CMPI_SGE = 5,
+	MIE_ARITH_CMPI_ULT = 6,
+	MIE_ARITH_CMPI_ULE = 7,
+	MIE_ARITH_CMPI_UGT = 8,
+	MIE_ARITH_CMPI_UGE = 9,
+};
 
 MIE_API struct mie_dialect *mie_arith_dialect_create(struct mie_ctx *ctx);
 
-MIE_API struct mie_register *mie_arith_put_constant_i(
+MIE_API struct mie_register *mie_arith_constant_i_put(
-	struct mie_builder *builder, long long value, const char *name);
+	struct mie_emitter *e, long long value, const char *name);
-MIE_API struct mie_register *mie_arith_put_constant_f(
+MIE_API struct mie_register *mie_arith_constant_f_put(
-	struct mie_builder *builder, long long value, const char *name);
+	struct mie_emitter *e, long long value, const char *name);
-MIE_API struct mie_register *mie_arith_put_addi(
+MIE_API struct mie_register *mie_arith_addi_put(
-	struct mie_builder *builder, struct mie_register *left,
+	struct mie_emitter *e, struct mie_register *left,
 	struct mie_register *right, const char *name);
-MIE_API struct mie_register *mie_arith_put_addf(
+MIE_API struct mie_register *mie_arith_cmpi_put(
-	struct mie_builder *builder, struct mie_register *left,
+	struct mie_emitter *e, enum mie_arith_cmpi_predicate pred,
+	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

@@ -1,10 +1,11 @@
 #ifndef MIE_DIALECT_BUILTIN_H_
 #define MIE_DIALECT_BUILTIN_H_
 
-#include <blue/ds/string.h>
+#include <fx/ds/string.h>
 #include <mie/attribute/attribute.h>
 #include <mie/interface/interface.h>
 #include <mie/misc.h>
+#include <mie/parse/file-span.h>
 #include <mie/trait/trait.h>
 #include <mie/vector.h>
 
@@ -15,11 +16,66 @@ struct mie_op;
 struct mie_int_type;
 struct mie_float_type;
 
+enum mie_builtin_diag {
+	MIE_BUILTIN_E_UNRECOGNISED_TOKEN,
+	MIE_BUILTIN_E_UNEXPECTED_TOKEN,
+	MIE_BUILTIN_E_UNRESOLVED_TYPE,
+	MIE_BUILTIN_E_UNRESOLVED_VALUE,
+	MIE_BUILTIN_E_UNRESOLVED_SUCCESSOR,
+	MIE_BUILTIN_E_UNKNOWN_OP,
+	MIE_BUILTIN_E_OP_REQUIRES_PARENT_SCOPE,
+	MIE_BUILTIN_E_INCORRECT_NUMBER_OF_ARGUMENTS,
+	MIE_BUILTIN_E_INCORRECT_NUMBER_OF_RESULTS,
+	MIE_BUILTIN_E_INCORRECT_NUMBER_OF_TYPES,
+	MIE_BUILTIN_E_INCORRECT_TYPE,
+	MIE_BUILTIN_E_INVALID_TYPE,
+	MIE_BUILTIN_E_NAME_ALREADY_IN_USE,
+	MIE_BUILTIN_E_INTERNAL_ERROR,
+};
+
+enum mie_builtin_msg {
+	MIE_BUILTIN_MSG_UNRECOGNISED_TOKEN,
+	MIE_BUILTIN_MSG_UNEXPECTED_TOKEN,
+	MIE_BUILTIN_MSG_UNRESOLVED_VALUE,
+	MIE_BUILTIN_MSG_UNRESOLVED_BUILTIN_TYPE,
+	MIE_BUILTIN_MSG_UNRESOLVED_DIALECT_TYPE,
+	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,
+	MIE_BUILTIN_MSG_UNKNOWN_OP,
+	MIE_BUILTIN_MSG_OP_REQUIRES_PARENT_SCOPE,
+	MIE_BUILTIN_MSG_OP_PARENT_SCOPE_EXAMPLE,
+	MIE_BUILTIN_MSG_USE_GENERIC_OP_SYNTAX,
+	MIE_BUILTIN_MSG_OP_HAS_NO_PARSER,
+	MIE_BUILTIN_MSG_DIALECT_INTERNAL_ERROR,
+	MIE_BUILTIN_MSG_COMPILER_INTERNAL_ERROR,
+	MIE_BUILTIN_MSG_OP_INCORRECT_NUMBER_OF_ARGS,
+	MIE_BUILTIN_MSG_OP_INCORRECT_NUMBER_OF_RESULTS,
+	MIE_BUILTIN_MSG_OP_NR_TYPES_DOESNT_MATCH_NR_ARGS,
+	MIE_BUILTIN_MSG_OP_NR_TYPES_DOESNT_MATCH_NR_RESULTS,
+	MIE_BUILTIN_MSG_OP_EXPECTS_X_RESULTS,
+	MIE_BUILTIN_MSG_NR_RESULT_NAME_OUTPUT_MISMATCH,
+	MIE_BUILTIN_MSG_NAME_ALREADY_IN_USE,
+	MIE_BUILTIN_MSG_NAME_ALREADY_USED_HERE,
+	MIE_BUILTIN_MSG_CANNOT_USE_FUNCTION_TYPE_HERE,
+	MIE_BUILTIN_MSG_CANNOT_USE_STORAGE_TYPE_HERE,
+	MIE_BUILTIN_MSG_MUST_USE_FUNCTION_TYPE_HERE,
+	MIE_BUILTIN_MSG_MUST_USE_STORAGE_TYPE_HERE,
+};
+
 enum mie_float_width {
 	MIE_FLOAT_32 = 32,
 	MIE_FLOAT_64 = 64,
 };
 
+enum mie_memref_rank_type {
+	MIE_MEMREF_RANK_UNKNOWN = 0,
+	MIE_MEMREF_RANK_STATIC,
+	MIE_MEMREF_RANK_TYPE,
+};
+
 struct mie_string {
 	struct mie_attribute str_base;
 	char *str_val;
@@ -74,6 +130,15 @@ struct mie_symbol_table {
 	struct mie_trait tab_base;
 };
 
+struct mie_memref_rank {
+	enum mie_memref_rank_type r_ranktype;
+	struct mie_file_span r_span;
+	union {
+		size_t r_static;
+		const struct mie_type *r_type;
+	};
+};
+
 struct mie_int_cache;
 struct mie_float_cache;
 struct mie_string_cache;
@@ -120,6 +185,8 @@ 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_type *mie_ctx_get_memref_type(
+	struct mie_ctx *ctx, const struct mie_memref_rank *ranks, size_t nr_ranks);
 
 MIE_API struct mie_attribute *mie_type_attr_create(
 	struct mie_ctx *ctx, const struct mie_type *ty);
@@ -127,4 +194,8 @@ MIE_API struct mie_attribute *mie_type_attr_create(
 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);
 
+MIE_API size_t mie_memref_type_get_nr_ranks(const struct mie_type *type);
+MIE_API const struct mie_memref_rank *mie_memref_type_get_rank(
+	const struct mie_type *type, size_t i);
+
 #endif

mie/include/mie/dialect/cf.h

@@ -2,10 +2,23 @@
 #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

@@ -1,8 +1,8 @@
 #ifndef MIE_DIALECT_DIALECT_H_
 #define MIE_DIALECT_DIALECT_H_
 
-#include <blue/core/btree.h>
+#include <fx/core/bst.h>
-#include <blue/core/queue.h>
+#include <fx/core/queue.h>
 #include <mie/id.h>
 #include <mie/misc.h>
 #include <mie/vector.h>
@@ -13,6 +13,9 @@ 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;
@@ -27,6 +30,12 @@ struct mie_dialect {
 	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/include/mie/dialect/func.h

@@ -7,8 +7,8 @@
 struct mie_ctx;
 struct mie_type;
 struct mie_dialect;
+struct mie_emitter;
 struct mie_register;
-struct mie_builder;
 
 struct mie_func_parameter {
 	const char *param_name;
@@ -18,9 +18,8 @@ struct mie_func_parameter {
 
 MIE_API struct mie_dialect *mie_func_dialect_create(struct mie_ctx *ctx);
 
-MIE_API struct mie_op *mie_func_put_func(
+MIE_API struct mie_op *mie_func_func_put(
-	struct mie_builder *builder, const char *name,
+	struct mie_emitter *e, const char *name, struct mie_func_parameter *params,
-	struct mie_func_parameter *params, size_t nr_params,
+	size_t nr_params, const struct mie_type **ret_types, size_t nr_ret_types);
-	const struct mie_type **ret_types, size_t nr_ret_types);
 
 #endif

mie/include/mie/dialect/memref.h

@@ -8,6 +8,13 @@
 struct mie_ctx;
 struct mie_dialect;
 
+enum mie_memref_msg {
+	MIE_MEMREF_MSG_OP_EXPECTS_MEMREF_ARGUMENT,
+	MIE_MEMREF_MSG_LAST_MEMREF_RANK_MUST_BE_TYPE,
+	MIE_MEMREF_MSG_MEMREF_MUST_HAVE_AT_LEAST_ONE_RANK,
+	MIE_MEMREF_MSG_OP_RESULT_DETERMINED_BY_LAST_MEMREF_RANK,
+};
+
 MIE_API struct mie_dialect *mie_memref_dialect_create(struct mie_ctx *ctx);
 
 #endif

mie/include/mie/dialect/scf.h

@@ -4,8 +4,19 @@
 #include <mie/misc.h>
 
 struct mie_ctx;
+struct mie_type;
+struct mie_region;
 struct mie_dialect;
+struct mie_emitter;
+struct mie_register;
 
 MIE_API struct mie_dialect *mie_scf_dialect_create(struct mie_ctx *ctx);
 
+MIE_API 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);
+MIE_API struct mie_op *mie_scf_yield_put(
+	struct mie_emitter *e, struct mie_register *value);
+
 #endif

mie/include/mie/id.h

@@ -1,9 +1,9 @@
 #ifndef MIE_ID_H_
 #define MIE_ID_H_
 
-#include <blue/core/btree.h>
+#include <fx/core/bst.h>
-#include <blue/core/queue.h>
+#include <fx/core/queue.h>
-#include <blue/core/rope.h>
+#include <fx/core/rope.h>
 #include <mie/misc.h>
 #include <mie/status.h>
 #include <stddef.h>
@@ -42,30 +42,30 @@ typedef struct mie_id {
 	};
 
 	union {
-		b_btree_node e_node;
+		fx_bst_node e_node;
-		b_queue_entry e_entry;
+		fx_queue_entry e_entry;
 	};
 } mie_id;
 
 struct mie_id_builder {
-	b_hash_ctx b_hash;
+	fx_hash_ctx b_hash;
 };
 
 struct mie_id_map {
 	mie_id map_ns_id;
-	b_btree map_entries;
+	fx_bst map_entries;
 };
 
 struct mie_id_map_iterator {
 	mie_id *it_id;
-	b_btree_node *_n;
+	fx_bst_node *_n;
 };
 
 MIE_API void mie_id_init(
 	mie_id *out, uint32_t a, uint16_t b, uint16_t c, uint16_t d, uint64_t e);
 MIE_API void mie_id_init_zero(mie_id *out);
 MIE_API void mie_id_init_random(mie_id *out);
-MIE_API void mie_id_init_ns(mie_id *out, const mie_id *ns, const b_rope *name);
+MIE_API void mie_id_init_ns(mie_id *out, const mie_id *ns, const fx_rope *name);
 
 static inline int mie_id_compare(const mie_id *a, const mie_id *b)
 {
@@ -86,8 +86,20 @@ static inline void mie_id_builder_add_cstr(
 {
 	mie_id_builder_add(builder, s, strlen(s));
 }
+static inline void mie_id_builder_add_id(
+	struct mie_id_builder *builder, const mie_id *id)
+{
+	mie_id_builder_add(builder, id->id_bytes, sizeof id->id_bytes);
+}
+static inline void mie_id_builder_add_int(
+	struct mie_id_builder *builder, long long v)
+{
+	char s[32];
+	size_t len = snprintf(s, sizeof s, "%lld", v);
+	mie_id_builder_add(builder, s, len);
+}
 MIE_API void mie_id_builder_add_rope(
-	struct mie_id_builder *builder, const b_rope *rope);
+	struct mie_id_builder *builder, const fx_rope *rope);
 MIE_API void mie_id_builder_add_marker(
 	struct mie_id_builder *builder, enum mie_id_builder_marker marker);
 MIE_API void mie_id_builder_end(struct mie_id_builder *builder, mie_id *out);
@@ -95,12 +107,12 @@ MIE_API void mie_id_builder_end(struct mie_id_builder *builder, mie_id *out);
 MIE_API void mie_id_map_init(struct mie_id_map *map, const mie_id *ns);
 static inline bool mie_id_map_empty(const struct mie_id_map *map)
 {
-	return b_btree_empty(&map->map_entries);
+	return fx_bst_empty(&map->map_entries);
 }
 
 MIE_API const mie_id *mie_id_map_get_ns(const struct mie_id_map *map);
 MIE_API void mie_id_map_put(
-	struct mie_id_map *map, mie_id *node, const b_rope *name);
+	struct mie_id_map *map, mie_id *node, const fx_rope *name);
 MIE_API void mie_id_map_put_id(struct mie_id_map *map, mie_id *node);
 MIE_API mie_id *mie_id_map_get(const struct mie_id_map *map, mie_id *id);
 

mie/include/mie/ir/block.h

@@ -1,25 +1,74 @@
 #ifndef MIE_IR_BLOCK_H_
 #define MIE_IR_BLOCK_H_
 
-#include <blue/core/queue.h>
+#include <fx/core/queue.h>
 #include <mie/misc.h>
 #include <mie/name.h>
 #include <mie/vector.h>
 
+#define MIE_BLOCK_ID_INVALID ((size_t)0)
+
 struct mie_op;
 struct mie_register;
 
+struct mie_block_predecessor {
+	struct mie_block *p_block;
+};
+
 struct mie_block {
 	struct mie_name b_name;
 	struct mie_region *b_parent;
 
+	/* immediate predecessor blocks */
+	MIE_VECTOR_DECLARE(struct mie_block_predecessor, b_ipred);
+
+	/* used by struct mie_region */
+	unsigned int b_id;
+	struct mie_block *b_idom;
+	// struct mie_block *b_sdom, *b_dfs_parent;
+	fx_queue_entry b_entry;
+
 	MIE_VECTOR_DECLARE(struct mie_register, b_params);
-	MIE_VECTOR_DECLARE(struct mie_op, b_ops);
+	/* queue of struct mie_op */
+	fx_queue b_ops;
 };
 
 extern struct mie_vector_ops mie_block_vector_ops;
 
+MIE_API struct mie_op *mie_block_get_first_op(const struct mie_block *block);
+MIE_API struct mie_op *mie_block_get_prev_op(
+	const struct mie_block *block, const struct mie_op *before);
+MIE_API struct mie_op *mie_block_get_next_op(
+	const struct mie_block *block, const struct mie_op *after);
+MIE_API struct mie_op *mie_block_get_last_op(const struct mie_block *block);
+
+MIE_API struct mie_op *mie_block_get_terminator(const struct mie_block *block);
+
+MIE_API struct mie_op_successor *mie_block_get_first_successor(
+	const struct mie_block *block);
+MIE_API struct mie_op_successor *mie_block_get_prev_successor(
+	const struct mie_block *block, const struct mie_op_successor *before);
+MIE_API struct mie_op_successor *mie_block_get_next_successor(
+	const struct mie_block *block, const struct mie_op_successor *after);
+MIE_API struct mie_op_successor *mie_block_get_last_successor(
+	const struct mie_block *block);
+
+MIE_API struct mie_block_predecessor *mie_block_get_first_predecessor(
+	const struct mie_block *block);
+MIE_API struct mie_block_predecessor *mie_block_get_prev_predecessor(
+	const struct mie_block *block, const struct mie_block_predecessor *before);
+MIE_API struct mie_block_predecessor *mie_block_get_next_predecessor(
+	const struct mie_block *block, const struct mie_block_predecessor *after);
+MIE_API struct mie_block_predecessor *mie_block_get_last_predecessor(
+	const struct mie_block *block);
+
 MIE_API struct mie_op *mie_block_add_op(struct mie_block *block);
+MIE_API struct mie_op *mie_block_add_op_after(
+	struct mie_block *block, struct mie_op *after);
 MIE_API struct mie_register *mie_block_add_param(struct mie_block *block);
 
+MIE_API struct mie_register *mie_block_find_register(
+	const struct mie_block *block, const char *name,
+	const struct mie_op *start_point);
+
 #endif

mie/include/mie/ir/builder.h

@@ -1,6 +1,7 @@
 #ifndef MIE_IR_BUILDER_H_
 #define MIE_IR_BUILDER_H_
 
+#include <mie/ir/emit.h>
 #include <mie/misc.h>
 #include <stddef.h>
 
@@ -30,9 +31,9 @@ MIE_API void mie_builder_step_into_block(
 MIE_API void mie_builder_step_out(struct mie_builder *builder);
 
 MIE_API struct mie_op *mie_builder_put_op(
-	struct mie_builder *, const char *dialect, const char *op,
+	struct mie_builder *builder, const char *dialect, const char *op,
 	struct mie_register **args, size_t nr_args);
 MIE_API enum mie_status mie_builder_put_name(
-	struct mie_builder *, struct mie_name *name, const char *hint);
+	struct mie_builder *builder, struct mie_name *name, const char *hint);
 
 #endif

mie/include/mie/ir/emit.h

@@ -0,0 +1,42 @@
+#ifndef MIE_IR_EMIT_H_
+#define MIE_IR_EMIT_H_
+
+#include <mie/misc.h>
+#include <mie/status.h>
+#include <stddef.h>
+
+#define MIE_EMITTER(p) ((struct mie_emitter *)(p))
+
+struct mie_op;
+struct mie_name;
+struct mie_block;
+struct mie_register;
+
+struct mie_emitter;
+
+typedef struct mie_ctx *(*mie_emit_get_ctx)(const struct mie_emitter *);
+typedef enum mie_status (*mie_emit_put_name)(
+	struct mie_emitter *, struct mie_name *, const char *);
+typedef struct mie_op *(*mie_emit_put_op)(
+	struct mie_emitter *, const char *, const char *,
+	struct mie_register **, size_t);
+typedef struct mie_block *(*mie_emit_put_block)(
+	struct mie_emitter *, struct mie_block *);
+
+struct mie_emitter {
+	mie_emit_get_ctx e_get_ctx;
+	mie_emit_put_name e_put_name;
+	mie_emit_put_op e_put_op;
+	mie_emit_put_block e_put_block;
+};
+
+MIE_API struct mie_ctx *mie_emitter_get_ctx(struct mie_emitter *emitter);
+MIE_API enum mie_status mie_emitter_put_name(
+	struct mie_emitter *emitter, struct mie_name *name, const char *hint);
+MIE_API struct mie_op *mie_emitter_put_op(
+	struct mie_emitter *emitter, const char *dialect_name,
+	const char *op_name, struct mie_register **args, size_t nr_args);
+MIE_API struct mie_block *mie_emitter_put_block(
+	struct mie_emitter *emitter, struct mie_block *insert_point);
+
+#endif

mie/include/mie/ir/op-definition.h

@@ -1,8 +1,8 @@
 #ifndef MIE_IR_OP_DEFINITION_H_
 #define MIE_IR_OP_DEFINITION_H_
 
-#include <blue/core/btree.h>
+#include <fx/core/bst.h>
-#include <blue/core/stream.h>
+#include <fx/core/stream.h>
 #include <mie/id.h>
 #include <mie/interface/interface-map.h>
 #include <mie/status.h>
@@ -15,6 +15,7 @@ struct mie_op;
 struct mie_printer;
 struct mie_parser;
 struct mie_dialect;
+struct mie_parser_scope;
 
 #if 0
 enum mie_op_trait {
@@ -103,7 +104,8 @@ struct mie_op_definition {
 	const struct mie_op_result op_results[MIE_OP_MAX_RESULTS];
 
 	enum mie_status (*op_print)(struct mie_printer *, const struct mie_op *);
-	enum mie_status (*op_parse)(struct mie_parser *, struct mie_op *);
+	enum mie_status (*op_parse)(
+		struct mie_parser *, struct mie_parser_scope *, struct mie_op *);
 };
 
 MIE_API struct mie_op_definition *mie_op_definition_create(

mie/include/mie/ir/op.h

@@ -9,8 +9,8 @@
 #include <mie/name.h>
 #include <mie/parse/file-span.h>
 
+struct mie_ctx;
 struct mie_type;
-
 struct mie_value;
 struct mie_block;
 struct mie_region;
@@ -37,6 +37,7 @@ struct mie_op_arg {
 
 struct mie_op_successor {
 	enum mie_op_flags s_flags;
+	struct mie_file_span s_name_span;
 
 	union {
 		/* only valid if F_SUCCESSOR_RESOLVED is set in s_flags; */
@@ -50,16 +51,20 @@ struct mie_op_successor {
 
 struct mie_op {
 	enum mie_op_flags op_flags;
+	/* used by struct mie_block */
+	fx_queue_entry op_entry;
 
-	/* these pointers are only valid if the F_OP_RESOLVED flag is set */
+	struct mie_line_source *op_src;
-	const struct mie_dialect *op_dialect;
+	/* this pointer is only valid if the F_OP_RESOLVED flag is set */
 	const struct mie_op_definition *op_info;
 
+	struct mie_block *op_container;
 	struct mie_file_span op_name_span;
 	/* only valid if the F_RESOLVED flag is NOT set */
 	char *op_name;
 
-	MIE_VECTOR_DECLARE(struct mie_region, op_regions);
+	fx_queue op_regions;
+
 	MIE_VECTOR_DECLARE(struct mie_op_successor, op_successors);
 	struct mie_attribute_map op_attrib;
 	MIE_VECTOR_DECLARE(struct mie_op_arg, op_args);
@@ -72,16 +77,43 @@ MIE_API void mie_op_destroy(struct mie_op *op);
 MIE_API void mie_op_init(struct mie_op *op);
 MIE_API void mie_op_cleanup(struct mie_op *op);
 
+MIE_API size_t mie_op_get_name(const struct mie_op *op, char *out, size_t max);
+
 MIE_API struct mie_op_arg *mie_op_add_arg(struct mie_op *op);
 MIE_API struct mie_register *mie_op_add_result(
 	struct mie_op *op, const struct mie_type *ty);
+MIE_API struct mie_op_successor *mie_op_add_successor(
+	struct mie_op *op, struct mie_block *block, struct mie_register **args,
+	size_t nr_args);
 MIE_API struct mie_region *mie_op_add_region(struct mie_op *op);
 
+MIE_API bool mie_op_is(
+	const struct mie_op *op, const char *dialect_name, const char *op_name);
 MIE_API bool mie_op_has_trait(
 	const struct mie_op *op, const char *dialect_name, const char *trait_name);
 MIE_API bool mie_op_has_interface(
 	const struct mie_op *op, const char *dialect_name, const char *iface_name);
 
+MIE_API struct mie_op *mie_op_get_parent(const struct mie_op *op);
+MIE_API struct mie_region *mie_op_get_first_region(const struct mie_op *op);
+MIE_API struct mie_region *mie_op_get_prev_region(
+	const struct mie_op *op, const struct mie_region *before);
+MIE_API struct mie_region *mie_op_get_next_region(
+	const struct mie_op *op, const struct mie_region *after);
+MIE_API struct mie_region *mie_op_get_last_region(const struct mie_op *op);
+
+MIE_API struct mie_register *mie_op_get_arg(const struct mie_op *op, size_t index);
+MIE_API struct mie_register *mie_op_get_result_with_name(
+	const struct mie_op *op, const char *name);
+
+MIE_API void mie_op_get_args_span(
+	const struct mie_op *op, struct mie_file_span *result);
+MIE_API void mie_op_get_results_span(
+	const struct mie_op *op, struct mie_file_span *result);
+
+MIE_API struct mie_op *mie_op_get_first_child_op(const struct mie_op *op);
+MIE_API struct mie_op *mie_op_get_last_child_op(const struct mie_op *op);
+
 MIE_API const struct mie_type *mie_op_arg_get_type(const struct mie_op_arg *arg);
 
 #endif

mie/include/mie/ir/region.h

@@ -1,19 +1,57 @@
 #ifndef MIE_IR_REGION_H_
 #define MIE_IR_REGION_H_
 
+#include <fx/core/bst.h>
+#include <fx/core/queue.h>
 #include <mie/misc.h>
 #include <mie/vector.h>
 #include <stddef.h>
 
 struct mie_op;
+struct mie_ctx;
 struct mie_block;
 
 struct mie_region {
 	struct mie_name_map *r_names;
 	struct mie_op *r_parent;
-	MIE_VECTOR_DECLARE(struct mie_block, r_blocks);
+	/* used by struct mie_op */
+	fx_queue_entry r_entry;
+	/* queue of struct mie_block */
+	fx_queue r_blocks;
+	/* bst of struct mie_block, as numbered by a depth-first search.
+	 * this ordering is recalculated by mie_region_refresh_dominance */
+	fx_bst r_blocks_s;
 };
 
+MIE_API struct mie_block *mie_region_get_first_block(
+	const struct mie_region *region);
+MIE_API struct mie_block *mie_region_get_prev_block(
+	const struct mie_region *region, const struct mie_block *before);
+MIE_API struct mie_block *mie_region_get_next_block(
+	const struct mie_region *region, const struct mie_block *after);
+MIE_API struct mie_block *mie_region_get_last_block(const struct mie_region *region);
+
 MIE_API struct mie_block *mie_region_add_block(struct mie_region *region);
+MIE_API struct mie_block *mie_region_add_block_before(
+	struct mie_region *region, struct mie_block *before);
+MIE_API struct mie_block *mie_region_add_block_after(
+	struct mie_region *region, struct mie_block *after);
+MIE_API struct mie_block *mie_region_find_block(
+	const struct mie_region *region, const char *name);
+MIE_API struct mie_register *mie_region_find_register(
+	const struct mie_region *region, const char *name);
+
+/* calculate the dominance-tree of all blocks in a region.
+ * this function populates the following attributes of every block in the
+ * region:
+ *   b_id
+ *   fx_node
+ *   fx_parent
+ * as well as the following attributes of the region itself:
+ *   r_blocks_s
+ * only top-level blocks and ops are considered by this function. if an op
+ * within the region itself contains one/more child regions, these are ignored.
+ */
+MIE_API void mie_region_refresh_dominance(struct mie_region *region);
 
 #endif

mie/include/mie/ir/register.h

@@ -30,13 +30,14 @@ struct mie_register_ref {
 
 /* represents a use of/resolved reference to a mie_register */
 struct mie_register_use {
-	b_queue_entry u_entry;
+	fx_queue_entry u_entry;
 	struct mie_op *u_user;
 	struct mie_register *u_reg;
 };
 
 struct mie_register {
 	enum mie_register_flags reg_flags;
+	struct mie_file_span reg_span;
 	union {
 		/* only valid if F_VIRTUAL is set. */
 		struct mie_name reg_name;
@@ -58,7 +59,7 @@ struct mie_register {
 	struct mie_op *reg_op;
 	/* list of struct mie_register_use, representing all the places
 	 * where this register is used. */
-	b_queue reg_use;
+	fx_queue reg_use;
 };
 
 extern struct mie_vector_ops mie_register_vector_ops;

mie/include/mie/ir/resolve.h

@@ -0,0 +1,14 @@
+#ifndef MIE_IR_RESOLVE_H_
+#define MIE_IR_RESOLVE_H_
+
+#include <mie/misc.h>
+#include <stdbool.h>
+
+struct mie_op;
+struct mie_ctx;
+
+MIE_API bool mie_resolve_op_self(struct mie_op *op, struct mie_ctx *ctx);
+MIE_API bool mie_resolve_op_args(struct mie_op *op, struct mie_ctx *ctx);
+MIE_API bool mie_resolve_op_successors(struct mie_op *op, struct mie_ctx *ctx);
+
+#endif

mie/include/mie/ir/rewrite.h

@@ -1,6 +0,0 @@
-#ifndef MIE_IR_REWRITE_H_
-#define MIE_IR_REWRITE_H_
-
-struct mie_rewriter;
-
-#endif

mie/include/mie/ir/walk.h

@@ -1,12 +1,12 @@
 #ifndef MIE_IR_WALK_H_
 #define MIE_IR_WALK_H_
 
+#include <fx/core/queue.h>
 #include <mie/misc.h>
 #include <mie/status.h>
 #include <stddef.h>
 
 struct mie_op;
-struct mie_walker;
 
 enum mie_walker_flags {
 	MIE_WALKER_F_NONE = 0x00u,
@@ -26,19 +26,45 @@ enum mie_walker_flags {
 	MIE_WALKER_F_INCLUDE_BLOCKS = 0x20u,
 };
 
-struct mie_walker_item {
+enum mie_walk_item_type {
+	MIE_WALK_ITEM_NONE = 0,
+	MIE_WALK_ITEM_OP,
+	MIE_WALK_ITEM_BLOCK,
+	MIE_WALK_ITEM_REGION,
+};
+
+struct mie_walk_item {
+	int _f;
+	fx_queue_entry _e;
+	enum mie_walk_item_type i_type;
+	// size_t i_index;
 	size_t i_depth;
+	union {
 		struct mie_op *i_op;
 		struct mie_block *i_block;
 		struct mie_region *i_region;
 	};
+};
 
-MIE_API struct mie_walker *mie_walker_begin(
+struct mie_walker {
-	struct mie_op *op, enum mie_walker_flags flags);
+	enum mie_walker_flags w_flags;
+	union {
+		/* used for recursive walks */
+		fx_queue w_stack;
+		/* used for non-recursive walks */
+		struct {
+			struct mie_walk_item w_region, w_block, w_op;
+		};
+	};
+};
+
+MIE_API void mie_walker_begin(
+	struct mie_walker *walker, const struct mie_op *op,
+	enum mie_walker_flags flags);
 MIE_API void mie_walker_end(struct mie_walker *walker);
 
 MIE_API enum mie_status mie_walker_step(struct mie_walker *walker);
 
-MIE_API struct mie_walker_item *mie_walker_get(struct mie_walker *walker);
+MIE_API struct mie_walk_item *mie_walker_get(struct mie_walker *walker);
 
 #endif

mie/include/mie/macros.h

@@ -25,6 +25,12 @@
 
 #define MIE_DIALECT_INIT(func) func(self)
 #define MIE_DIALECT_CLEANUP(func) self->d_cleanup = (func)
+#define MIE_DIALECT_DIAG_CLASS_LIST(list) \
+        self->d_diag_classes = (list);    \
+        self->d_nr_diag_classes = (list##_count)
+#define MIE_DIALECT_DIAG_MSG_LIST(list) \
+        self->d_diag_msgs = (list);     \
+        self->d_nr_diag_msgs = (list##_count)
 #define MIE_DIALECT_ADD_OP(op_id)                           \
         extern struct mie_op_definition* op_id##_op_create( \
             struct mie_dialect*, struct mie_ctx*);          \
@@ -246,3 +252,83 @@
         } while (0)
 
 #endif
+
+/******************************************************************************/
+/*                          REWRITE PATTERN MACROS                            */
+/******************************************************************************/
+
+#define MIE_REWRITE_PATTERN_BEGIN(name)                                \
+        struct mie_pattern* name##_create(struct mie_pattern_set* set) \
+        {                                                              \
+                struct mie_pattern* self = mie_pattern_set_add(set);   \
+                if (!self) {                                           \
+                        return NULL;                                   \
+                }
+#define MIE_REWRITE_PATTERN_END() \
+        return self;              \
+        }
+
+#define MIE_REWRITE_PATTERN_ROOT(dialect_name, op_name) \
+        self->p_root.t_dialect_name = (dialect_name);   \
+        self->p_root.t_op_name = (op_name)
+#define MIE_REWRITE_PATTERN_MATCH(func) self->p_match = (func)
+#define MIE_REWRITE_PATTERN_REWRITE(func) self->p_rewrite = (func)
+
+/******************************************************************************/
+/*                             DIAG CLASS MACROS                              */
+/******************************************************************************/
+
+#define __MIE_CNAME2(x, y) x##_##y
+#define __MIE_CNAME1(x, y) __MIE_CNAME2(x, y)
+#define __MIE_CNAME(fun) __MIE_CNAME1(MIE_DIAG_CLASS_PREFIX, fun)
+
+#define __MIE_CSNAME2(x, y) #x #y
+#define __MIE_CSNAME1(x, y) __MIE_CSNAME2(x, y)
+#define __MIE_CSNAME(fun) __MIE_CSNAME1(MIE_DIAG_CLASS_PREFIX, fun)
+
+#define MIE_DIAG_CLASS_LIST_EXTERN(list_name)     \
+        extern struct mie_diag_class list_name[]; \
+        extern const size_t list_name##_count
+#define MIE_DIAG_CLASS_LIST_BEGIN(list_name) \
+        struct mie_diag_class list_name[] = {
+#define MIE_DIAG_CLASS_LIST_END(list_name) \
+        }                                  \
+        ;                                  \
+        const size_t list_name##_count = sizeof(list_name) / sizeof(list_name[0]);
+#define MIE_DIAG_CLASS(id, type, title)            \
+        [__MIE_CNAME(id)] = {                      \
+                .c_id = __MIE_CNAME(id),           \
+                .c_type = MIE_DIAG_CLASS_##type,   \
+                .c_title = (title),                \
+                .c_id_str_short = #id,             \
+                .c_id_str_long = __MIE_CSNAME(id), \
+        },
+
+/******************************************************************************/
+/*                              DIAG MSG MACROS                               */
+/******************************************************************************/
+
+#define __MIE_MNAME2(x, y) x##_##y
+#define __MIE_MNAME1(x, y) __MIE_CNAME2(x, y)
+#define __MIE_MNAME(fun) __MIE_CNAME1(MIE_DIAG_MSG_PREFIX, fun)
+
+#define __MIE_MSNAME2(x, y) #x #y
+#define __MIE_MSNAME1(x, y) __MIE_CSNAME2(x, y)
+#define __MIE_MSNAME(fun) __MIE_CSNAME1(MIE_DIAG_MSG_PREFIX, fun)
+
+#define MIE_DIAG_MSG_LIST_EXTERN(list_name)     \
+        extern struct mie_diag_msg list_name[]; \
+        extern const size_t list_name##_count
+#define MIE_DIAG_MSG_LIST_BEGIN(list_name) \
+        struct mie_diag_msg list_name[] = {
+#define MIE_DIAG_MSG_LIST_END(list_name) \
+        }                                \
+        ;                                \
+        const size_t list_name##_count = sizeof(list_name) / sizeof(list_name[0]);
+#define MIE_DIAG_MSG(id, content)                    \
+        [__MIE_MNAME(id)] = {                        \
+                .msg_id = __MIE_MNAME(id),           \
+                .msg_content = (content),            \
+                .msg_id_str_short = #id,             \
+                .msg_id_str_long = __MIE_MSNAME(id), \
+        },

mie/include/mie/name.h

@@ -1,8 +1,8 @@
 #ifndef MIE_NAME_H_
 #define MIE_NAME_H_
 
-#include <blue/core/btree.h>
+#include <fx/core/bst.h>
-#include <blue/core/queue.h>
+#include <fx/core/queue.h>
 #include <mie/misc.h>
 #include <mie/parse/file-span.h>
 
@@ -30,14 +30,14 @@ struct mie_name_map_entry {
 	enum mie_name_map_entry_type e_type;
 	uint64_t e_hash;
 	union {
-		b_queue_entry e_entry;
+		fx_queue_entry e_entry;
-		b_btree_node e_node;
+		fx_bst_node e_node;
 	};
 };
 
 struct mie_name_bucket {
 	struct mie_name_map_entry b_base;
-	b_queue b_names;
+	fx_queue b_names;
 };
 
 /* stores a unique name, and forms a binary tree of similar entries.
@@ -59,12 +59,12 @@ struct mie_name {
 
 	/* if this name was read from a file, these structs can be used to
 	 * record the location within the file where the name is found. */
-	struct mie_file_span n_start, n_end;
+	struct mie_file_span n_span;
 };
 
 struct mie_name_map {
 	const struct mie_name_map *m_parent;
-	b_btree m_entries;
+	fx_bst m_entries;
 	size_t m_next_id;
 };
 

mie/include/mie/parse/lex.h

@@ -1,17 +1,23 @@
 #ifndef MIE_PARSE_LEX_H_
 #define MIE_PARSE_LEX_H_
 
-#include <blue/core/stream.h>
+#include <fx/core/queue.h>
+#include <fx/core/stream.h>
 #include <mie/misc.h>
 #include <mie/status.h>
 
 struct mie_lex;
+struct mie_ctx;
 struct mie_token;
+struct mie_line_source;
 
-MIE_API struct mie_lex *mie_lex_create(b_stream *src);
+MIE_API struct mie_lex *mie_lex_create(
+	struct mie_line_source *src, struct mie_ctx *ctx);
 MIE_API void mie_lex_destroy(struct mie_lex *lex);
 
 MIE_API enum mie_status mie_lex_get_status(const struct mie_lex *lex);
+MIE_API struct mie_line_source *mie_lex_get_line_source(const struct mie_lex *lex);
+MIE_API const struct mie_file_cell *mie_lex_get_cursor(const struct mie_lex *lex);
 MIE_API struct mie_token *mie_lex_peek(struct mie_lex *lex);
 MIE_API void mie_lex_advance(struct mie_lex *lex);
 

mie/include/mie/parse/line-source.h

@@ -0,0 +1,35 @@
+#ifndef MIE_PARSE_LINE_SOURCE_H_
+#define MIE_PARSE_LINE_SOURCE_H_
+
+#include <fx/core/stream.h>
+#include <fx/ds/array.h>
+#include <fx/ds/string.h>
+#include <mie/misc.h>
+#include <mie/parse/file-span.h>
+#include <mie/status.h>
+
+struct mie_line_source {
+	fx_stream *s_stream;
+	const char *s_path;
+	fx_string *s_linebuf;
+	fx_iterator *s_linebuf_ptr;
+	fx_array *s_lines;
+
+	struct mie_file_cell s_cursor;
+};
+
+MIE_API enum mie_status mie_line_source_init(
+	struct mie_line_source *src, const char *path, fx_stream *stream);
+MIE_API void mie_line_source_cleanup(struct mie_line_source *src);
+
+MIE_API const char *mie_line_source_get_path(const struct mie_line_source *src);
+MIE_API const struct mie_file_cell *mie_line_source_get_cursor(
+	const struct mie_line_source *src);
+MIE_API fx_wchar mie_line_source_peekc(struct mie_line_source *src);
+MIE_API fx_wchar mie_line_source_getc(struct mie_line_source *src);
+MIE_API enum mie_status mie_line_source_get_row(
+	struct mie_line_source *src, size_t row, const fx_string **out);
+
+MIE_API bool mie_line_source_input_available(struct mie_line_source *src);
+
+#endif

mie/include/mie/parse/parser.h

@@ -1,7 +1,7 @@
 #ifndef MIE_PARSE_PARSER_H_
 #define MIE_PARSE_PARSER_H_
 
-#include <blue/ds/string.h>
+#include <fx/ds/string.h>
 #include <mie/ir/register.h>
 #include <mie/misc.h>
 #include <mie/parse/token.h>
@@ -25,6 +25,30 @@ struct mie_register;
 struct mie_attribute_map;
 struct mie_attribute;
 
+#define MIE_PARSE_ITEM_NONE {.i_type = MIE_PARSER_ITEM_NONE}
+#define MIE_PARSE_ITEM_TOKEN(tok)                                              \
+	{.i_type = MIE_PARSER_ITEM_TOK, .i_tok = (tok)}
+#define MIE_PARSE_ITEM_CSTR(s) {.i_type = MIE_PARSER_ITEM_CSTR, .i_cstr = (s)}
+
+struct mie_parser_scope {
+	struct mie_region *s_region;
+	struct mie_name_map *s_names;
+};
+
+enum mie_parser_item_type {
+	MIE_PARSER_ITEM_NONE = 0,
+	MIE_PARSER_ITEM_TOK,
+	MIE_PARSER_ITEM_CSTR,
+};
+
+struct mie_parser_item {
+	enum mie_parser_item_type i_type;
+	union {
+		unsigned int i_tok;
+		const char *i_cstr;
+	};
+};
+
 MIE_API struct mie_parser *mie_parser_create(
 	struct mie_ctx *ctx, struct mie_lex *lex);
 MIE_API void mie_parser_destroy(struct mie_parser *ctx);
@@ -33,7 +57,7 @@ MIE_API struct mie_ctx *mie_parser_get_mie_ctx(struct mie_parser *ctx);
 MIE_API struct mie_lex *mie_parser_get_lexer(struct mie_parser *ctx);
 MIE_API enum mie_status mie_parser_get_status(const struct mie_parser *ctx);
 MIE_API void mie_parser_set_status(struct mie_parser *ctx, enum mie_status status);
-MIE_API b_string *mie_parser_get_tempstr(struct mie_parser *ctx);
+MIE_API fx_string *mie_parser_get_tempstr(struct mie_parser *ctx);
 
 MIE_API struct mie_token *mie_parser_peek(struct mie_parser *ctx);
 MIE_API enum mie_token_type mie_parser_peek_type(struct mie_parser *ctx);
@@ -50,38 +74,45 @@ MIE_API bool mie_parser_parse_int(
 MIE_API bool mie_parser_parse_float(
 	struct mie_parser *ctx, double *out, struct mie_file_span *loc);
 MIE_API bool mie_parser_parse_word(
-	struct mie_parser *ctx, b_string *out, struct mie_file_span *loc);
+	struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc);
+MIE_API bool mie_parser_parse_name(
+	struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc);
 MIE_API bool mie_parser_parse_instname(
-	struct mie_parser *ctx, b_string *out, struct mie_file_span *loc);
+	struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc);
 MIE_API bool mie_parser_parse_graphname(
-	struct mie_parser *ctx, b_string *out, struct mie_file_span *loc);
+	struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc);
 MIE_API bool mie_parser_parse_opname(
-	struct mie_parser *ctx, b_string *out, struct mie_file_span *loc);
+	struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc);
 MIE_API bool mie_parser_parse_vregname(
-	struct mie_parser *ctx, b_string *out, struct mie_file_span *loc);
+	struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc);
 MIE_API bool mie_parser_parse_mregname(
-	struct mie_parser *ctx, b_string *out, struct mie_file_span *loc);
+	struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc);
 MIE_API bool mie_parser_parse_blockname(
-	struct mie_parser *ctx, b_string *out, struct mie_file_span *loc);
+	struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc);
 MIE_API bool mie_parser_parse_attribname(
-	struct mie_parser *ctx, b_string *out, struct mie_file_span *loc);
+	struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc);
 MIE_API bool mie_parser_parse_typename(
-	struct mie_parser *ctx, b_string *out, struct mie_file_span *loc);
+	struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc);
 MIE_API bool mie_parser_parse_symname(
-	struct mie_parser *ctx, b_string *out, struct mie_file_span *loc);
+	struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc);
 MIE_API bool mie_parser_parse_string(
-	struct mie_parser *ctx, b_string *out, struct mie_file_span *loc);
+	struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc);
-MIE_API bool mie_parser_parse_keyword(struct mie_parser *ctx, const char *kw);
+MIE_API bool mie_parser_parse_keyword(
+	struct mie_parser *ctx, const char *kw, struct mie_file_span *loc);
 MIE_API bool mie_parser_parse_symbol(
 	struct mie_parser *ctx, enum mie_token_symbol sym);
 MIE_API bool mie_parser_parse_linefeed(struct mie_parser *ctx);
 
 MIE_API bool mie_parser_parse_type(
-	struct mie_parser *ctx, const struct mie_type **out);
+	struct mie_parser *ctx, const char *context,
+	const struct mie_type **out, struct mie_file_span *out_span);
 MIE_API bool mie_parser_parse_type_list(
-	struct mie_parser *ctx, MIE_VECTOR_REF_PARAM(const struct mie_type *, out));
+	struct mie_parser *ctx, const char *context,
+	MIE_VECTOR_REF_PARAM(const struct mie_type *, out),
+	struct mie_file_span *out_span);
 MIE_API bool mie_parser_parse_function_type(
-	struct mie_parser *ctx, struct mie_type **out);
+	struct mie_parser *ctx, const char *context, struct mie_type **out,
+	struct mie_file_span *out_span);
 
 MIE_API bool mie_parser_parse_operand(
 	struct mie_parser *ctx, struct mie_op_arg *out);
@@ -89,31 +120,33 @@ MIE_API bool mie_parser_parse_operand_list(
 	struct mie_parser *ctx, MIE_VECTOR_REF_PARAM(struct mie_op_arg, out));
 
 MIE_API bool mie_parser_parse_parameter(
-	struct mie_parser *ctx, struct mie_op_arg *out);
+	struct mie_parser *ctx, bool include_type, struct mie_op_arg *out,
+	const char *context);
 MIE_API bool mie_parser_parse_parameter_list(
-	struct mie_parser *ctx, MIE_VECTOR_REF_PARAM(struct mie_op_arg, out));
+	struct mie_parser *ctx, bool include_type,
+	MIE_VECTOR_REF_PARAM(struct mie_op_arg, out), const char *context);
 
-MIE_API bool mie_parser_parse_unknown_keyword(struct mie_parser *ctx, b_string *out);
+MIE_API bool mie_parser_parse_unknown_keyword(struct mie_parser *ctx, fx_string *out);
 MIE_API bool mie_parser_parse_unknown_symbol(
 	struct mie_parser *ctx, enum mie_token_symbol sym);
 
 MIE_API bool mie_parser_parse_register(
-	struct mie_parser *ctx, struct mie_name_map *names,
+	struct mie_parser *ctx, struct mie_parser_scope *scope,
-	struct mie_register *out);
+	const char *context, struct mie_register *out);
 MIE_API bool mie_parser_parse_register_list(
-	struct mie_parser *ctx, struct mie_name_map *names,
+	struct mie_parser *ctx, struct mie_parser_scope *scope,
-	MIE_VECTOR_REF_PARAM(struct mie_register, out));
+	const char *context, MIE_VECTOR_REF_PARAM(struct mie_register, out));
 
 MIE_API bool mie_parser_parse_region(
-	struct mie_parser *ctx, struct mie_op *parent, struct mie_region *region);
-MIE_API bool mie_parser_parse_region_list(
 	struct mie_parser *ctx, struct mie_op *parent,
-	MIE_VECTOR_REF_PARAM(struct mie_region, out));
+	struct mie_region *region, struct mie_block *first_block);
+MIE_API bool mie_parser_parse_region_list(
+	struct mie_parser *ctx, struct mie_op *parent);
 MIE_API bool mie_parser_parse_anonymous_block(
-	struct mie_parser *ctx, struct mie_name_map *names,
+	struct mie_parser *ctx, struct mie_parser_scope *scope,
 	struct mie_block *block);
 MIE_API bool mie_parser_parse_block(
-	struct mie_parser *ctx, struct mie_name_map *names,
+	struct mie_parser *ctx, struct mie_parser_scope *scope,
 	struct mie_block *block);
 
 MIE_API bool mie_parser_parse_successor(
@@ -123,11 +156,34 @@ MIE_API bool mie_parser_parse_successor_list(
 
 MIE_API bool mie_parser_parse_module(struct mie_parser *ctx, struct mie_module *mod);
 MIE_API bool mie_parser_parse_op(
-	struct mie_parser *ctx, struct mie_name_map *names, struct mie_op *dest);
+	struct mie_parser *ctx, struct mie_parser_scope *scope,
+	struct mie_op *dest);
 
 MIE_API bool mie_parser_parse_attribute(
 	struct mie_parser *ctx, const struct mie_attribute **dest);
 MIE_API bool mie_parser_parse_attribute_map(
 	struct mie_parser *ctx, struct mie_attribute_map *out);
 
+MIE_API struct mie_diag *mie_parser_report_error_simple(
+	struct mie_parser *parser, const char *dialect, unsigned int diag_class,
+	unsigned int msg, const struct mie_file_span *loc);
+MIE_API void mie_parser_report_unexpected_token_v(
+	struct mie_parser *parser,
+	const struct mie_parser_item expected_tokens[], const char *context);
+MIE_API void mie_parser_report_unexpected_token_s(
+	struct mie_parser *parser, const char *expected_token, const char *context);
+static inline void mie_parser_report_unexpected_token(
+	struct mie_parser *parser, unsigned int expected_token, const char *context)
+{
+	struct mie_parser_item t[]
+		= {MIE_PARSE_ITEM_TOKEN(expected_token), MIE_PARSE_ITEM_NONE};
+	mie_parser_report_unexpected_token_v(parser, t, context);
+}
+
+MIE_API struct mie_name *mie_parser_scope_put_name(
+	struct mie_parser_scope *scope, struct mie_name *entry,
+	const char *hint, enum mie_name_map_flags flags);
+MIE_API struct mie_register *mie_parser_scope_find_value(
+	struct mie_parser_scope *scope, const char *name);
+
 #endif

mie/include/mie/parse/token.h

@@ -1,7 +1,7 @@
 #ifndef MIE_PARSE_TOKEN_H_
 #define MIE_PARSE_TOKEN_H_
 
-#include <blue/core/queue.h>
+#include <fx/core/queue.h>
 #include <mie/misc.h>
 #include <mie/parse/file-span.h>
 
@@ -39,6 +39,7 @@ enum mie_token_type {
 	MIE_TOK_TYPENAME = 0x4000u,
 	/* word or name, prefixed with a # hash */
 	MIE_TOK_ATTRIBNAME = 0x8000u,
+	__MIE_TOK_UBOUND = 0x9000u,
 };
 
 enum mie_token_value_type {
@@ -51,7 +52,7 @@ enum mie_token_value_type {
 
 enum mie_token_symbol {
 	MIE_SYM_NONE = 0,
-	MIE_SYM_COLON,
+	MIE_SYM_COLON = __MIE_TOK_UBOUND,
 	MIE_SYM_EQUAL,
 	MIE_SYM_COMMA,
 	MIE_SYM_HYPHEN,
@@ -64,6 +65,7 @@ enum mie_token_symbol {
 	MIE_SYM_TILDE,
 	MIE_SYM_BANG,
 	MIE_SYM_ATSIGN,
+	MIE_SYM_QUESTION,
 	MIE_SYM_LEFT_BRACE,
 	MIE_SYM_RIGHT_BRACE,
 	MIE_SYM_LEFT_BRACKET,
@@ -80,7 +82,7 @@ struct mie_token {
 	struct mie_file_span tok_location;
 	enum mie_token_type tok_type;
 	enum mie_token_value_type tok_value_type;
-	b_queue_entry tok_entry;
+	fx_queue_entry tok_entry;
 
 	union {
 		char *tok_str;

mie/include/mie/pass/pass-definition.h

@@ -14,6 +14,7 @@
 struct mie_op;
 struct mie_ctx;
 struct mie_pass;
+struct mie_dialect;
 struct mie_op_definition;
 struct mie_trait_definition;
 struct mie_interface_definition;
@@ -40,6 +41,7 @@ struct mie_pass_args {
 };
 
 struct mie_pass_filter {
+	const struct mie_dialect *f_dialect;
 	const struct mie_op_definition *f_op;
 	const struct mie_trait_definition *f_trait;
 	const struct mie_interface_definition *f_iface;

mie/include/mie/print/printer.h

@@ -1,7 +1,7 @@
 #ifndef MIE_PRINT_PRINTER_H_
 #define MIE_PRINT_PRINTER_H_
 
-#include <blue/core/stream.h>
+#include <fx/core/stream.h>
 #include <mie/misc.h>
 #include <mie/status.h>
 
@@ -23,16 +23,18 @@ enum mie_print_flags {
 	MIE_PRINT_F_INCLUDE_TYPE = 0x04u,
 	MIE_PRINT_F_EXCLUDE_BLOCK_HEADER = 0x08u,
 	MIE_PRINT_F_EXCLUDE_FIRST_BLOCK_HEADER = 0x10u,
+
+	MIE_PRINT_F_MARK_UNRESOLVED_ELEMENTS = 0x20u,
 };
 
 struct mie_printer {
 	enum mie_print_flags p_flags;
 	struct mie_ctx *p_mie;
-	b_stream *p_stream;
+	fx_stream *p_stream;
 };
 
 MIE_API enum mie_status mie_printer_init(
-	struct mie_printer *printer, struct mie_ctx *ctx, b_stream *out,
+	struct mie_printer *printer, struct mie_ctx *ctx, fx_stream *out,
 	enum mie_print_flags flags);
 
 MIE_API void mie_printer_print_module(

mie/include/mie/rewrite/convert.h

@@ -0,0 +1,20 @@
+#ifndef MIE_REWRITE_CONVERT_H_
+#define MIE_REWRITE_CONVERT_H_
+
+#include <mie/ctx.h>
+
+struct mie_pattern_set;
+struct mie_convert_config;
+
+MIE_API struct mie_convert_config *mie_convert_config_create(struct mie_ctx *ctx);
+MIE_API void mie_convert_config_destroy(struct mie_convert_config *cfg);
+
+MIE_API enum mie_status mie_convert_config_add_illegal_op(
+	struct mie_convert_config *cfg, const char *dialect_name,
+	const char *op_name);
+
+MIE_API enum mie_status mie_convert_apply(
+	struct mie_op *op, struct mie_convert_config *cfg,
+	struct mie_pattern_set *patterns);
+
+#endif

mie/include/mie/rewrite/greedy.h

@@ -0,0 +1,16 @@
+#ifndef MIE_REWRITE_GREEDY_H_
+#define MIE_REWRITE_GREEDY_H_
+
+#include <mie/ctx.h>
+
+struct mie_pattern_set;
+struct mie_greedy_config;
+
+MIE_API struct mie_greedy_config *mie_greedy_config_create(struct mie_ctx *ctx);
+MIE_API void mie_greedy_config_destroy(struct mie_greedy_config *cfg);
+
+MIE_API enum mie_status mie_greedy_apply(
+	struct mie_op *op, struct mie_greedy_config *cfg,
+	struct mie_pattern_set *patterns);
+
+#endif

mie/include/mie/rewrite/pattern.h

@@ -0,0 +1,54 @@
+#ifndef MIE_REWRITE_PATTERN_H_
+#define MIE_REWRITE_PATTERN_H_
+
+#include <mie/vector.h>
+
+#define MIE_REWRITE_RESULT(result, status)                                     \
+	((struct mie_rewrite_result) {.r_result = (result), .r_status = (status)})
+
+struct mie_op;
+struct mie_rewriter;
+
+enum mie_match_result {
+	MIE_NO_MATCH_FOUND = 0,
+	MIE_MATCH_FOUND,
+};
+
+struct mie_rewrite_result {
+	enum {
+		MIE_REWRITE_SUCCESS = 0,
+		MIE_REWRITE_IGNORE,
+		MIE_REWRITE_FAILURE,
+	} r_result;
+	enum mie_status r_status;
+};
+
+struct mie_pattern {
+	struct {
+		const char *t_dialect_name, *t_op_name;
+		const struct mie_op_definition *t_op;
+	} p_root;
+
+	enum mie_match_result (*p_match)(const struct mie_op *);
+	struct mie_rewrite_result (*p_rewrite)(
+		struct mie_op *, struct mie_rewriter *);
+};
+
+struct mie_pattern_set {
+	MIE_VECTOR_DECLARE(struct mie_pattern, s_patterns);
+};
+
+MIE_API void mie_pattern_set_init(struct mie_pattern_set *set);
+MIE_API void mie_pattern_set_cleanup(struct mie_pattern_set *set);
+
+MIE_API struct mie_pattern *mie_pattern_set_add(struct mie_pattern_set *set);
+MIE_API struct mie_pattern *mie_pattern_set_match(
+	struct mie_pattern_set *set, const struct mie_op *op);
+
+MIE_API enum mie_match_result mie_pattern_match(
+	const struct mie_pattern *pattern, const struct mie_op *op);
+MIE_API struct mie_rewrite_result mie_pattern_rewrite(
+	const struct mie_pattern *pattern, struct mie_op *op,
+	struct mie_rewriter *rewriter);
+
+#endif

mie/include/mie/rewrite/rewriter.h

@@ -0,0 +1,117 @@
+#ifndef MIE_IR_REWRITE_H_
+#define MIE_IR_REWRITE_H_
+
+#include <mie/ir/emit.h>
+#include <mie/misc.h>
+#include <mie/status.h>
+#include <mie/vector.h>
+#include <stddef.h>
+
+struct mie_op;
+struct mie_ctx;
+struct mie_type;
+struct mie_region;
+struct mie_register;
+struct mie_op_successor;
+
+struct mie_rewriter {
+	struct mie_emitter r_base;
+	struct mie_ctx *r_ctx;
+	/* anything ops added to the IR are inserted in this block. */
+	struct mie_block *r_insert_block;
+	/* anything ops added to the IR are inserted after this op.
+	 * if this is null, the insertion point is the end of r_insert_block. */
+	struct mie_op *r_insert_point;
+};
+
+MIE_API void mie_rewriter_init(struct mie_rewriter *rw, struct mie_ctx *ctx);
+MIE_API void mie_rewriter_cleanup(struct mie_rewriter *rw);
+
+MIE_API struct mie_ctx *mie_rewriter_get_ctx(const struct mie_rewriter *rw);
+
+MIE_API struct mie_block *mie_rewriter_get_insertion_block(struct mie_rewriter *rw);
+MIE_API struct mie_op *mie_rewriter_get_insertion_point(struct mie_rewriter *rw);
+
+MIE_API struct mie_block *mie_rewriter_set_insertion_block(
+	struct mie_rewriter *rw, struct mie_block *block);
+MIE_API struct mie_op *mie_rewriter_set_insertion_point(
+	struct mie_rewriter *rw, struct mie_op *insert_point);
+
+MIE_API struct mie_block *mie_rewriter_split_block(
+	struct mie_rewriter *rw, struct mie_block *block, struct mie_op *before,
+	const char *name);
+MIE_API struct mie_block *mie_rewriter_create_block(
+	struct mie_rewriter *rw, struct mie_block *insert_before, const char *name);
+MIE_API struct mie_register *mie_rewriter_add_block_parameter(
+	struct mie_rewriter *rw, struct mie_block *block, const char *name,
+	const struct mie_type *type);
+
+MIE_API enum mie_status mie_rewriter_move_block_to_start(
+	struct mie_rewriter *rw, struct mie_block *block,
+	struct mie_region *from, struct mie_region *to);
+MIE_API enum mie_status mie_rewriter_move_block_to_end(
+	struct mie_rewriter *rw, struct mie_block *block,
+	struct mie_region *from, struct mie_region *to);
+MIE_API enum mie_status mie_rewriter_move_block_before(
+	struct mie_rewriter *rw, struct mie_block *block,
+	struct mie_region *from, struct mie_region *to, struct mie_block *before);
+MIE_API enum mie_status mie_rewriter_move_block_after(
+	struct mie_rewriter *rw, struct mie_block *block,
+	struct mie_region *from, struct mie_region *to, struct mie_block *after);
+
+MIE_API enum mie_status mie_rewriter_rename_block(
+	struct mie_rewriter *rw, struct mie_block *block, const char *name);
+
+MIE_API enum mie_status mie_rewriter_move_blocks_to_start(
+	struct mie_rewriter *rw, struct mie_region *from, struct mie_region *to);
+MIE_API enum mie_status mie_rewriter_move_blocks_to_end(
+	struct mie_rewriter *rw, struct mie_region *from, struct mie_region *to);
+MIE_API enum mie_status mie_rewriter_move_blocks_before(
+	struct mie_rewriter *rw, struct mie_region *from, struct mie_region *to,
+	struct mie_block *before);
+MIE_API enum mie_status mie_rewriter_move_blocks_after(
+	struct mie_rewriter *rw, struct mie_region *from, struct mie_region *to,
+	struct mie_block *after);
+
+MIE_API enum mie_status mie_rewriter_move_region_to_start(
+	struct mie_rewriter *rw, struct mie_region *region, struct mie_op *from,
+	struct mie_op *to);
+MIE_API enum mie_status mie_rewriter_move_region_to_end(
+	struct mie_rewriter *rw, struct mie_region *region, struct mie_op *from,
+	struct mie_op *to);
+MIE_API enum mie_status mie_rewriter_move_region_before(
+	struct mie_rewriter *rw, struct mie_region *region, struct mie_op *from,
+	struct mie_op *to, struct mie_region *before);
+MIE_API enum mie_status mie_rewriter_move_region_after(
+	struct mie_rewriter *rw, struct mie_region *region, struct mie_op *from,
+	struct mie_op *to, struct mie_region *after);
+
+MIE_API struct mie_op *mie_rewriter_put_op(
+	struct mie_rewriter *rw, const char *dialect, const char *op,
+	struct mie_register **args, size_t nr_args);
+MIE_API struct mie_op *mie_rewriter_replace_op(
+	struct mie_rewriter *rw, struct mie_op *op, const char *dialect_name,
+	const char *op_name);
+MIE_API struct mie_op_successor *mie_rewriter_add_op_successor(
+	struct mie_rewriter *rw, struct mie_op *op, struct mie_block *dest,
+	struct mie_register **args, size_t nr_args);
+MIE_API struct mie_op_arg *mie_rewriter_add_op_successor_arg(
+	struct mie_rewriter *rw, struct mie_op *op, struct mie_op_successor *s,
+	struct mie_register *reg);
+MIE_API struct mie_op_arg *mie_rewriter_add_op_arg(
+	struct mie_rewriter *rw, struct mie_op *op, struct mie_register *reg);
+MIE_API enum mie_status mie_rewriter_erase_op(
+	struct mie_rewriter *rw, struct mie_op *op);
+MIE_API enum mie_status mie_rewriter_move_op_args_to_successor(
+	struct mie_rewriter *rw, struct mie_op *op, struct mie_op_successor *s);
+
+MIE_API enum mie_status mie_rewriter_replace_register(
+	struct mie_rewriter *rw, struct mie_register *old,
+	struct mie_register *new);
+MIE_API enum mie_status mie_rewriter_rename_register(
+	struct mie_rewriter *rw, struct mie_register *reg, const char *name);
+
+MIE_API enum mie_status mie_rewriter_put_name(
+	struct mie_rewriter *rw, struct mie_name *name, const char *hint);
+
+#endif

mie/include/mie/status.h

@@ -5,7 +5,7 @@
 
 #define MIE_ERROR_VENDOR (ivy_error_vendor())
 
-struct b_error_vendor;
+struct fx_error_vendor;
 
 enum mie_status {
 	MIE_SUCCESS = 0,
@@ -23,6 +23,6 @@ enum mie_status {
 	MIE_ERR_INTERNAL_FAILURE,
 };
 
-MIE_API const struct b_error_vendor *mie_error_vendor(void);
+MIE_API const struct fx_error_vendor *mie_error_vendor(void);
 
 #endif

mie/include/mie/trait/trait-definition.h

@@ -1,7 +1,7 @@
 #ifndef MIE_TRAIT_TRAIT_DEFINITION_H_
 #define MIE_TRAIT_TRAIT_DEFINITION_H_
 
-#include <blue/core/stream.h>
+#include <fx/core/stream.h>
 #include <mie/id.h>
 #include <mie/status.h>
 
@@ -50,7 +50,7 @@ struct mie_trait_definition {
 		struct mie_id_builder *);
 	enum mie_status (*tr_print)(
 		const struct mie_trait_definition *, const struct mie_trait *,
-		b_stream *);
+		fx_stream *);
 	enum mie_status (*tr_cleanup)(
 		const struct mie_trait_definition *, struct mie_trait *);
 	enum mie_status (*tr_validate)(

mie/include/mie/trait/trait-table.h

@@ -1,7 +1,7 @@
 #ifndef MIE_TRAIT_TRAIT_TABLE_H_
 #define MIE_TRAIT_TRAIT_TABLE_H_
 
-#include <blue/core/btree.h>
+#include <fx/core/bst.h>
 #include <mie/id.h>
 #include <mie/misc.h>
 #include <mie/status.h>
@@ -18,7 +18,7 @@ struct mie_trait_table_iterator {
 	int _f;
 	struct mie_id_map_iterator _n;
 	const struct mie_trait_table *_m;
-	b_queue_entry *_e;
+	fx_queue_entry *_e;
 };
 
 MIE_API void mie_trait_table_init(struct mie_trait_table *out);

mie/include/mie/trait/trait.h

@@ -15,6 +15,6 @@ struct mie_trait {
 	const struct mie_trait_definition *tr_def;
 };
 
-MIE_API void mie_trait_print(const struct mie_trait *type, b_stream *out);
+MIE_API void mie_trait_print(const struct mie_trait *type, fx_stream *out);
 
 #endif