From 7e4067c44ceb21b4ca0ce89e501df1bf9de106b7 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 12 Jan 2022 19:18:54 +0000
Subject: Begin work to move entry point code to Odin itself rather than in C++
 side

---
 core/runtime/procs_windows_amd64.odin | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'core/runtime')

diff --git a/core/runtime/procs_windows_amd64.odin b/core/runtime/procs_windows_amd64.odin
index 273bb57b2..e430357be 100644
--- a/core/runtime/procs_windows_amd64.odin
+++ b/core/runtime/procs_windows_amd64.odin
@@ -22,4 +22,4 @@ windows_trap_type_assertion :: proc "contextless" () -> ! {
 when ODIN_NO_CRT {
 	@(require)
 	foreign import crt_lib "procs_windows_amd64.asm"
-}
\ No newline at end of file
+}
-- 
cgit v1.2.3


From f1521aa980da5753a6ba6ea951d1cb2ebfd0e66a Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 12 Jan 2022 20:10:23 +0000
Subject: Add proc_windows.odin for custom entry points

---
 core/runtime/proc_windows.odin | 44 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 core/runtime/proc_windows.odin

(limited to 'core/runtime')

diff --git a/core/runtime/proc_windows.odin b/core/runtime/proc_windows.odin
new file mode 100644
index 000000000..ba3a2b9d8
--- /dev/null
+++ b/core/runtime/proc_windows.odin
@@ -0,0 +1,44 @@
+//+private
+//+build windows
+package runtime
+
+import "core:intrinsics"
+
+when ODIN_BUILD_MODE == "dynamic" {
+	@(link_name="DllMain", linkage="strong", require)
+	DllMain :: proc "stdcall" (hinstDLL: rawptr, fdwReason: u32, lpReserved: rawptr) -> b32 {
+		context = default_context()
+		switch fdwReason {
+		case 1: // DLL_PROCESS_ATTACH
+			#force_no_inline _startup_runtime()
+			intrinsics.__entry_point()
+		case 0: // DLL_PROCESS_DETACH
+			#force_no_inline _cleanup_runtime()
+		case 2: // DLL_THREAD_ATTACH
+			break
+		case 3: // DLL_THREAD_DETACH
+			break
+		}
+		return true
+	}
+} else when !ODIN_TEST && !ODIN_NO_ENTRY_POINT {
+	when ODIN_ARCH == "386" || ODIN_NO_CRT {
+		@(link_name="mainCRTStartup", linkage="strong", require)
+		mainCRTStartup :: proc "stdcall" () -> i32 {
+			context = default_context()
+			#force_no_inline _startup_runtime()
+			intrinsics.__entry_point()
+			#force_no_inline _cleanup_runtime()
+			return 0
+		}
+	} else {
+		@(link_name="main", linkage="strong", require)
+		main :: proc "c" (argc: i32, argv: [^]cstring) -> i32 {
+			context = default_context()
+			#force_no_inline _startup_runtime()
+			intrinsics.__entry_point()
+			#force_no_inline _cleanup_runtime()
+			return 0
+		}
+	}
+}
\ No newline at end of file
-- 
cgit v1.2.3


From 75b7f2b9feada3cf6ed8aab5142e078d7b07ed59 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 12 Jan 2022 20:13:38 +0000
Subject: Correct `-init` for *nix to be a different procedure

---
 core/runtime/proc_unix.odin | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 core/runtime/proc_unix.odin

(limited to 'core/runtime')

diff --git a/core/runtime/proc_unix.odin b/core/runtime/proc_unix.odin
new file mode 100644
index 000000000..7e0d1055a
--- /dev/null
+++ b/core/runtime/proc_unix.odin
@@ -0,0 +1,18 @@
+//+private
+//+build linux, darwin
+package runtime
+
+import "core:intrinsics"
+
+when ODIN_BUILD_MODE == "dynamic" {
+	@(link_name="_odin_entry_point", linkage="strong", require)
+	_odin_entry_point :: proc "c" () {
+		context = default_context()
+		#force_no_inline _startup_runtime()
+	}
+	@(link_name="_odin_exit_point", linkage="strong", require)
+	_odin_exit_point :: proc "c" () {
+		context = default_context()
+		#force_no_inline _cleanup_runtime()
+	}
+}
\ No newline at end of file
-- 
cgit v1.2.3


From 6209b02bf9d8dc05c34754beded39c4b80f1d8c6 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 12 Jan 2022 20:16:04 +0000
Subject: Add `intrinsics._entry_point` call to `_odin_entry_point`

---
 core/runtime/proc_unix.odin | 1 +
 1 file changed, 1 insertion(+)

(limited to 'core/runtime')

diff --git a/core/runtime/proc_unix.odin b/core/runtime/proc_unix.odin
index 7e0d1055a..cb3199ad1 100644
--- a/core/runtime/proc_unix.odin
+++ b/core/runtime/proc_unix.odin
@@ -9,6 +9,7 @@ when ODIN_BUILD_MODE == "dynamic" {
 	_odin_entry_point :: proc "c" () {
 		context = default_context()
 		#force_no_inline _startup_runtime()
+		intrinsics._odin_entry_point()
 	}
 	@(link_name="_odin_exit_point", linkage="strong", require)
 	_odin_exit_point :: proc "c" () {
-- 
cgit v1.2.3


From 7df93ea5044bcc4cb5d9bb15a511b449225b2182 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 12 Jan 2022 20:16:46 +0000
Subject: Initialize `runtime.args__` through `main`

---
 core/runtime/proc_windows.odin | 1 +
 1 file changed, 1 insertion(+)

(limited to 'core/runtime')

diff --git a/core/runtime/proc_windows.odin b/core/runtime/proc_windows.odin
index ba3a2b9d8..ef8b0c529 100644
--- a/core/runtime/proc_windows.odin
+++ b/core/runtime/proc_windows.odin
@@ -34,6 +34,7 @@ when ODIN_BUILD_MODE == "dynamic" {
 	} else {
 		@(link_name="main", linkage="strong", require)
 		main :: proc "c" (argc: i32, argv: [^]cstring) -> i32 {
+			args__ = argv[:argc]
 			context = default_context()
 			#force_no_inline _startup_runtime()
 			intrinsics.__entry_point()
-- 
cgit v1.2.3


From 8f038118420ecbca072017b4f0379603688389c4 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 12 Jan 2022 20:30:34 +0000
Subject: Fix typo

---
 core/runtime/proc_unix.odin | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'core/runtime')

diff --git a/core/runtime/proc_unix.odin b/core/runtime/proc_unix.odin
index cb3199ad1..2a62c8d8f 100644
--- a/core/runtime/proc_unix.odin
+++ b/core/runtime/proc_unix.odin
@@ -9,7 +9,7 @@ when ODIN_BUILD_MODE == "dynamic" {
 	_odin_entry_point :: proc "c" () {
 		context = default_context()
 		#force_no_inline _startup_runtime()
-		intrinsics._odin_entry_point()
+		intrinsics.__entry_point()
 	}
 	@(link_name="_odin_exit_point", linkage="strong", require)
 	_odin_exit_point :: proc "c" () {
-- 
cgit v1.2.3


From 80f175cdb0fe13b4bd83239373f890c155b1ecf5 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 12 Jan 2022 20:40:34 +0000
Subject: Add empty `main` dynamic builds for *nix systems

---
 core/runtime/proc_unix.odin | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'core/runtime')

diff --git a/core/runtime/proc_unix.odin b/core/runtime/proc_unix.odin
index 2a62c8d8f..119ce3718 100644
--- a/core/runtime/proc_unix.odin
+++ b/core/runtime/proc_unix.odin
@@ -16,4 +16,8 @@ when ODIN_BUILD_MODE == "dynamic" {
 		context = default_context()
 		#force_no_inline _cleanup_runtime()
 	}
+	@(link_name="main", linkage="strong", require)
+	main :: proc(argc: i32, argv: [^]cstring) -> i32 {
+		return 0
+	}
 }
\ No newline at end of file
-- 
cgit v1.2.3


From c9bc7596240ac3c18d48c0545f478e08b0c2a23e Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 12 Jan 2022 23:04:31 +0000
Subject: Correct calling convention

---
 core/runtime/proc_unix.odin | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'core/runtime')

diff --git a/core/runtime/proc_unix.odin b/core/runtime/proc_unix.odin
index 119ce3718..eb656f39b 100644
--- a/core/runtime/proc_unix.odin
+++ b/core/runtime/proc_unix.odin
@@ -17,7 +17,7 @@ when ODIN_BUILD_MODE == "dynamic" {
 		#force_no_inline _cleanup_runtime()
 	}
 	@(link_name="main", linkage="strong", require)
-	main :: proc(argc: i32, argv: [^]cstring) -> i32 {
+	main :: proc "c" (argc: i32, argv: [^]cstring) -> i32 {
 		return 0
 	}
 }
\ No newline at end of file
-- 
cgit v1.2.3


From 315a08f33f0d3ae9c16377c5a077733824d301d4 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Thu, 13 Jan 2022 12:04:42 +0000
Subject: Add `main` to proc_unix.odin

---
 core/runtime/proc_unix.odin | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

(limited to 'core/runtime')

diff --git a/core/runtime/proc_unix.odin b/core/runtime/proc_unix.odin
index eb656f39b..38116c0f9 100644
--- a/core/runtime/proc_unix.odin
+++ b/core/runtime/proc_unix.odin
@@ -1,17 +1,17 @@
 //+private
-//+build linux, darwin
+//+build linux, darwin, freebsd
 package runtime
 
 import "core:intrinsics"
 
 when ODIN_BUILD_MODE == "dynamic" {
-	@(link_name="_odin_entry_point", linkage="strong", require)
+	@(link_name="_odin_entry_point", linkage="strong", require, link_section=".init")
 	_odin_entry_point :: proc "c" () {
 		context = default_context()
 		#force_no_inline _startup_runtime()
 		intrinsics.__entry_point()
 	}
-	@(link_name="_odin_exit_point", linkage="strong", require)
+	@(link_name="_odin_exit_point", linkage="strong", require, link_section=".fini")
 	_odin_exit_point :: proc "c" () {
 		context = default_context()
 		#force_no_inline _cleanup_runtime()
@@ -20,4 +20,14 @@ when ODIN_BUILD_MODE == "dynamic" {
 	main :: proc "c" (argc: i32, argv: [^]cstring) -> i32 {
 		return 0
 	}
+} else when !ODIN_TEST && !ODIN_NO_ENTRY_POINT {
+	@(link_name="main", linkage="strong", require)
+	main :: proc "c" (argc: i32, argv: [^]cstring) -> i32 {
+		args__ = argv[:argc]
+		context = default_context()
+		#force_no_inline _startup_runtime()
+		intrinsics.__entry_point()
+		#force_no_inline _cleanup_runtime()
+		return 0
+	}
 }
\ No newline at end of file
-- 
cgit v1.2.3


From b33ca6651e442c2ff6122cbdadedec782cb376c9 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Thu, 13 Jan 2022 12:05:22 +0000
Subject: Rename `proc_*` to `entry_*`

---
 core/runtime/entry_unix.odin    | 33 ++++++++++++++++++++++++++++++
 core/runtime/entry_windows.odin | 45 +++++++++++++++++++++++++++++++++++++++++
 core/runtime/proc_unix.odin     | 33 ------------------------------
 core/runtime/proc_windows.odin  | 45 -----------------------------------------
 4 files changed, 78 insertions(+), 78 deletions(-)
 create mode 100644 core/runtime/entry_unix.odin
 create mode 100644 core/runtime/entry_windows.odin
 delete mode 100644 core/runtime/proc_unix.odin
 delete mode 100644 core/runtime/proc_windows.odin

(limited to 'core/runtime')

diff --git a/core/runtime/entry_unix.odin b/core/runtime/entry_unix.odin
new file mode 100644
index 000000000..38116c0f9
--- /dev/null
+++ b/core/runtime/entry_unix.odin
@@ -0,0 +1,33 @@
+//+private
+//+build linux, darwin, freebsd
+package runtime
+
+import "core:intrinsics"
+
+when ODIN_BUILD_MODE == "dynamic" {
+	@(link_name="_odin_entry_point", linkage="strong", require, link_section=".init")
+	_odin_entry_point :: proc "c" () {
+		context = default_context()
+		#force_no_inline _startup_runtime()
+		intrinsics.__entry_point()
+	}
+	@(link_name="_odin_exit_point", linkage="strong", require, link_section=".fini")
+	_odin_exit_point :: proc "c" () {
+		context = default_context()
+		#force_no_inline _cleanup_runtime()
+	}
+	@(link_name="main", linkage="strong", require)
+	main :: proc "c" (argc: i32, argv: [^]cstring) -> i32 {
+		return 0
+	}
+} else when !ODIN_TEST && !ODIN_NO_ENTRY_POINT {
+	@(link_name="main", linkage="strong", require)
+	main :: proc "c" (argc: i32, argv: [^]cstring) -> i32 {
+		args__ = argv[:argc]
+		context = default_context()
+		#force_no_inline _startup_runtime()
+		intrinsics.__entry_point()
+		#force_no_inline _cleanup_runtime()
+		return 0
+	}
+}
\ No newline at end of file
diff --git a/core/runtime/entry_windows.odin b/core/runtime/entry_windows.odin
new file mode 100644
index 000000000..ef8b0c529
--- /dev/null
+++ b/core/runtime/entry_windows.odin
@@ -0,0 +1,45 @@
+//+private
+//+build windows
+package runtime
+
+import "core:intrinsics"
+
+when ODIN_BUILD_MODE == "dynamic" {
+	@(link_name="DllMain", linkage="strong", require)
+	DllMain :: proc "stdcall" (hinstDLL: rawptr, fdwReason: u32, lpReserved: rawptr) -> b32 {
+		context = default_context()
+		switch fdwReason {
+		case 1: // DLL_PROCESS_ATTACH
+			#force_no_inline _startup_runtime()
+			intrinsics.__entry_point()
+		case 0: // DLL_PROCESS_DETACH
+			#force_no_inline _cleanup_runtime()
+		case 2: // DLL_THREAD_ATTACH
+			break
+		case 3: // DLL_THREAD_DETACH
+			break
+		}
+		return true
+	}
+} else when !ODIN_TEST && !ODIN_NO_ENTRY_POINT {
+	when ODIN_ARCH == "386" || ODIN_NO_CRT {
+		@(link_name="mainCRTStartup", linkage="strong", require)
+		mainCRTStartup :: proc "stdcall" () -> i32 {
+			context = default_context()
+			#force_no_inline _startup_runtime()
+			intrinsics.__entry_point()
+			#force_no_inline _cleanup_runtime()
+			return 0
+		}
+	} else {
+		@(link_name="main", linkage="strong", require)
+		main :: proc "c" (argc: i32, argv: [^]cstring) -> i32 {
+			args__ = argv[:argc]
+			context = default_context()
+			#force_no_inline _startup_runtime()
+			intrinsics.__entry_point()
+			#force_no_inline _cleanup_runtime()
+			return 0
+		}
+	}
+}
\ No newline at end of file
diff --git a/core/runtime/proc_unix.odin b/core/runtime/proc_unix.odin
deleted file mode 100644
index 38116c0f9..000000000
--- a/core/runtime/proc_unix.odin
+++ /dev/null
@@ -1,33 +0,0 @@
-//+private
-//+build linux, darwin, freebsd
-package runtime
-
-import "core:intrinsics"
-
-when ODIN_BUILD_MODE == "dynamic" {
-	@(link_name="_odin_entry_point", linkage="strong", require, link_section=".init")
-	_odin_entry_point :: proc "c" () {
-		context = default_context()
-		#force_no_inline _startup_runtime()
-		intrinsics.__entry_point()
-	}
-	@(link_name="_odin_exit_point", linkage="strong", require, link_section=".fini")
-	_odin_exit_point :: proc "c" () {
-		context = default_context()
-		#force_no_inline _cleanup_runtime()
-	}
-	@(link_name="main", linkage="strong", require)
-	main :: proc "c" (argc: i32, argv: [^]cstring) -> i32 {
-		return 0
-	}
-} else when !ODIN_TEST && !ODIN_NO_ENTRY_POINT {
-	@(link_name="main", linkage="strong", require)
-	main :: proc "c" (argc: i32, argv: [^]cstring) -> i32 {
-		args__ = argv[:argc]
-		context = default_context()
-		#force_no_inline _startup_runtime()
-		intrinsics.__entry_point()
-		#force_no_inline _cleanup_runtime()
-		return 0
-	}
-}
\ No newline at end of file
diff --git a/core/runtime/proc_windows.odin b/core/runtime/proc_windows.odin
deleted file mode 100644
index ef8b0c529..000000000
--- a/core/runtime/proc_windows.odin
+++ /dev/null
@@ -1,45 +0,0 @@
-//+private
-//+build windows
-package runtime
-
-import "core:intrinsics"
-
-when ODIN_BUILD_MODE == "dynamic" {
-	@(link_name="DllMain", linkage="strong", require)
-	DllMain :: proc "stdcall" (hinstDLL: rawptr, fdwReason: u32, lpReserved: rawptr) -> b32 {
-		context = default_context()
-		switch fdwReason {
-		case 1: // DLL_PROCESS_ATTACH
-			#force_no_inline _startup_runtime()
-			intrinsics.__entry_point()
-		case 0: // DLL_PROCESS_DETACH
-			#force_no_inline _cleanup_runtime()
-		case 2: // DLL_THREAD_ATTACH
-			break
-		case 3: // DLL_THREAD_DETACH
-			break
-		}
-		return true
-	}
-} else when !ODIN_TEST && !ODIN_NO_ENTRY_POINT {
-	when ODIN_ARCH == "386" || ODIN_NO_CRT {
-		@(link_name="mainCRTStartup", linkage="strong", require)
-		mainCRTStartup :: proc "stdcall" () -> i32 {
-			context = default_context()
-			#force_no_inline _startup_runtime()
-			intrinsics.__entry_point()
-			#force_no_inline _cleanup_runtime()
-			return 0
-		}
-	} else {
-		@(link_name="main", linkage="strong", require)
-		main :: proc "c" (argc: i32, argv: [^]cstring) -> i32 {
-			args__ = argv[:argc]
-			context = default_context()
-			#force_no_inline _startup_runtime()
-			intrinsics.__entry_point()
-			#force_no_inline _cleanup_runtime()
-			return 0
-		}
-	}
-}
\ No newline at end of file
-- 
cgit v1.2.3


From e15f71466005ff84c6dc97cbfbd10d57f1193e7a Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Thu, 13 Jan 2022 15:18:47 +0000
Subject: Define wasm `_start` entry point in Odin code

---
 core/runtime/entry_wasm.odin | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 core/runtime/entry_wasm.odin

(limited to 'core/runtime')

diff --git a/core/runtime/entry_wasm.odin b/core/runtime/entry_wasm.odin
new file mode 100644
index 000000000..125abc756
--- /dev/null
+++ b/core/runtime/entry_wasm.odin
@@ -0,0 +1,19 @@
+//+private
+//+build wasm32, wasm64
+package runtime
+
+import "core:intrinsics"
+
+when !ODIN_TEST && !ODIN_NO_ENTRY_POINT {
+	@(link_name="_start", linkage="strong", require, export)
+	_start :: proc "c" () {
+		context = default_context()
+		#force_no_inline _startup_runtime()
+		intrinsics.__entry_point()
+	}
+	@(link_name="_end", linkage="strong", require, export)
+	_end :: proc "c" () {
+		context = default_context()
+		#force_no_inline _cleanup_runtime()
+	}
+}
\ No newline at end of file
-- 
cgit v1.2.3


From 6c4867081985a8dd1cccb3e5c503d72807e4ee87 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sat, 15 Jan 2022 17:34:35 +0000
Subject: Make `ODIN_BUILD_MODE` a enum type

---
 core/runtime/core.odin          |  13 +++++
 core/runtime/entry_unix.odin    |   2 +-
 core/runtime/entry_windows.odin |   2 +-
 core/runtime/internal.odin      |   2 +-
 src/build_settings.cpp          |  23 ++-------
 src/check_expr.cpp              | 112 ++++++++++++++++++++++------------------
 src/checker.cpp                 |  64 ++++++++++++++++++++++-
 7 files changed, 144 insertions(+), 74 deletions(-)

(limited to 'core/runtime')

diff --git a/core/runtime/core.odin b/core/runtime/core.odin
index be30eef02..91b6bf5ca 100644
--- a/core/runtime/core.odin
+++ b/core/runtime/core.odin
@@ -386,6 +386,19 @@ Raw_Cstring :: struct {
 }
 
 
+/*
+	// Defined internally by the compiler
+	Odin_Build_Mode_Type :: enum int {
+		Executable,
+		Dynamic,
+		Object,
+		Assembly,
+		LLVM_IR,
+	}
+*/
+Odin_Build_Mode_Type :: type_of(ODIN_BUILD_MODE)
+
+
 /////////////////////////////
 // Init Startup Procedures //
 /////////////////////////////
diff --git a/core/runtime/entry_unix.odin b/core/runtime/entry_unix.odin
index 38116c0f9..67d2cbcb7 100644
--- a/core/runtime/entry_unix.odin
+++ b/core/runtime/entry_unix.odin
@@ -4,7 +4,7 @@ package runtime
 
 import "core:intrinsics"
 
-when ODIN_BUILD_MODE == "dynamic" {
+when ODIN_BUILD_MODE == .Dynamic {
 	@(link_name="_odin_entry_point", linkage="strong", require, link_section=".init")
 	_odin_entry_point :: proc "c" () {
 		context = default_context()
diff --git a/core/runtime/entry_windows.odin b/core/runtime/entry_windows.odin
index ef8b0c529..97a5bebe6 100644
--- a/core/runtime/entry_windows.odin
+++ b/core/runtime/entry_windows.odin
@@ -4,7 +4,7 @@ package runtime
 
 import "core:intrinsics"
 
-when ODIN_BUILD_MODE == "dynamic" {
+when ODIN_BUILD_MODE == .Dynamic {
 	@(link_name="DllMain", linkage="strong", require)
 	DllMain :: proc "stdcall" (hinstDLL: rawptr, fdwReason: u32, lpReserved: rawptr) -> b32 {
 		context = default_context()
diff --git a/core/runtime/internal.odin b/core/runtime/internal.odin
index 6498c4db7..7b283a132 100644
--- a/core/runtime/internal.odin
+++ b/core/runtime/internal.odin
@@ -8,7 +8,7 @@ IS_WASM :: ODIN_ARCH == "wasm32" || ODIN_ARCH == "wasm64"
 @(private)
 RUNTIME_LINKAGE :: "strong" when (
 	(ODIN_USE_SEPARATE_MODULES || 
-	ODIN_BUILD_MODE == "dynamic" || 
+	ODIN_BUILD_MODE == .Dynamic ||
 	!ODIN_NO_CRT) &&
 	!IS_WASM) else "internal"
 RUNTIME_REQUIRE :: true
diff --git a/src/build_settings.cpp b/src/build_settings.cpp
index ccae0fcf0..bafa93042 100644
--- a/src/build_settings.cpp
+++ b/src/build_settings.cpp
@@ -119,6 +119,8 @@ enum BuildModeKind {
 	BuildMode_Object,
 	BuildMode_Assembly,
 	BuildMode_LLVM_IR,
+
+	BuildMode_COUNT,
 };
 
 enum CommandKind : u32 {
@@ -172,10 +174,9 @@ struct BuildContext {
 	String ODIN_VENDOR;  // compiler vendor
 	String ODIN_VERSION; // compiler version
 	String ODIN_ROOT;    // Odin ROOT
-	String ODIN_BUILD_MODE;
 	bool   ODIN_DEBUG;   // Odin in debug mode
 	bool   ODIN_DISABLE_ASSERT; // Whether the default 'assert' et al is disabled in code or not
-	bool   ODIN_DEFAULT_TO_NIL_ALLOCATOR; // Whether the default allocator is a "nil" allocator or not (i.e. it does nothing)
+bool   ODIN_DEFAULT_TO_NIL_ALLOCATOR; // Whether the default allocator is a "nil" allocator or not (i.e. it does nothing)
 
 	TargetEndianKind endian_kind;
 
@@ -855,24 +856,6 @@ void init_build_context(TargetMetrics *cross_target) {
 	bc->ODIN_VENDOR  = str_lit("odin");
 	bc->ODIN_VERSION = ODIN_VERSION;
 	bc->ODIN_ROOT    = odin_root_dir();
-	switch (bc->build_mode) {
-	default:
-	case BuildMode_Executable:
-		bc->ODIN_BUILD_MODE = str_lit("executable");
-		break;
-	case BuildMode_DynamicLibrary:
-		bc->ODIN_BUILD_MODE = str_lit("dynamic");
-		break;
-	case BuildMode_Object:
-		bc->ODIN_BUILD_MODE = str_lit("object");
-		break;
-	case BuildMode_Assembly:
-		bc->ODIN_BUILD_MODE = str_lit("assembly");
-		break;
-	case BuildMode_LLVM_IR:
-		bc->ODIN_BUILD_MODE = str_lit("llvm-ir");
-		break;
-	}
 	
 	bc->copy_file_contents = true;
 
diff --git a/src/check_expr.cpp b/src/check_expr.cpp
index 1162cefee..8667d8734 100644
--- a/src/check_expr.cpp
+++ b/src/check_expr.cpp
@@ -119,6 +119,58 @@ void check_or_else_split_types(CheckerContext *c, Operand *x, String const &name
 void check_or_else_expr_no_value_error(CheckerContext *c, String const &name, Operand const &x, Type *type_hint);
 void check_or_return_split_types(CheckerContext *c, Operand *x, String const &name, Type **left_type_, Type **right_type_);
 
+
+void check_did_you_mean_print(DidYouMeanAnswers *d, char const *prefix = "") {
+	auto results = did_you_mean_results(d);
+	if (results.count != 0) {
+		error_line("\tSuggestion: Did you mean?\n");
+		for_array(i, results) {
+			String const &target = results[i].target;
+			error_line("\t\t%s%.*s\n", prefix, LIT(target));
+			// error_line("\t\t%.*s %td\n", LIT(target), results[i].distance);
+		}
+	}
+}
+
+void check_did_you_mean_type(String const &name, Array<Entity *> const &fields, char const *prefix = "") {
+	ERROR_BLOCK();
+
+	DidYouMeanAnswers d = did_you_mean_make(heap_allocator(), fields.count, name);
+	defer (did_you_mean_destroy(&d));
+
+	for_array(i, fields) {
+		did_you_mean_append(&d, fields[i]->token.string);
+	}
+	check_did_you_mean_print(&d, prefix);
+}
+
+void check_did_you_mean_type(String const &name, Slice<Entity *> const &fields, char const *prefix = "") {
+	ERROR_BLOCK();
+
+	DidYouMeanAnswers d = did_you_mean_make(heap_allocator(), fields.count, name);
+	defer (did_you_mean_destroy(&d));
+
+	for_array(i, fields) {
+		did_you_mean_append(&d, fields[i]->token.string);
+	}
+	check_did_you_mean_print(&d, prefix);
+}
+
+void check_did_you_mean_scope(String const &name, Scope *scope, char const *prefix = "") {
+	ERROR_BLOCK();
+
+	DidYouMeanAnswers d = did_you_mean_make(heap_allocator(), scope->elements.entries.count, name);
+	defer (did_you_mean_destroy(&d));
+
+	mutex_lock(&scope->mutex);
+	for_array(i, scope->elements.entries) {
+		Entity *e = scope->elements.entries[i].value;
+		did_you_mean_append(&d, e->token.string);
+	}
+	mutex_unlock(&scope->mutex);
+	check_did_you_mean_print(&d, prefix);
+}
+
 Entity *entity_from_expr(Ast *expr) {
 	expr = unparen_expr(expr);
 	switch (expr->kind) {
@@ -3361,7 +3413,17 @@ void convert_untyped_error(CheckerContext *c, Operand *operand, Type *target_typ
 			}
 		}
 	}
+	ERROR_BLOCK();
+
 	error(operand->expr, "Cannot convert untyped value '%s' to '%s' from '%s'%s", expr_str, type_str, from_type_str, extra_text);
+	if (operand->value.kind == ExactValue_String) {
+		String key = operand->value.value_string;
+		if (is_type_string(operand->type) && is_type_enum(target_type)) {
+			gb_printf_err("HERE!\n");
+			Type *et = base_type(target_type);
+			check_did_you_mean_type(key, et->Enum.fields, ".");
+		}
+	}
 
 	gb_string_free(from_type_str);
 	gb_string_free(type_str);
@@ -3979,56 +4041,6 @@ ExactValue get_constant_field(CheckerContext *c, Operand const *operand, Selecti
 	if (success_) *success_ = true;
 	return empty_exact_value;
 }
-void check_did_you_mean_print(DidYouMeanAnswers *d) {
-	auto results = did_you_mean_results(d);
-	if (results.count != 0) {
-		error_line("\tSuggestion: Did you mean?\n");
-		for_array(i, results) {
-			String const &target = results[i].target;
-			error_line("\t\t%.*s\n", LIT(target));
-			// error_line("\t\t%.*s %td\n", LIT(target), results[i].distance);
-		}
-	}
-}
-
-void check_did_you_mean_type(String const &name, Array<Entity *> const &fields) {
-	ERROR_BLOCK();
-	
-	DidYouMeanAnswers d = did_you_mean_make(heap_allocator(), fields.count, name);
-	defer (did_you_mean_destroy(&d));
-
-	for_array(i, fields) {
-		did_you_mean_append(&d, fields[i]->token.string);
-	}
-	check_did_you_mean_print(&d);
-}
-
-void check_did_you_mean_type(String const &name, Slice<Entity *> const &fields) {
-	ERROR_BLOCK();
-	
-	DidYouMeanAnswers d = did_you_mean_make(heap_allocator(), fields.count, name);
-	defer (did_you_mean_destroy(&d));
-
-	for_array(i, fields) {
-		did_you_mean_append(&d, fields[i]->token.string);
-	}
-	check_did_you_mean_print(&d);
-}
-
-void check_did_you_mean_scope(String const &name, Scope *scope) {
-	ERROR_BLOCK();
-	
-	DidYouMeanAnswers d = did_you_mean_make(heap_allocator(), scope->elements.entries.count, name);
-	defer (did_you_mean_destroy(&d));
-
-	mutex_lock(&scope->mutex);
-	for_array(i, scope->elements.entries) {
-		Entity *e = scope->elements.entries[i].value;
-		did_you_mean_append(&d, e->token.string);
-	}
-	mutex_unlock(&scope->mutex);
-	check_did_you_mean_print(&d);
-}
 
 Type *determine_swizzle_array_type(Type *original_type, Type *type_hint, isize new_count) {
 	Type *array_type = base_type(type_deref(original_type));
diff --git a/src/checker.cpp b/src/checker.cpp
index f261c8f4a..c3dcd1d11 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -780,6 +780,54 @@ AstPackage *create_builtin_package(char const *name) {
 	return pkg;
 }
 
+struct GlobalEnumValue {
+	char const *name;
+	i64 value;
+};
+
+Slice<Entity *> add_global_enum_type(String const &type_name, GlobalEnumValue *values, isize value_count) {
+	Scope *scope = create_scope(nullptr, builtin_pkg->scope);
+	Entity *e = alloc_entity_type_name(scope, make_token_ident(type_name), nullptr, EntityState_Resolved);
+
+	Type *enum_type = alloc_type_enum();
+	Type *named_type = alloc_type_named(type_name, enum_type, e);
+	set_base_type(named_type, enum_type);
+	enum_type->Enum.base_type = t_int;
+	enum_type->Enum.scope = scope;
+
+	auto fields = array_make<Entity *>(permanent_allocator(), value_count);
+	for (isize i = 0; i < value_count; i++) {
+		i64 value = values[i].value;
+		Entity *e = alloc_entity_constant(scope, make_token_ident(values[i].name), named_type, exact_value_i64(value));
+		e->flags |= EntityFlag_Visited;
+		e->state = EntityState_Resolved;
+		fields[i] = e;
+
+		Entity *ie = scope_insert(scope, e);
+		GB_ASSERT(ie == nullptr);
+	}
+
+
+	enum_type->Enum.fields = fields;
+	enum_type->Enum.min_value_index = 0;
+	enum_type->Enum.max_value_index = value_count-1;
+	enum_type->Enum.min_value = &enum_type->Enum.fields[enum_type->Enum.min_value_index]->Constant.value;
+	enum_type->Enum.max_value = &enum_type->Enum.fields[enum_type->Enum.max_value_index]->Constant.value;
+
+	return slice_from_array(fields);
+}
+void add_global_enum_constant(Slice<Entity *> const &fields, char const *name, i64 value) {
+	for (Entity *field : fields) {
+		GB_ASSERT(field->kind == Entity_Constant);
+		if (value == exact_value_to_i64(field->Constant.value)) {
+			add_global_constant(name, field->type, field->Constant.value);
+			return;
+		}
+	}
+	GB_PANIC("Unfound enum value for global constant: %s %lld", name, cast(long long)value);
+}
+
+
 void init_universal(void) {
 	BuildContext *bc = &build_context;
 
@@ -815,7 +863,21 @@ void init_universal(void) {
 	add_global_string_constant("ODIN_VERSION", bc->ODIN_VERSION);
 	add_global_string_constant("ODIN_ROOT",    bc->ODIN_ROOT);
 	
-	add_global_string_constant("ODIN_BUILD_MODE", bc->ODIN_BUILD_MODE);
+	{
+		GlobalEnumValue values[BuildMode_COUNT] = {
+			{"Executable", BuildMode_Executable},
+			{"Dynamic",    BuildMode_DynamicLibrary},
+			{"Object",     BuildMode_Object},
+			{"Assembly",   BuildMode_Assembly},
+			{"LLVM_IR",    BuildMode_LLVM_IR},
+		};
+
+		auto fields = add_global_enum_type(str_lit("Odin_Build_Mode_Type"), values, gb_count_of(values));
+		add_global_enum_constant(fields, "ODIN_BUILD_MODE", bc->build_mode);
+	}
+
+	// add_global_string_constant("ODIN_BUILD_MODE", bc->ODIN_BUILD_MODE);
+
 	add_global_bool_constant("ODIN_DEBUG",                    bc->ODIN_DEBUG);
 	add_global_bool_constant("ODIN_DISABLE_ASSERT",           bc->ODIN_DISABLE_ASSERT);
 	add_global_bool_constant("ODIN_DEFAULT_TO_NIL_ALLOCATOR", bc->ODIN_DEFAULT_TO_NIL_ALLOCATOR);
-- 
cgit v1.2.3


From 29ebe0c3c92724f74392687ee859a0c2db503b0d Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sat, 15 Jan 2022 17:40:00 +0000
Subject: Rename architecture `386` to `i386`

---
 core/c/c.odin                               |  2 +-
 core/crypto/_fiat/field_poly1305/field.odin |  2 +-
 core/crypto/chacha20/chacha20.odin          |  2 +-
 core/runtime/entry_windows.odin             |  2 +-
 core/runtime/procs_windows_386.odin         | 28 ---------------------------
 core/runtime/procs_windows_i386.odin        | 28 +++++++++++++++++++++++++++
 core/sys/cpu/cpu_x86.odin                   |  2 +-
 core/sys/unix/syscalls_linux.odin           |  2 +-
 src/build_settings.cpp                      | 30 ++++++++++++++---------------
 src/check_builtin.cpp                       |  2 +-
 src/llvm_abi.cpp                            |  2 +-
 src/llvm_backend.cpp                        |  4 ++--
 src/llvm_backend_expr.cpp                   |  2 +-
 src/llvm_backend_proc.cpp                   |  4 ++--
 src/llvm_backend_utility.cpp                |  2 +-
 src/microsoft_craziness.h                   | 10 +++++-----
 16 files changed, 62 insertions(+), 62 deletions(-)
 delete mode 100644 core/runtime/procs_windows_386.odin
 create mode 100644 core/runtime/procs_windows_i386.odin

(limited to 'core/runtime')

diff --git a/core/c/c.odin b/core/c/c.odin
index 139d9920a..d0b8e377f 100644
--- a/core/c/c.odin
+++ b/core/c/c.odin
@@ -48,7 +48,7 @@ int_least64_t  :: builtin.i64
 uint_least64_t :: builtin.u64
 
 // Same on Windows, Linux, and FreeBSD
-when ODIN_ARCH == "386" || ODIN_ARCH == "amd64" {
+when ODIN_ARCH == "i386" || ODIN_ARCH == "amd64" {
 	int_fast8_t    :: builtin.i8
 	uint_fast8_t   :: builtin.u8
 	int_fast16_t   :: builtin.i32
diff --git a/core/crypto/_fiat/field_poly1305/field.odin b/core/crypto/_fiat/field_poly1305/field.odin
index bfb7cf1f9..4ed8acbff 100644
--- a/core/crypto/_fiat/field_poly1305/field.odin
+++ b/core/crypto/_fiat/field_poly1305/field.odin
@@ -22,7 +22,7 @@ fe_from_bytes :: #force_inline proc (out1: ^Tight_Field_Element, arg1: []byte, a
 
 	assert(len(arg1) == 16)
 
-	when ODIN_ARCH == "386" || ODIN_ARCH == "amd64" {
+	when ODIN_ARCH == "i386" || ODIN_ARCH == "amd64" {
 		// While it may be unwise to do deserialization here on our
 		// own when fiat-crypto provides equivalent functionality,
 		// doing it this way provides a little under 3x performance
diff --git a/core/crypto/chacha20/chacha20.odin b/core/crypto/chacha20/chacha20.odin
index f6f551692..e32dacb2c 100644
--- a/core/crypto/chacha20/chacha20.odin
+++ b/core/crypto/chacha20/chacha20.odin
@@ -346,7 +346,7 @@ _do_blocks :: proc (ctx: ^Context, dst, src: []byte, nr_blocks: int) {
 		// Until dedicated assembly can be written leverage the fact that
 		// the callers of this routine ensure that src/dst are valid.
 
-		when ODIN_ARCH == "386" || ODIN_ARCH == "amd64" {
+		when ODIN_ARCH == "i386" || ODIN_ARCH == "amd64" {
 			// util.PUT_U32_LE/util.U32_LE are not required on little-endian
 			// systems that also happen to not be strict about aligned
 			// memory access.
diff --git a/core/runtime/entry_windows.odin b/core/runtime/entry_windows.odin
index 97a5bebe6..35a6bb421 100644
--- a/core/runtime/entry_windows.odin
+++ b/core/runtime/entry_windows.odin
@@ -22,7 +22,7 @@ when ODIN_BUILD_MODE == .Dynamic {
 		return true
 	}
 } else when !ODIN_TEST && !ODIN_NO_ENTRY_POINT {
-	when ODIN_ARCH == "386" || ODIN_NO_CRT {
+	when ODIN_ARCH == "i386" || ODIN_NO_CRT {
 		@(link_name="mainCRTStartup", linkage="strong", require)
 		mainCRTStartup :: proc "stdcall" () -> i32 {
 			context = default_context()
diff --git a/core/runtime/procs_windows_386.odin b/core/runtime/procs_windows_386.odin
deleted file mode 100644
index f810197f1..000000000
--- a/core/runtime/procs_windows_386.odin
+++ /dev/null
@@ -1,28 +0,0 @@
-//+private
-package runtime
-
-@require foreign import "system:int64.lib"
-
-foreign import kernel32 "system:Kernel32.lib"
-
-windows_trap_array_bounds :: proc "contextless" () -> ! {
-	DWORD :: u32
-	ULONG_PTR :: uint
-
-	EXCEPTION_ARRAY_BOUNDS_EXCEEDED :: 0xC000008C
-
-	foreign kernel32 {
-		RaiseException :: proc "stdcall" (dwExceptionCode, dwExceptionFlags, nNumberOfArguments: DWORD, lpArguments: ^ULONG_PTR) -> ! ---
-	}
-
-	RaiseException(EXCEPTION_ARRAY_BOUNDS_EXCEEDED, 0, 0, nil)
-}
-
-windows_trap_type_assertion :: proc "contextless" () -> ! {
-	windows_trap_array_bounds()
-}
-
-@(private, export, link_name="_fltused") _fltused: i32 = 0x9875
-
-@(private, export, link_name="_tls_index") _tls_index: u32
-@(private, export, link_name="_tls_array") _tls_array: u32
diff --git a/core/runtime/procs_windows_i386.odin b/core/runtime/procs_windows_i386.odin
new file mode 100644
index 000000000..f810197f1
--- /dev/null
+++ b/core/runtime/procs_windows_i386.odin
@@ -0,0 +1,28 @@
+//+private
+package runtime
+
+@require foreign import "system:int64.lib"
+
+foreign import kernel32 "system:Kernel32.lib"
+
+windows_trap_array_bounds :: proc "contextless" () -> ! {
+	DWORD :: u32
+	ULONG_PTR :: uint
+
+	EXCEPTION_ARRAY_BOUNDS_EXCEEDED :: 0xC000008C
+
+	foreign kernel32 {
+		RaiseException :: proc "stdcall" (dwExceptionCode, dwExceptionFlags, nNumberOfArguments: DWORD, lpArguments: ^ULONG_PTR) -> ! ---
+	}
+
+	RaiseException(EXCEPTION_ARRAY_BOUNDS_EXCEEDED, 0, 0, nil)
+}
+
+windows_trap_type_assertion :: proc "contextless" () -> ! {
+	windows_trap_array_bounds()
+}
+
+@(private, export, link_name="_fltused") _fltused: i32 = 0x9875
+
+@(private, export, link_name="_tls_index") _tls_index: u32
+@(private, export, link_name="_tls_array") _tls_array: u32
diff --git a/core/sys/cpu/cpu_x86.odin b/core/sys/cpu/cpu_x86.odin
index 8f3560a87..146822e61 100644
--- a/core/sys/cpu/cpu_x86.odin
+++ b/core/sys/cpu/cpu_x86.odin
@@ -1,4 +1,4 @@
-//+build 386, amd64
+//+build i386, amd64
 package sys_cpu
 
 _cache_line_size :: 64;
diff --git a/core/sys/unix/syscalls_linux.odin b/core/sys/unix/syscalls_linux.odin
index 25c5ed0a1..3dc3d2c74 100644
--- a/core/sys/unix/syscalls_linux.odin
+++ b/core/sys/unix/syscalls_linux.odin
@@ -675,7 +675,7 @@ when ODIN_ARCH == "amd64" {
 	SYS_landlock_create_ruleset : uintptr : 444
 	SYS_landlock_add_rule : uintptr : 445
 	SYS_landlock_restrict_self : uintptr : 446
-} else when ODIN_ARCH == "386" {
+} else when ODIN_ARCH == "i386" {
 	SYS_restart_syscall : uintptr : 0
 	SYS_exit : uintptr : 1
 	SYS_fork : uintptr : 2
diff --git a/src/build_settings.cpp b/src/build_settings.cpp
index bafa93042..5e4534517 100644
--- a/src/build_settings.cpp
+++ b/src/build_settings.cpp
@@ -29,7 +29,7 @@ enum TargetArchKind {
 	TargetArch_Invalid,
 
 	TargetArch_amd64,
-	TargetArch_386,
+	TargetArch_i386,
 	TargetArch_arm64,
 	TargetArch_wasm32,
 	TargetArch_wasm64,
@@ -63,7 +63,7 @@ String target_os_names[TargetOs_COUNT] = {
 String target_arch_names[TargetArch_COUNT] = {
 	str_lit(""),
 	str_lit("amd64"),
-	str_lit("386"),
+	str_lit("i386"),
 	str_lit("arm64"),
 	str_lit("wasm32"),
 	str_lit("wasm64"),
@@ -269,9 +269,9 @@ bool global_ignore_warnings(void) {
 }
 
 
-gb_global TargetMetrics target_windows_386 = {
+gb_global TargetMetrics target_windows_i386 = {
 	TargetOs_windows,
-	TargetArch_386,
+	TargetArch_i386,
 	4,
 	8,
 	str_lit("i386-pc-windows-msvc"),
@@ -285,9 +285,9 @@ gb_global TargetMetrics target_windows_amd64 = {
 	str_lit("e-m:w-i64:64-f80:128-n8:16:32:64-S128"),
 };
 
-gb_global TargetMetrics target_linux_386 = {
+gb_global TargetMetrics target_linux_i386 = {
 	TargetOs_linux,
-	TargetArch_386,
+	TargetArch_i386,
 	4,
 	8,
 	str_lit("i386-pc-linux-gnu"),
@@ -328,9 +328,9 @@ gb_global TargetMetrics target_darwin_arm64 = {
 	str_lit("e-m:o-i64:64-i128:128-n32:64-S128"), // TODO(bill): Is this correct?
 };
 
-gb_global TargetMetrics target_freebsd_386 = {
+gb_global TargetMetrics target_freebsd_i386 = {
 	TargetOs_freebsd,
-	TargetArch_386,
+	TargetArch_i386,
 	4,
 	8,
 	str_lit("i386-unknown-freebsd-elf"),
@@ -401,12 +401,12 @@ gb_global NamedTargetMetrics named_targets[] = {
 	{ str_lit("darwin_amd64"),        &target_darwin_amd64   },
 	{ str_lit("darwin_arm64"),        &target_darwin_arm64   },
 	{ str_lit("essence_amd64"),       &target_essence_amd64  },
-	{ str_lit("linux_386"),           &target_linux_386      },
+	{ str_lit("linux_i386"),           &target_linux_i386      },
 	{ str_lit("linux_amd64"),         &target_linux_amd64    },
 	{ str_lit("linux_arm64"),         &target_linux_arm64    },
-	{ str_lit("windows_386"),         &target_windows_386    },
+	{ str_lit("windows_i386"),         &target_windows_i386    },
 	{ str_lit("windows_amd64"),       &target_windows_amd64  },
-	{ str_lit("freebsd_386"),         &target_freebsd_386    },
+	{ str_lit("freebsd_i386"),         &target_freebsd_i386    },
 	{ str_lit("freebsd_amd64"),       &target_freebsd_amd64  },
 	{ str_lit("freestanding_wasm32"), &target_freestanding_wasm32 },
 	{ str_lit("wasi_wasm32"),         &target_wasi_wasm32 },
@@ -879,13 +879,13 @@ void init_build_context(TargetMetrics *cross_target) {
 		#endif
 	#else
 		#if defined(GB_SYSTEM_WINDOWS)
-			metrics = &target_windows_386;
+			metrics = &target_windows_i386;
 		#elif defined(GB_SYSTEM_OSX)
 			#error "Build Error: Unsupported architecture"
 		#elif defined(GB_SYSTEM_FREEBSD)
-			metrics = &target_freebsd_386;
+			metrics = &target_freebsd_i386;
 		#else
-			metrics = &target_linux_386;
+			metrics = &target_linux_i386;
 		#endif
 	#endif
 
@@ -932,7 +932,7 @@ void init_build_context(TargetMetrics *cross_target) {
 			bc->link_flags = str_lit("-arch x86-64 ");
 			break;
 		}
-	} else if (bc->metrics.arch == TargetArch_386) {
+	} else if (bc->metrics.arch == TargetArch_i386) {
 		switch (bc->metrics.os) {
 		case TargetOs_windows:
 			bc->link_flags = str_lit("/machine:x86 ");
diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp
index 82ad6d161..a42741976 100644
--- a/src/check_builtin.cpp
+++ b/src/check_builtin.cpp
@@ -3225,7 +3225,7 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32
 			case TargetOs_essence:
 			case TargetOs_freebsd:
 				switch (build_context.metrics.arch) {
-				case TargetArch_386:
+				case TargetArch_i386:
 				case TargetArch_amd64:
 				case TargetArch_arm64:
 					max_arg_count = 7;
diff --git a/src/llvm_abi.cpp b/src/llvm_abi.cpp
index 42f05bb27..310df6639 100644
--- a/src/llvm_abi.cpp
+++ b/src/llvm_abi.cpp
@@ -1193,7 +1193,7 @@ LB_ABI_INFO(lb_get_abi_info) {
 		} else {
 			return lbAbiAmd64SysV::abi_info(c, arg_types, arg_count, return_type, return_is_defined, calling_convention);
 		}
-	case TargetArch_386:
+	case TargetArch_i386:
 		return lbAbi386::abi_info(c, arg_types, arg_count, return_type, return_is_defined, calling_convention);
 	case TargetArch_arm64:
 		return lbAbiArm64::abi_info(c, arg_types, arg_count, return_type, return_is_defined, calling_convention);
diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index 7a7f20f8d..63fb5d4e9 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -783,7 +783,7 @@ lbProcedure *lb_create_main_procedure(lbModule *m, lbProcedure *startup_runtime)
 		params->Tuple.variables[1] = alloc_entity_param(nullptr, make_token_ident("fdwReason"),  t_u32,    false, true);
 		params->Tuple.variables[2] = alloc_entity_param(nullptr, make_token_ident("lpReserved"), t_rawptr, false, true);
 		call_cleanup = false;
-	} else if (build_context.metrics.os == TargetOs_windows && (build_context.metrics.arch == TargetArch_386 || build_context.no_crt)) {
+	} else if (build_context.metrics.os == TargetOs_windows && (build_context.metrics.arch == TargetArch_i386 || build_context.no_crt)) {
 		name = str_lit("mainCRTStartup");
 	} else if (is_arch_wasm()) {
 		name = str_lit("_start");
@@ -1140,7 +1140,7 @@ void lb_generate_code(lbGenerator *gen) {
 
 	switch (build_context.metrics.arch) {
 	case TargetArch_amd64: 
-	case TargetArch_386:
+	case TargetArch_i386:
 		LLVMInitializeX86TargetInfo();
 		LLVMInitializeX86Target();
 		LLVMInitializeX86TargetMC();
diff --git a/src/llvm_backend_expr.cpp b/src/llvm_backend_expr.cpp
index 0b2f6b3fd..1f0ed6434 100644
--- a/src/llvm_backend_expr.cpp
+++ b/src/llvm_backend_expr.cpp
@@ -508,7 +508,7 @@ bool lb_is_matrix_simdable(Type *t) {
 			case TargetArch_arm64:
 				// TODO(bill): determine when this is fine
 				return true;
-			case TargetArch_386:
+			case TargetArch_i386:
 			case TargetArch_wasm32:
 			case TargetArch_wasm64:
 				return false;
diff --git a/src/llvm_backend_proc.cpp b/src/llvm_backend_proc.cpp
index eccf9b360..2a6eb6bb3 100644
--- a/src/llvm_backend_proc.cpp
+++ b/src/llvm_backend_proc.cpp
@@ -1361,7 +1361,7 @@ lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValue const &tv,
 		}
 
 	case BuiltinProc_cpu_relax:
-		if (build_context.metrics.arch == TargetArch_386 ||
+		if (build_context.metrics.arch == TargetArch_i386 ||
 		    build_context.metrics.arch == TargetArch_amd64) {
 			LLVMTypeRef func_type = LLVMFunctionType(LLVMVoidTypeInContext(p->module->ctx), nullptr, 0, false);
 			LLVMValueRef the_asm = llvm_get_inline_asm(func_type, str_lit("pause"), {});
@@ -2018,7 +2018,7 @@ lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValue const &tv,
 					inline_asm = llvm_get_inline_asm(func_type, make_string_c(asm_string), make_string_c(constraints));
 				}
 				break;
-			case TargetArch_386:
+			case TargetArch_i386:
 				{
 					GB_ASSERT(arg_count <= 7);
 					
diff --git a/src/llvm_backend_utility.cpp b/src/llvm_backend_utility.cpp
index 3fe96459f..5b1b11b44 100644
--- a/src/llvm_backend_utility.cpp
+++ b/src/llvm_backend_utility.cpp
@@ -1494,7 +1494,7 @@ lbValue lb_emit_mul_add(lbProcedure *p, lbValue a, lbValue b, lbValue c, Type *t
 		case TargetArch_arm64:
 			// possible
 			break;
-		case TargetArch_386:
+		case TargetArch_i386:
 		case TargetArch_wasm32:
 		case TargetArch_wasm64:
 			is_possible = false;
diff --git a/src/microsoft_craziness.h b/src/microsoft_craziness.h
index 02f14dda3..b4f815284 100644
--- a/src/microsoft_craziness.h
+++ b/src/microsoft_craziness.h
@@ -460,7 +460,7 @@ bool find_visual_studio_by_fighting_through_microsoft_craziness(Find_Result *res
             wchar_t *library_path = nullptr;
             if (build_context.metrics.arch == TargetArch_amd64) {
                 library_path = concat(bstr_inst_path, L"\\VC\\Tools\\MSVC\\", version, L"\\lib\\x64\\");
-            } else if (build_context.metrics.arch == TargetArch_386) {
+            } else if (build_context.metrics.arch == TargetArch_i386) {
                 library_path = concat(bstr_inst_path, L"\\VC\\Tools\\MSVC\\", version, L"\\lib\\x86\\");
             } else {
                 continue;
@@ -472,7 +472,7 @@ bool find_visual_studio_by_fighting_through_microsoft_craziness(Find_Result *res
                 wchar_t *link_exe_path = nullptr;
                 if (build_context.metrics.arch == TargetArch_amd64) {
                     link_exe_path = concat(bstr_inst_path, L"\\VC\\Tools\\MSVC\\", version, L"\\bin\\Hostx64\\x64\\");
-                } else if (build_context.metrics.arch == TargetArch_386) {
+                } else if (build_context.metrics.arch == TargetArch_i386) {
                     link_exe_path = concat(bstr_inst_path, L"\\VC\\Tools\\MSVC\\", version, L"\\bin\\Hostx86\\x86\\");
                 } else {
                     continue;
@@ -529,7 +529,7 @@ bool find_visual_studio_by_fighting_through_microsoft_craziness(Find_Result *res
 
             if (build_context.metrics.arch == TargetArch_amd64) {
                 lib_path = concat(buffer, L"VC\\Lib\\amd64\\");
-            } else if (build_context.metrics.arch == TargetArch_386) {
+            } else if (build_context.metrics.arch == TargetArch_i386) {
                 lib_path = concat(buffer, L"VC\\Lib\\");
             } else {
                 continue;
@@ -542,7 +542,7 @@ bool find_visual_studio_by_fighting_through_microsoft_craziness(Find_Result *res
             if (os_file_exists(vcruntime_filename)) {
                 if (build_context.metrics.arch == TargetArch_amd64) {
                     result->vs_exe_path = concat(buffer, L"VC\\bin\\");
-                } else if (build_context.metrics.arch == TargetArch_386) {
+                } else if (build_context.metrics.arch == TargetArch_i386) {
                     // result->vs_exe_path = concat(buffer, L"VC\\bin\\amd64_x86\\");
                     result->vs_exe_path = concat(buffer, L"VC\\bin\\x86_amd64\\");
                 } else {
@@ -573,7 +573,7 @@ Find_Result find_visual_studio_and_windows_sdk() {
         if (build_context.metrics.arch == TargetArch_amd64) {
             result.windows_sdk_um_library_path   = concat(result.windows_sdk_root, L"um\\x64\\");
             result.windows_sdk_ucrt_library_path = concat(result.windows_sdk_root, L"ucrt\\x64\\");
-        } else if (build_context.metrics.arch == TargetArch_386) {
+        } else if (build_context.metrics.arch == TargetArch_i386) {
             result.windows_sdk_um_library_path   = concat(result.windows_sdk_root, L"um\\x86\\");
             result.windows_sdk_ucrt_library_path = concat(result.windows_sdk_root, L"ucrt\\x86\\");
         }
-- 
cgit v1.2.3


From f0529535e02ab175bca3f7ff8c3bc2112d949236 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sat, 15 Jan 2022 17:53:18 +0000
Subject: `ODIN_ENDIAN` changed to an enum constant; `ODIN_ENUM_STRING` is the
 new string version of the old constant

---
 core/crypto/_sha3/_sha3.odin    |  4 ++--
 core/crypto/haval/haval.odin    |  2 +-
 core/encoding/json/marshal.odin |  4 ++--
 core/fmt/fmt.odin               |  4 ++--
 core/hash/xxhash/streaming.odin |  2 +-
 core/image/png/example.odin     |  2 +-
 core/image/png/png.odin         |  2 +-
 core/math/bits/bits.odin        | 32 ++++++++++++++++----------------
 core/runtime/core.odin          | 10 ++++++++++
 core/runtime/udivmod128.odin    |  2 +-
 src/build_settings.cpp          | 20 +++++++++-----------
 src/checker.cpp                 | 15 +++++++++++++--
 vendor/sdl2/sdl_audio.odin      |  2 +-
 vendor/sdl2/sdl_pixels.odin     |  8 ++++----
 14 files changed, 64 insertions(+), 45 deletions(-)

(limited to 'core/runtime')

diff --git a/core/crypto/_sha3/_sha3.odin b/core/crypto/_sha3/_sha3.odin
index 76e09bf24..9846aca42 100644
--- a/core/crypto/_sha3/_sha3.odin
+++ b/core/crypto/_sha3/_sha3.odin
@@ -52,7 +52,7 @@ keccakf :: proc "contextless" (st: ^[25]u64) {
     t: u64       = ---
     bc: [5]u64   = ---
 
-    when ODIN_ENDIAN != "little" {
+    when ODIN_ENDIAN != .Little {
         v: uintptr = ---
         for i = 0; i < 25; i += 1 {
             v := uintptr(&st[i])
@@ -98,7 +98,7 @@ keccakf :: proc "contextless" (st: ^[25]u64) {
         st[0] ~= keccakf_rndc[r]
     }
 
-    when ODIN_ENDIAN != "little" {
+    when ODIN_ENDIAN != .Little {
         for i = 0; i < 25; i += 1 {
             v = uintptr(&st[i])
             t = st[i]
diff --git a/core/crypto/haval/haval.odin b/core/crypto/haval/haval.odin
index f95ea344d..442a348e9 100644
--- a/core/crypto/haval/haval.odin
+++ b/core/crypto/haval/haval.odin
@@ -1332,7 +1332,7 @@ update :: proc(ctx: ^Haval_Context, data: []byte) {
     }
     ctx.count[1] += str_len >> 29
 
-    when ODIN_ENDIAN == "little" {
+    when ODIN_ENDIAN == .Little {
         if rmd_len + str_len >= 128 {
             copy(util.slice_to_bytes(ctx.block[:])[rmd_len:], data[:fill_len])
             block(ctx, ctx.rounds)
diff --git a/core/encoding/json/marshal.odin b/core/encoding/json/marshal.odin
index adbcb95be..aa1c1559c 100644
--- a/core/encoding/json/marshal.odin
+++ b/core/encoding/json/marshal.odin
@@ -285,8 +285,8 @@ marshal_to_writer :: proc(w: io.Writer, v: any) -> (err: Marshal_Error) {
 			case runtime.Type_Info_Integer:
 				switch info.endianness {
 				case .Platform: return false
-				case .Little:   return ODIN_ENDIAN != "little"
-				case .Big:      return ODIN_ENDIAN != "big"
+				case .Little:   return ODIN_ENDIAN != .Little
+				case .Big:      return ODIN_ENDIAN != .Big
 				}
 			}
 			return false
diff --git a/core/fmt/fmt.odin b/core/fmt/fmt.odin
index a9ff6ca47..2cc192c12 100644
--- a/core/fmt/fmt.odin
+++ b/core/fmt/fmt.odin
@@ -1092,8 +1092,8 @@ fmt_bit_set :: proc(fi: ^Info, v: any, name: string = "") {
 		case runtime.Type_Info_Integer:
 			switch info.endianness {
 			case .Platform: return false
-			case .Little:   return ODIN_ENDIAN != "little"
-			case .Big:      return ODIN_ENDIAN != "big"
+			case .Little:   return ODIN_ENDIAN != .Little
+			case .Big:      return ODIN_ENDIAN != .Big
 			}
 		}
 		return false
diff --git a/core/hash/xxhash/streaming.odin b/core/hash/xxhash/streaming.odin
index 737e37eae..d6df1089f 100644
--- a/core/hash/xxhash/streaming.odin
+++ b/core/hash/xxhash/streaming.odin
@@ -96,7 +96,7 @@ XXH3_128_canonical_from_hash :: proc(hash: XXH128_hash_t) -> (canonical: XXH128_
 	#assert(size_of(XXH128_canonical) == size_of(XXH128_hash_t))
 
 	t := hash
-	when ODIN_ENDIAN == "little" {
+	when ODIN_ENDIAN == .Little {
 		t.high = byte_swap(t.high)
 		t.low  = byte_swap(t.low)
 	}
diff --git a/core/image/png/example.odin b/core/image/png/example.odin
index 5e7dca4c8..f4eb5128e 100644
--- a/core/image/png/example.odin
+++ b/core/image/png/example.odin
@@ -189,7 +189,7 @@ write_image_as_ppm :: proc(filename: string, image: ^image.Image) -> (success: b
 	img := image
 
 	// PBM 16-bit images are big endian
-	when ODIN_ENDIAN == "little" {
+	when ODIN_ENDIAN == .Little {
 		if img.depth == 16 {
 			// The pixel components are in Big Endian. Let's byteswap back.
 			input  := mem.slice_data_cast([]u16,   img.pixels.buf[:])
diff --git a/core/image/png/png.odin b/core/image/png/png.odin
index f77bf7519..da76a4588 100644
--- a/core/image/png/png.odin
+++ b/core/image/png/png.odin
@@ -1611,7 +1611,7 @@ defilter :: proc(img: ^Image, filter_bytes: ^bytes.Buffer, header: ^image.PNG_IH
 			}
 		}
 	}
-	when ODIN_ENDIAN == "little" {
+	when ODIN_ENDIAN == .Little {
 		if img.depth == 16 {
 			// The pixel components are in Big Endian. Let's byteswap.
 			input  := mem.slice_data_cast([]u16be, img.pixels.buf[:])
diff --git a/core/math/bits/bits.odin b/core/math/bits/bits.odin
index bff984cc7..850e8038a 100644
--- a/core/math/bits/bits.odin
+++ b/core/math/bits/bits.odin
@@ -69,29 +69,29 @@ rotate_left :: proc(x: uint, k: int) -> uint {
 }
 
 from_be_u8   :: proc(i:   u8) ->   u8 { return i }
-from_be_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
-from_be_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
-from_be_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
-from_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
+from_be_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } }
+from_be_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } }
+from_be_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } }
+from_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } }
 
 from_le_u8   :: proc(i:   u8) ->   u8 { return i }
-from_le_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
-from_le_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
-from_le_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
-from_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
+from_le_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } }
+from_le_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } }
+from_le_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } }
+from_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } }
 
 to_be_u8   :: proc(i:   u8) ->   u8 { return i }
-to_be_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
-to_be_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
-to_be_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
-to_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
+to_be_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } }
+to_be_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } }
+to_be_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } }
+to_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } }
 
 
 to_le_u8   :: proc(i:   u8) ->   u8 { return i }
-to_le_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
-to_le_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
-to_le_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
-to_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
+to_le_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } }
+to_le_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } }
+to_le_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } }
+to_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } }
 
 
 
diff --git a/core/runtime/core.odin b/core/runtime/core.odin
index 91b6bf5ca..424650828 100644
--- a/core/runtime/core.odin
+++ b/core/runtime/core.odin
@@ -398,6 +398,16 @@ Raw_Cstring :: struct {
 */
 Odin_Build_Mode_Type :: type_of(ODIN_BUILD_MODE)
 
+/*
+	// Defined internally by the compiler
+	Odin_Endian_Type :: enum int {
+		Unknown,
+		Little,
+		Big,
+	}
+*/
+Odin_Endian_Type :: type_of(ODIN_ENDIAN)
+
 
 /////////////////////////////
 // Init Startup Procedures //
diff --git a/core/runtime/udivmod128.odin b/core/runtime/udivmod128.odin
index 1fd1b5f84..87ef73c2c 100644
--- a/core/runtime/udivmod128.odin
+++ b/core/runtime/udivmod128.odin
@@ -11,7 +11,7 @@ udivmod128 :: proc "c" (a, b: u128, rem: ^u128) -> u128 {
 	q, r: [2]u64
 	sr: u32 = 0
 
-	low  :: 1 when ODIN_ENDIAN == "big" else 0
+	low  :: 1 when ODIN_ENDIAN == .Big else 0
 	high :: 1 - low
 	U64_BITS :: 8*size_of(u64)
 	U128_BITS :: 8*size_of(u128)
diff --git a/src/build_settings.cpp b/src/build_settings.cpp
index 5e4534517..b4a934ec8 100644
--- a/src/build_settings.cpp
+++ b/src/build_settings.cpp
@@ -170,7 +170,6 @@ struct BuildContext {
 	// Constants
 	String ODIN_OS;      // target operating system
 	String ODIN_ARCH;    // target architecture
-	String ODIN_ENDIAN;  // target endian
 	String ODIN_VENDOR;  // compiler vendor
 	String ODIN_VERSION; // compiler version
 	String ODIN_ROOT;    // Odin ROOT
@@ -269,7 +268,7 @@ bool global_ignore_warnings(void) {
 }
 
 
-gb_global TargetMetrics target_windows_i386 = {
+gb_global TargetMetrics target_windows_386 = {
 	TargetOs_windows,
 	TargetArch_i386,
 	4,
@@ -285,7 +284,7 @@ gb_global TargetMetrics target_windows_amd64 = {
 	str_lit("e-m:w-i64:64-f80:128-n8:16:32:64-S128"),
 };
 
-gb_global TargetMetrics target_linux_i386 = {
+gb_global TargetMetrics target_linux_386 = {
 	TargetOs_linux,
 	TargetArch_i386,
 	4,
@@ -328,7 +327,7 @@ gb_global TargetMetrics target_darwin_arm64 = {
 	str_lit("e-m:o-i64:64-i128:128-n32:64-S128"), // TODO(bill): Is this correct?
 };
 
-gb_global TargetMetrics target_freebsd_i386 = {
+gb_global TargetMetrics target_freebsd_386 = {
 	TargetOs_freebsd,
 	TargetArch_i386,
 	4,
@@ -401,12 +400,12 @@ gb_global NamedTargetMetrics named_targets[] = {
 	{ str_lit("darwin_amd64"),        &target_darwin_amd64   },
 	{ str_lit("darwin_arm64"),        &target_darwin_arm64   },
 	{ str_lit("essence_amd64"),       &target_essence_amd64  },
-	{ str_lit("linux_i386"),           &target_linux_i386      },
+	{ str_lit("linux_386"),           &target_linux_386      },
 	{ str_lit("linux_amd64"),         &target_linux_amd64    },
 	{ str_lit("linux_arm64"),         &target_linux_arm64    },
-	{ str_lit("windows_i386"),         &target_windows_i386    },
+	{ str_lit("windows_386"),         &target_windows_386    },
 	{ str_lit("windows_amd64"),       &target_windows_amd64  },
-	{ str_lit("freebsd_i386"),         &target_freebsd_i386    },
+	{ str_lit("freebsd_386"),         &target_freebsd_386    },
 	{ str_lit("freebsd_amd64"),       &target_freebsd_amd64  },
 	{ str_lit("freestanding_wasm32"), &target_freestanding_wasm32 },
 	{ str_lit("wasi_wasm32"),         &target_wasi_wasm32 },
@@ -879,13 +878,13 @@ void init_build_context(TargetMetrics *cross_target) {
 		#endif
 	#else
 		#if defined(GB_SYSTEM_WINDOWS)
-			metrics = &target_windows_i386;
+			metrics = &target_windows_386;
 		#elif defined(GB_SYSTEM_OSX)
 			#error "Build Error: Unsupported architecture"
 		#elif defined(GB_SYSTEM_FREEBSD)
-			metrics = &target_freebsd_i386;
+			metrics = &target_freebsd_386;
 		#else
-			metrics = &target_linux_i386;
+			metrics = &target_linux_386;
 		#endif
 	#endif
 
@@ -904,7 +903,6 @@ void init_build_context(TargetMetrics *cross_target) {
 	bc->metrics = *metrics;
 	bc->ODIN_OS     = target_os_names[metrics->os];
 	bc->ODIN_ARCH   = target_arch_names[metrics->arch];
-	bc->ODIN_ENDIAN = target_endian_names[target_endians[metrics->arch]];
 	bc->endian_kind = target_endians[metrics->arch];
 	bc->word_size   = metrics->word_size;
 	bc->max_align   = metrics->max_align;
diff --git a/src/checker.cpp b/src/checker.cpp
index c3dcd1d11..ddb73d33e 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -858,7 +858,6 @@ void init_universal(void) {
 	// TODO(bill): Set through flags in the compiler
 	add_global_string_constant("ODIN_OS",      bc->ODIN_OS);
 	add_global_string_constant("ODIN_ARCH",    bc->ODIN_ARCH);
-	add_global_string_constant("ODIN_ENDIAN",  bc->ODIN_ENDIAN);
 	add_global_string_constant("ODIN_VENDOR",  bc->ODIN_VENDOR);
 	add_global_string_constant("ODIN_VERSION", bc->ODIN_VERSION);
 	add_global_string_constant("ODIN_ROOT",    bc->ODIN_ROOT);
@@ -876,7 +875,19 @@ void init_universal(void) {
 		add_global_enum_constant(fields, "ODIN_BUILD_MODE", bc->build_mode);
 	}
 
-	// add_global_string_constant("ODIN_BUILD_MODE", bc->ODIN_BUILD_MODE);
+	add_global_string_constant("ODIN_ENDIAN_STRING", target_endian_names[target_endians[bc->metrics.arch]]);
+	{
+		GlobalEnumValue values[TargetEndian_COUNT] = {
+			{"Unknown", TargetEndian_Invalid},
+
+			{"Little",  TargetEndian_Little},
+			{"Big",     TargetEndian_Big},
+		};
+
+		auto fields = add_global_enum_type(str_lit("Odin_Endian_Type"), values, gb_count_of(values));
+		add_global_enum_constant(fields, "ODIN_ENDIAN", target_endians[bc->metrics.arch]);
+	}
+
 
 	add_global_bool_constant("ODIN_DEBUG",                    bc->ODIN_DEBUG);
 	add_global_bool_constant("ODIN_DISABLE_ASSERT",           bc->ODIN_DISABLE_ASSERT);
diff --git a/vendor/sdl2/sdl_audio.odin b/vendor/sdl2/sdl_audio.odin
index e108e31c6..2c5b7fedb 100644
--- a/vendor/sdl2/sdl_audio.odin
+++ b/vendor/sdl2/sdl_audio.odin
@@ -59,7 +59,7 @@ AUDIO_F32LSB    :: 0x8120  /**< 32-bit floating point samples */
 AUDIO_F32MSB    :: 0x9120  /**< As above, but big-endian byte order */
 AUDIO_F32       :: AUDIO_F32LSB
 
-when ODIN_ENDIAN == "little"  {
+when ODIN_ENDIAN == .Little {
 	AUDIO_U16SYS :: AUDIO_U16LSB
 	AUDIO_S16SYS :: AUDIO_S16LSB
 	AUDIO_S32SYS :: AUDIO_S32LSB
diff --git a/vendor/sdl2/sdl_pixels.odin b/vendor/sdl2/sdl_pixels.odin
index a8503c621..22f6db440 100644
--- a/vendor/sdl2/sdl_pixels.odin
+++ b/vendor/sdl2/sdl_pixels.odin
@@ -156,10 +156,10 @@ PixelFormatEnum :: enum u32 {
 	ARGB2101010 = 1<<28 | PIXELTYPE_PACKED32<<24 | PACKEDORDER_ARGB<<20 | PACKEDLAYOUT_2101010<<16 | 32<<8 | 4<<0,
 
 	/* Aliases for RGBA byte arrays of color data, for the current platform */
-	RGBA32 = RGBA8888 when ODIN_ENDIAN == "big" else ABGR8888,
-	ARGB32 = ARGB8888 when ODIN_ENDIAN == "big" else BGRA8888,
-	BGRA32 = BGRA8888 when ODIN_ENDIAN == "big" else ARGB8888,
-	ABGR32 = ABGR8888 when ODIN_ENDIAN == "big" else RGBA8888,
+	RGBA32 = RGBA8888 when ODIN_ENDIAN == .Big else ABGR8888,
+	ARGB32 = ARGB8888 when ODIN_ENDIAN == .Big else BGRA8888,
+	BGRA32 = BGRA8888 when ODIN_ENDIAN == .Big else ARGB8888,
+	ABGR32 = ABGR8888 when ODIN_ENDIAN == .Big else RGBA8888,
 
 	YV12 =      /**< Planar mode: Y + V + U  (3 planes) */
 		'Y'<<24 | 'V'<<16 | '1'<<8 | '2'<<0,
-- 
cgit v1.2.3


From cd6898439e9de6fce42555e2bab5c27e206dbcde Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Jan 2022 12:17:13 +0000
Subject: Comment out `link_section` on procedures

---
 core/runtime/entry_unix.odin | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'core/runtime')

diff --git a/core/runtime/entry_unix.odin b/core/runtime/entry_unix.odin
index 67d2cbcb7..dd1e06625 100644
--- a/core/runtime/entry_unix.odin
+++ b/core/runtime/entry_unix.odin
@@ -5,13 +5,13 @@ package runtime
 import "core:intrinsics"
 
 when ODIN_BUILD_MODE == .Dynamic {
-	@(link_name="_odin_entry_point", linkage="strong", require, link_section=".init")
+	@(link_name="_odin_entry_point", linkage="strong", require/*, link_section=".init"*/)
 	_odin_entry_point :: proc "c" () {
 		context = default_context()
 		#force_no_inline _startup_runtime()
 		intrinsics.__entry_point()
 	}
-	@(link_name="_odin_exit_point", linkage="strong", require, link_section=".fini")
+	@(link_name="_odin_exit_point", linkage="strong", require/*, link_section=".fini"*/)
 	_odin_exit_point :: proc "c" () {
 		context = default_context()
 		#force_no_inline _cleanup_runtime()
-- 
cgit v1.2.3


From cfbc1a447bba4e3648d9e15c1f776d6d8068951e Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Thu, 20 Jan 2022 13:18:37 +0000
Subject: Correct inverse and inverse_transpose for 2x2 matrices

---
 core/runtime/core_builtin_matrix.odin | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

(limited to 'core/runtime')

diff --git a/core/runtime/core_builtin_matrix.odin b/core/runtime/core_builtin_matrix.odin
index 08dca288e..53589587c 100644
--- a/core/runtime/core_builtin_matrix.odin
+++ b/core/runtime/core_builtin_matrix.odin
@@ -146,14 +146,14 @@ matrix2x2_inverse_transpose :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y:
 	d := x[0, 0]*x[1, 1] - x[0, 1]*x[1, 0]
 	when intrinsics.type_is_integer(T) {
 		y[0, 0] = +x[1, 1] / d
-		y[1, 0] = -x[1, 0] / d
-		y[0, 1] = -x[0, 1] / d
+		y[1, 0] = -x[0, 1] / d
+		y[0, 1] = -x[1, 0] / d
 		y[1, 1] = +x[0, 0] / d
 	} else {
 		id := 1 / d
 		y[0, 0] = +x[1, 1] * id
-		y[1, 0] = -x[1, 0] * id
-		y[0, 1] = -x[0, 1] * id
+		y[1, 0] = -x[0, 1] * id
+		y[0, 1] = -x[1, 0] * id
 		y[1, 1] = +x[0, 0] * id
 	}
 	return
@@ -214,16 +214,16 @@ matrix1x1_inverse :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) {
 matrix2x2_inverse :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) {
 	d := x[0, 0]*x[1, 1] - x[0, 1]*x[1, 0]
 	when intrinsics.type_is_integer(T) {
-		y[0, 0] = x[1, 1] / d
-		y[0, 1] = x[1, 0] / d
-		y[1, 0] = x[0, 1] / d
-		y[1, 1] = x[0, 0] / d
+		y[0, 0] = +x[1, 1] / d
+		y[0, 1] = -x[0, 1] / d
+		y[1, 0] = -x[1, 0] / d
+		y[1, 1] = +x[0, 0] / d
 	} else {
 		id := 1 / d
-		y[0, 0] = x[1, 1] * id
-		y[0, 1] = x[1, 0] * id
-		y[1, 0] = x[0, 1] * id
-		y[1, 1] = x[0, 0] * id
+		y[0, 0] = +x[1, 1] * id
+		y[0, 1] = -x[0, 1] * id
+		y[1, 0] = -x[1, 0] * id
+		y[1, 1] = +x[0, 0] * id
 	}
 	return
 }
-- 
cgit v1.2.3


From 3d7d3471924574beee08fc304a6daf6a8707d723 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Thu, 20 Jan 2022 19:56:05 +0000
Subject: Convert `ODIN_OS` and `ODIN_ARCH` to use enums rather than use
 strings

---
 core/c/c.odin                                    |  8 ++---
 core/c/libc/complex.odin                         |  4 +--
 core/c/libc/ctype.odin                           |  4 +--
 core/c/libc/errno.odin                           | 10 +++----
 core/c/libc/math.odin                            |  4 +--
 core/c/libc/setjmp.odin                          |  6 ++--
 core/c/libc/signal.odin                          | 10 +++----
 core/c/libc/stdio.odin                           | 10 +++----
 core/c/libc/stdlib.odin                          | 10 +++----
 core/c/libc/string.odin                          |  4 +--
 core/c/libc/threads.odin                         |  6 ++--
 core/c/libc/time.odin                            |  8 ++---
 core/c/libc/uchar.odin                           |  4 +--
 core/c/libc/wchar.odin                           |  4 +--
 core/c/libc/wctype.odin                          | 10 +++----
 core/crypto/_fiat/field_poly1305/field.odin      |  2 +-
 core/crypto/chacha20/chacha20.odin               |  2 +-
 core/crypto/rand_generic.odin                    |  2 +-
 core/image/png/example.odin                      |  2 +-
 core/image/png/helpers.odin                      |  2 +-
 core/os/file_windows.odin                        |  2 +-
 core/os/os.odin                                  |  2 +-
 core/os/os2/user.odin                            | 16 +++++-----
 core/os/os_darwin.odin                           |  2 +-
 core/os/os_linux.odin                            | 26 ++++++++---------
 core/os/stream.odin                              |  6 ++--
 core/path/filepath/match.odin                    | 10 +++----
 core/path/filepath/path.odin                     |  4 +--
 core/path/filepath/path_unix.odin                |  4 +--
 core/runtime/core.odin                           |  2 +-
 core/runtime/default_allocators_nil.odin         |  2 +-
 core/runtime/default_temporary_allocator.odin    |  2 +-
 core/runtime/entry_windows.odin                  |  2 +-
 core/runtime/error_checks.odin                   |  4 +--
 core/runtime/internal.odin                       |  2 +-
 core/runtime/procs.odin                          |  4 +--
 core/sync/sync2/primitives.odin                  |  2 +-
 core/sync/sync2/primitives_internal.odin         |  2 +-
 core/sys/unix/syscalls_linux.odin                |  8 ++---
 core/time/time_unix.odin                         |  2 +-
 src/checker.cpp                                  | 37 ++++++++++++++++++++++--
 vendor/ENet/enet.odin                            |  4 +--
 vendor/OpenGL/helpers.odin                       |  2 +-
 vendor/botan/bindings/botan.odin                 |  6 ++--
 vendor/glfw/bindings/bindings.odin               |  6 ++--
 vendor/glfw/native.odin                          |  6 ++--
 vendor/miniaudio/common.odin                     |  6 ++--
 vendor/miniaudio/data_conversion.odin            |  4 +--
 vendor/miniaudio/decoding.odin                   |  4 +--
 vendor/miniaudio/device_io_procs.odin            |  4 +--
 vendor/miniaudio/device_io_types.odin            | 32 ++++++++++----------
 vendor/miniaudio/encoding.odin                   |  4 +--
 vendor/miniaudio/filtering.odin                  |  4 +--
 vendor/miniaudio/generation.odin                 |  4 +--
 vendor/miniaudio/logging.odin                    |  4 +--
 vendor/miniaudio/utilities.odin                  |  4 +--
 vendor/miniaudio/vfs.odin                        |  4 +--
 vendor/portmidi/portmidi.odin                    |  2 +-
 vendor/portmidi/util.odin                        |  2 +-
 vendor/raylib/raylib.odin                        |  6 ++--
 vendor/raylib/rlgl.odin                          |  6 ++--
 vendor/sdl2/image/sdl_image.odin                 |  8 ++---
 vendor/sdl2/mixer/sdl_mixer.odin                 |  8 ++---
 vendor/sdl2/net/sdl_net.odin                     |  8 ++---
 vendor/sdl2/sdl2.odin                            |  8 ++---
 vendor/sdl2/sdl_audio.odin                       |  8 ++---
 vendor/sdl2/sdl_blendmode.odin                   |  8 ++---
 vendor/sdl2/sdl_cpuinfo.odin                     |  8 ++---
 vendor/sdl2/sdl_events.odin                      |  8 ++---
 vendor/sdl2/sdl_gamecontroller.odin              |  8 ++---
 vendor/sdl2/sdl_gesture_haptic.odin              |  8 ++---
 vendor/sdl2/sdl_hints.odin                       |  8 ++---
 vendor/sdl2/sdl_joystick.odin                    |  8 ++---
 vendor/sdl2/sdl_keyboard.odin                    |  8 ++---
 vendor/sdl2/sdl_log.odin                         |  8 ++---
 vendor/sdl2/sdl_messagebox.odin                  |  8 ++---
 vendor/sdl2/sdl_metal.odin                       |  8 ++---
 vendor/sdl2/sdl_mouse.odin                       |  8 ++---
 vendor/sdl2/sdl_mutex.odin                       |  8 ++---
 vendor/sdl2/sdl_pixels.odin                      |  8 ++---
 vendor/sdl2/sdl_rect.odin                        |  8 ++---
 vendor/sdl2/sdl_render.odin                      |  8 ++---
 vendor/sdl2/sdl_rwops.odin                       |  8 ++---
 vendor/sdl2/sdl_stdinc.odin                      |  8 ++---
 vendor/sdl2/sdl_surface.odin                     |  8 ++---
 vendor/sdl2/sdl_system.odin                      |  8 ++---
 vendor/sdl2/sdl_syswm.odin                       |  8 ++---
 vendor/sdl2/sdl_thread.odin                      |  8 ++---
 vendor/sdl2/sdl_timer.odin                       |  8 ++---
 vendor/sdl2/sdl_touch.odin                       |  8 ++---
 vendor/sdl2/sdl_video.odin                       |  8 ++---
 vendor/sdl2/sdl_vulkan.odin                      |  8 ++---
 vendor/sdl2/ttf/sdl_ttf.odin                     |  8 ++---
 vendor/stb/image/stb_image.odin                  |  4 +--
 vendor/stb/image/stb_image_resize.odin           |  4 +--
 vendor/stb/image/stb_image_write.odin            |  4 +--
 vendor/stb/rect_pack/stb_rect_pack.odin          |  4 +--
 vendor/stb/truetype/stb_truetype.odin            |  4 +--
 vendor/stb/vorbis/stb_vorbis.odin                |  4 +--
 vendor/vulkan/_gen/create_vulkan_odin_wrapper.py |  2 +-
 vendor/vulkan/structs.odin                       |  2 +-
 101 files changed, 341 insertions(+), 310 deletions(-)

(limited to 'core/runtime')

diff --git a/core/c/c.odin b/core/c/c.odin
index d0b8e377f..05732476f 100644
--- a/core/c/c.odin
+++ b/core/c/c.odin
@@ -7,20 +7,20 @@ char           :: builtin.u8  // assuming -funsigned-char
 schar          :: builtin.i8
 short          :: builtin.i16
 int            :: builtin.i32
-long           :: builtin.i32 when (ODIN_OS == "windows" || size_of(builtin.rawptr) == 4) else builtin.i64
+long           :: builtin.i32 when (ODIN_OS == .Windows || size_of(builtin.rawptr) == 4) else builtin.i64
 longlong       :: builtin.i64
 
 uchar          :: builtin.u8
 ushort         :: builtin.u16
 uint           :: builtin.u32
-ulong          :: builtin.u32 when (ODIN_OS == "windows" || size_of(builtin.rawptr) == 4) else builtin.u64
+ulong          :: builtin.u32 when (ODIN_OS == .Windows || size_of(builtin.rawptr) == 4) else builtin.u64
 ulonglong      :: builtin.u64
 
 bool           :: builtin.bool
 
 size_t         :: builtin.uint
 ssize_t        :: builtin.int
-wchar_t        :: builtin.u16 when (ODIN_OS == "windows") else builtin.u32
+wchar_t        :: builtin.u16 when (ODIN_OS == .Windows) else builtin.u32
 
 float          :: builtin.f32
 double         :: builtin.f64
@@ -48,7 +48,7 @@ int_least64_t  :: builtin.i64
 uint_least64_t :: builtin.u64
 
 // Same on Windows, Linux, and FreeBSD
-when ODIN_ARCH == "i386" || ODIN_ARCH == "amd64" {
+when ODIN_ARCH == .i386 || ODIN_ARCH == .amd64 {
 	int_fast8_t    :: builtin.i8
 	uint_fast8_t   :: builtin.u8
 	int_fast16_t   :: builtin.i32
diff --git a/core/c/libc/complex.odin b/core/c/libc/complex.odin
index 62b28f0cd..22c422cce 100644
--- a/core/c/libc/complex.odin
+++ b/core/c/libc/complex.odin
@@ -2,9 +2,9 @@ package libc
 
 // 7.3 Complex arithmetic
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	foreign import libc "system:libucrt.lib"
-} else when ODIN_OS == "darwin" {
+} else when ODIN_OS == .Darwin {
 	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
diff --git a/core/c/libc/ctype.odin b/core/c/libc/ctype.odin
index 05d9dcd37..185385a5e 100644
--- a/core/c/libc/ctype.odin
+++ b/core/c/libc/ctype.odin
@@ -1,8 +1,8 @@
 package libc
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	foreign import libc "system:libucrt.lib"
-} else when ODIN_OS == "darwin" {
+} else when ODIN_OS == .Darwin {
 	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
diff --git a/core/c/libc/errno.odin b/core/c/libc/errno.odin
index 8ebe2f734..ecde6af59 100644
--- a/core/c/libc/errno.odin
+++ b/core/c/libc/errno.odin
@@ -2,9 +2,9 @@ package libc
 
 // 7.5 Errors
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	foreign import libc "system:libucrt.lib"
-} else when ODIN_OS == "darwin" {
+} else when ODIN_OS == .Darwin {
 	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
@@ -14,7 +14,7 @@ when ODIN_OS == "windows" {
 //	EDOM,
 //	EILSEQ
 //	ERANGE
-when ODIN_OS == "linux" || ODIN_OS == "freebsd" {
+when ODIN_OS == .Linux || ODIN_OS == .FreeBSD {
 	@(private="file")
 	@(default_calling_convention="c")
 	foreign libc {
@@ -27,7 +27,7 @@ when ODIN_OS == "linux" || ODIN_OS == "freebsd" {
 	ERANGE :: 34
 }
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	@(private="file")
 	@(default_calling_convention="c")
 	foreign libc {
@@ -40,7 +40,7 @@ when ODIN_OS == "windows" {
 	ERANGE :: 34
 }
 
-when ODIN_OS == "darwin" {
+when ODIN_OS == .Darwin {
 	@(private="file")
 	@(default_calling_convention="c")
 	foreign libc {
diff --git a/core/c/libc/math.odin b/core/c/libc/math.odin
index ee702b82e..97f77236f 100644
--- a/core/c/libc/math.odin
+++ b/core/c/libc/math.odin
@@ -4,9 +4,9 @@ package libc
 
 import "core:intrinsics"
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	foreign import libc "system:libucrt.lib"
-} else when ODIN_OS == "darwin" {
+} else when ODIN_OS == .Darwin {
 	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
diff --git a/core/c/libc/setjmp.odin b/core/c/libc/setjmp.odin
index dcd4a9c64..c2cd1d047 100644
--- a/core/c/libc/setjmp.odin
+++ b/core/c/libc/setjmp.odin
@@ -2,14 +2,14 @@ package libc
 
 // 7.13 Nonlocal jumps
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	foreign import libc "system:libucrt.lib"
-} else when ODIN_OS == "darwin" {
+} else when ODIN_OS == .Darwin {
 	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
 }
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	@(default_calling_convention="c")
 	foreign libc {
 		// 7.13.1 Save calling environment
diff --git a/core/c/libc/signal.odin b/core/c/libc/signal.odin
index e1044dc02..186b74d8c 100644
--- a/core/c/libc/signal.odin
+++ b/core/c/libc/signal.odin
@@ -2,9 +2,9 @@ package libc
 
 // 7.14 Signal handling
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	foreign import libc "system:libucrt.lib"
-} else when ODIN_OS == "darwin" {
+} else when ODIN_OS == .Darwin {
 	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
@@ -21,7 +21,7 @@ foreign libc {
 	raise  :: proc(sig: int) -> int ---
 }
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	SIG_ERR :: rawptr(~uintptr(0)) 
 	SIG_DFL :: rawptr(uintptr(0))
 	SIG_IGN :: rawptr(uintptr(1))
@@ -34,7 +34,7 @@ when ODIN_OS == "windows" {
 	SIGTERM :: 15
 }
 
-when ODIN_OS == "linux" || ODIN_OS == "freebsd" {
+when ODIN_OS == .Linux || ODIN_OS == .FreeBSD {
 	SIG_ERR  :: rawptr(~uintptr(0))
 	SIG_DFL  :: rawptr(uintptr(0))
 	SIG_IGN  :: rawptr(uintptr(1)) 
@@ -47,7 +47,7 @@ when ODIN_OS == "linux" || ODIN_OS == "freebsd" {
 	SIGTERM  :: 15
 }
 
-when ODIN_OS == "darwin" {
+when ODIN_OS == .Darwin {
 	SIG_ERR  :: rawptr(~uintptr(0))
 	SIG_DFL  :: rawptr(uintptr(0))
 	SIG_IGN  :: rawptr(uintptr(1)) 
diff --git a/core/c/libc/stdio.odin b/core/c/libc/stdio.odin
index 4a39c22e9..33be34625 100644
--- a/core/c/libc/stdio.odin
+++ b/core/c/libc/stdio.odin
@@ -1,8 +1,8 @@
 package libc
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	foreign import libc "system:libucrt.lib"
-} else when ODIN_OS == "darwin" {
+} else when ODIN_OS == .Darwin {
 	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
@@ -13,7 +13,7 @@ when ODIN_OS == "windows" {
 FILE :: struct {}
 
 // MSVCRT compatible.
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	_IOFBF       :: 0x0000
 	_IONBF       :: 0x0004
 	_IOLBF       :: 0x0040
@@ -48,7 +48,7 @@ when ODIN_OS == "windows" {
 }
 
 // GLIBC and MUSL compatible.
-when ODIN_OS == "linux" {
+when ODIN_OS == .Linux {
 	fpos_t        :: struct #raw_union { _: [16]char, _: longlong, _: double, }
 
 	_IOFBF        :: 0
@@ -78,7 +78,7 @@ when ODIN_OS == "linux" {
 	}
 }
 
-when ODIN_OS == "darwin" {
+when ODIN_OS == .Darwin {
 	fpos_t :: distinct i64
 	
 	_IOFBF        :: 0
diff --git a/core/c/libc/stdlib.odin b/core/c/libc/stdlib.odin
index b368c0cee..a278db0ef 100644
--- a/core/c/libc/stdlib.odin
+++ b/core/c/libc/stdlib.odin
@@ -2,15 +2,15 @@ package libc
 
 // 7.22 General utilities
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	foreign import libc "system:libucrt.lib"
-} else when ODIN_OS == "darwin" {
+} else when ODIN_OS == .Darwin {
 	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
 }
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	RAND_MAX :: 0x7fff
 
 	@(private="file")
@@ -24,7 +24,7 @@ when ODIN_OS == "windows" {
 	}
 }
 
-when ODIN_OS == "linux" {
+when ODIN_OS == .Linux {
 	RAND_MAX :: 0x7fffffff
 
 	// GLIBC and MUSL only
@@ -40,7 +40,7 @@ when ODIN_OS == "linux" {
 }
 
 
-when ODIN_OS == "darwin" {
+when ODIN_OS == .Darwin {
 	RAND_MAX :: 0x7fffffff
 
 	// GLIBC and MUSL only
diff --git a/core/c/libc/string.odin b/core/c/libc/string.odin
index c91124dcb..8f83ee1b9 100644
--- a/core/c/libc/string.odin
+++ b/core/c/libc/string.odin
@@ -4,9 +4,9 @@ import "core:runtime"
 
 // 7.24 String handling
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	foreign import libc "system:libucrt.lib"
-} else when ODIN_OS == "darwin" {
+} else when ODIN_OS == .Darwin {
 	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
diff --git a/core/c/libc/threads.odin b/core/c/libc/threads.odin
index ad305b517..a7a45150d 100644
--- a/core/c/libc/threads.odin
+++ b/core/c/libc/threads.odin
@@ -5,7 +5,7 @@ package libc
 thrd_start_t :: proc "c" (rawptr) -> int
 tss_dtor_t   :: proc "c" (rawptr)
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	foreign import libc {
 		"system:libucrt.lib", 
 		"system:msvcprt.lib"
@@ -74,7 +74,7 @@ when ODIN_OS == "windows" {
 }
 
 // GLIBC and MUSL compatible constants and types.
-when ODIN_OS == "linux" {
+when ODIN_OS == .Linux {
 	foreign import libc {
 		"system:c",
 		"system:pthread"
@@ -138,6 +138,6 @@ when ODIN_OS == "linux" {
 }
 
 
-when ODIN_OS == "darwin" {
+when ODIN_OS == .Darwin {
 	// TODO: find out what this is meant to be!
 }
diff --git a/core/c/libc/time.odin b/core/c/libc/time.odin
index 96e80e216..b3539a227 100644
--- a/core/c/libc/time.odin
+++ b/core/c/libc/time.odin
@@ -2,9 +2,9 @@ package libc
 
 // 7.27 Date and time
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	foreign import libc "system:libucrt.lib"
-} else when ODIN_OS == "darwin" {
+} else when ODIN_OS == .Darwin {
 	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
@@ -12,7 +12,7 @@ when ODIN_OS == "windows" {
 
 // We enforce 64-bit time_t and timespec as there is no reason to use 32-bit as
 // we approach the 2038 problem. Windows has defaulted to this since VC8 (2005).
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	foreign libc {
 		// 7.27.2 Time manipulation functions
 		                               clock        :: proc() -> clock_t ---
@@ -45,7 +45,7 @@ when ODIN_OS == "windows" {
 	}
 }
 
-when ODIN_OS == "linux" || ODIN_OS == "freebsd" || ODIN_OS == "darwin" {
+when ODIN_OS == .Linux || ODIN_OS == .FreeBSD || ODIN_OS == .Darwin {
 	@(default_calling_convention="c")
 	foreign libc {
 		// 7.27.2 Time manipulation functions
diff --git a/core/c/libc/uchar.odin b/core/c/libc/uchar.odin
index e49c29e51..a10969ceb 100644
--- a/core/c/libc/uchar.odin
+++ b/core/c/libc/uchar.odin
@@ -2,9 +2,9 @@ package libc
 
 // 7.28 Unicode utilities
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	foreign import libc "system:libucrt.lib"
-} else when ODIN_OS == "darwin" {
+} else when ODIN_OS == .Darwin {
 	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
diff --git a/core/c/libc/wchar.odin b/core/c/libc/wchar.odin
index fc206e494..f2aa8410e 100644
--- a/core/c/libc/wchar.odin
+++ b/core/c/libc/wchar.odin
@@ -2,9 +2,9 @@ package libc
 
 // 7.29 Extended multibyte and wide character utilities
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	foreign import libc "system:libucrt.lib"
-} else when ODIN_OS == "darwin" {
+} else when ODIN_OS == .Darwin {
 	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
diff --git a/core/c/libc/wctype.odin b/core/c/libc/wctype.odin
index 47f17e0b4..942726ba6 100644
--- a/core/c/libc/wctype.odin
+++ b/core/c/libc/wctype.odin
@@ -2,25 +2,25 @@ package libc
 
 // 7.30 Wide character classification and mapping utilities
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	foreign import libc "system:libucrt.lib"
-} else when ODIN_OS == "darwin" {
+} else when ODIN_OS == .Darwin {
 	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
 }
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	wctrans_t :: distinct wchar_t
 	wctype_t  :: distinct ushort
 }
 
-when ODIN_OS == "linux" {
+when ODIN_OS == .Linux {
 	wctrans_t :: distinct intptr_t
 	wctype_t  :: distinct ulong
 }
 
-when ODIN_OS == "darwin" {
+when ODIN_OS == .Darwin {
 	wctrans_t :: distinct int
 	wctype_t  :: distinct u32
 }
diff --git a/core/crypto/_fiat/field_poly1305/field.odin b/core/crypto/_fiat/field_poly1305/field.odin
index 4ed8acbff..ca458e079 100644
--- a/core/crypto/_fiat/field_poly1305/field.odin
+++ b/core/crypto/_fiat/field_poly1305/field.odin
@@ -22,7 +22,7 @@ fe_from_bytes :: #force_inline proc (out1: ^Tight_Field_Element, arg1: []byte, a
 
 	assert(len(arg1) == 16)
 
-	when ODIN_ARCH == "i386" || ODIN_ARCH == "amd64" {
+	when ODIN_ARCH == .i386 || ODIN_ARCH == .amd64 {
 		// While it may be unwise to do deserialization here on our
 		// own when fiat-crypto provides equivalent functionality,
 		// doing it this way provides a little under 3x performance
diff --git a/core/crypto/chacha20/chacha20.odin b/core/crypto/chacha20/chacha20.odin
index e32dacb2c..229949c22 100644
--- a/core/crypto/chacha20/chacha20.odin
+++ b/core/crypto/chacha20/chacha20.odin
@@ -346,7 +346,7 @@ _do_blocks :: proc (ctx: ^Context, dst, src: []byte, nr_blocks: int) {
 		// Until dedicated assembly can be written leverage the fact that
 		// the callers of this routine ensure that src/dst are valid.
 
-		when ODIN_ARCH == "i386" || ODIN_ARCH == "amd64" {
+		when ODIN_ARCH == .i386 || ODIN_ARCH == .amd64 {
 			// util.PUT_U32_LE/util.U32_LE are not required on little-endian
 			// systems that also happen to not be strict about aligned
 			// memory access.
diff --git a/core/crypto/rand_generic.odin b/core/crypto/rand_generic.odin
index 98890b5b1..be6987ee2 100644
--- a/core/crypto/rand_generic.odin
+++ b/core/crypto/rand_generic.odin
@@ -1,6 +1,6 @@
 package crypto
 
-when ODIN_OS != "linux" {
+when ODIN_OS != .Linux {
 	_rand_bytes :: proc (dst: []byte) {
 		unimplemented("crypto: rand_bytes not supported on this OS")
 	}
diff --git a/core/image/png/example.odin b/core/image/png/example.odin
index f4eb5128e..17436c260 100644
--- a/core/image/png/example.odin
+++ b/core/image/png/example.odin
@@ -207,7 +207,7 @@ write_image_as_ppm :: proc(filename: string, image: ^image.Image) -> (success: b
 	}
 
 	mode: int = 0
-	when ODIN_OS == "linux" || ODIN_OS == "darwin" {
+	when ODIN_OS == .Linux || ODIN_OS == .Darwin {
 		// NOTE(justasd): 644 (owner read, write; group read; others read)
 		mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH
 	}
diff --git a/core/image/png/helpers.odin b/core/image/png/helpers.odin
index ecc0183bc..6ec674544 100644
--- a/core/image/png/helpers.odin
+++ b/core/image/png/helpers.odin
@@ -443,7 +443,7 @@ when false {
 		}
 
 		mode: int = 0
-		when ODIN_OS == "linux" || ODIN_OS == "darwin" {
+		when ODIN_OS == .Linux || ODIN_OS == .Darwin {
 			// NOTE(justasd): 644 (owner read, write; group read; others read)
 			mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH
 		}
diff --git a/core/os/file_windows.odin b/core/os/file_windows.odin
index 419f8bbc2..8a0f2ed64 100644
--- a/core/os/file_windows.odin
+++ b/core/os/file_windows.odin
@@ -399,7 +399,7 @@ is_abs :: proc(path: string) -> bool {
 	if len(path) > 0 && path[0] == '/' {
 		return true
 	}
-	when ODIN_OS == "windows" {
+	when ODIN_OS == .Windows {
 		if len(path) > 2 {
 			switch path[0] {
 			case 'A'..='Z', 'a'..='z':
diff --git a/core/os/os.odin b/core/os/os.odin
index 83158be80..19a8099ef 100644
--- a/core/os/os.odin
+++ b/core/os/os.odin
@@ -139,7 +139,7 @@ write_entire_file :: proc(name: string, data: []byte, truncate := true) -> (succ
 	}
 
 	mode: int = 0
-	when OS == "linux" || OS == "darwin" {
+	when OS == .Linux || OS == .Darwin {
 		// NOTE(justasd): 644 (owner read, write; group read; others read)
 		mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH
 	}
diff --git a/core/os/os2/user.odin b/core/os/os2/user.odin
index 6dd99c621..976e61bb1 100644
--- a/core/os/os2/user.odin
+++ b/core/os/os2/user.odin
@@ -3,13 +3,13 @@ package os2
 import "core:strings"
 
 user_cache_dir :: proc(allocator := context.allocator) -> (dir: string, is_defined: bool) {
-	switch ODIN_OS {
-	case "windows":
+	#partial switch ODIN_OS {
+	case .Windows:
 		dir = get_env("LocalAppData")
 		if dir != "" {
 			dir = strings.clone(dir, allocator)
 		}
-	case "darwin":
+	case .Darwin:
 		dir = get_env("HOME")
 		if dir != "" {
 			dir = strings.concatenate({dir, "/Library/Caches"}, allocator)
@@ -29,13 +29,13 @@ user_cache_dir :: proc(allocator := context.allocator) -> (dir: string, is_defin
 }
 
 user_config_dir :: proc(allocator := context.allocator) -> (dir: string, is_defined: bool) {
-	switch ODIN_OS {
-	case "windows":
+	#partial switch ODIN_OS {
+	case .Windows:
 		dir = get_env("AppData")
 		if dir != "" {
 			dir = strings.clone(dir, allocator)
 		}
-	case "darwin":
+	case .Darwin:
 		dir = get_env("HOME")
 		if dir != "" {
 			dir = strings.concatenate({dir, "/Library/Application Support"}, allocator)
@@ -56,8 +56,8 @@ user_config_dir :: proc(allocator := context.allocator) -> (dir: string, is_defi
 
 user_home_dir :: proc() -> (dir: string, is_defined: bool) {
 	env := "HOME"
-	switch ODIN_OS {
-	case "windows":
+	#partial switch ODIN_OS {
+	case .Windows:
 		env = "USERPROFILE"
 	}
 	if v := get_env(env); v != "" {
diff --git a/core/os/os_darwin.odin b/core/os/os_darwin.odin
index b32453a5d..4828c5167 100644
--- a/core/os/os_darwin.odin
+++ b/core/os/os_darwin.odin
@@ -335,7 +335,7 @@ open :: proc(path: string, flags: int = O_RDWR, mode: int = 0) -> (Handle, Errno
 		return INVALID_HANDLE, 1
 	}
 
-when  ODIN_OS == "darwin" && ODIN_ARCH == "arm64" {
+when  ODIN_OS == .Darwin && ODIN_ARCH == .arm64 {
 	if mode != 0 {
 		err := fchmod(handle, cast(u16)mode)
 		if err != 0 {
diff --git a/core/os/os_linux.odin b/core/os/os_linux.odin
index 1c796f1b8..3eb76249c 100644
--- a/core/os/os_linux.odin
+++ b/core/os/os_linux.odin
@@ -271,7 +271,7 @@ AT_REMOVEDIR        :: uintptr(0x200)
 AT_SYMLINK_NOFOLLOW :: uintptr(0x100)
 
 _unix_open :: proc(path: cstring, flags: int, mode: int = 0o000) -> Handle {
-	when ODIN_ARCH != "arm64" {
+	when ODIN_ARCH != .arm64 {
 		res := int(intrinsics.syscall(unix.SYS_open, uintptr(rawptr(path)), uintptr(flags), uintptr(mode)))
 	} else { // NOTE: arm64 does not have open
 		res := int(intrinsics.syscall(unix.SYS_openat, uintptr(AT_FDCWD), uintptr(rawptr(path), uintptr(flags), uintptr(mode))))
@@ -292,7 +292,7 @@ _unix_write :: proc(fd: Handle, buf: rawptr, size: uint) -> int {
 }
 
 _unix_seek :: proc(fd: Handle, offset: i64, whence: int) -> i64 {
-	when ODIN_ARCH == "amd64" || ODIN_ARCH == "arm64" {
+	when ODIN_ARCH == .amd64 || ODIN_ARCH == .arm64 {
 		return i64(intrinsics.syscall(unix.SYS_lseek, uintptr(fd), uintptr(offset), uintptr(whence)))
 	} else {
 		low := uintptr(offset & 0xFFFFFFFF)
@@ -304,9 +304,9 @@ _unix_seek :: proc(fd: Handle, offset: i64, whence: int) -> i64 {
 }
 
 _unix_stat :: proc(path: cstring, stat: ^OS_Stat) -> int {
-	when ODIN_ARCH == "amd64" {
+	when ODIN_ARCH == .amd64 {
 		return int(intrinsics.syscall(unix.SYS_stat, uintptr(rawptr(path)), uintptr(stat)))
-	} else when ODIN_ARCH != "arm64" {
+	} else when ODIN_ARCH != .arm64 {
 		return int(intrinsics.syscall(unix.SYS_stat64, uintptr(rawptr(path)), uintptr(stat)))
 	} else { // NOTE: arm64 does not have stat
 		return int(intrinsics.syscall(unix.SYS_fstatat, uintptr(AT_FDCWD), uintptr(rawptr(path)), uintptr(stat), 0))
@@ -314,7 +314,7 @@ _unix_stat :: proc(path: cstring, stat: ^OS_Stat) -> int {
 }
 
 _unix_fstat :: proc(fd: Handle, stat: ^OS_Stat) -> int {
-	when ODIN_ARCH == "amd64" || ODIN_ARCH == "arm64" {
+	when ODIN_ARCH == .amd64 || ODIN_ARCH == .arm64 {
 		return int(intrinsics.syscall(unix.SYS_fstat, uintptr(fd), uintptr(stat)))
 	} else {
 		return int(intrinsics.syscall(unix.SYS_fstat64, uintptr(fd), uintptr(stat)))
@@ -322,9 +322,9 @@ _unix_fstat :: proc(fd: Handle, stat: ^OS_Stat) -> int {
 }
 
 _unix_lstat :: proc(path: cstring, stat: ^OS_Stat) -> int {
-	when ODIN_ARCH == "amd64" {
+	when ODIN_ARCH == .amd64 {
 		return int(intrinsics.syscall(unix.SYS_lstat, uintptr(rawptr(path)), uintptr(stat)))
-	} else when ODIN_ARCH != "arm64" {
+	} else when ODIN_ARCH != .arm64 {
 		return int(intrinsics.syscall(unix.SYS_lstat64, uintptr(rawptr(path)), uintptr(stat)))
 	} else { // NOTE: arm64 does not have any lstat
 		return int(intrinsics.syscall(unix.SYS_fstatat, uintptr(AT_FDCWD), uintptr(rawptr(path)), uintptr(stat), AT_SYMLINK_NOFOLLOW))
@@ -332,7 +332,7 @@ _unix_lstat :: proc(path: cstring, stat: ^OS_Stat) -> int {
 }
 
 _unix_readlink :: proc(path: cstring, buf: rawptr, bufsiz: uint) -> int {
-	when ODIN_ARCH != "arm64" {
+	when ODIN_ARCH != .arm64 {
 		return int(intrinsics.syscall(unix.SYS_readlink, uintptr(rawptr(path)), uintptr(buf), uintptr(bufsiz)))
 	} else { // NOTE: arm64 does not have readlink
 		return int(intrinsics.syscall(unix.SYS_readlinkat, uintptr(AT_FDCWD), uintptr(rawptr(path)), uintptr(buf), uintptr(bufsiz)))
@@ -340,7 +340,7 @@ _unix_readlink :: proc(path: cstring, buf: rawptr, bufsiz: uint) -> int {
 }
 
 _unix_access :: proc(path: cstring, mask: int) -> int {
-	when ODIN_ARCH != "arm64" {
+	when ODIN_ARCH != .arm64 {
 		return int(intrinsics.syscall(unix.SYS_access, uintptr(rawptr(path)), uintptr(mask)))
 	} else { // NOTE: arm64 does not have access
 		return int(intrinsics.syscall(unix.SYS_faccessat, uintptr(AT_FDCWD), uintptr(rawptr(path)), uintptr(mask)))
@@ -356,7 +356,7 @@ _unix_chdir :: proc(path: cstring) -> int {
 }
 
 _unix_rename :: proc(old, new: cstring) -> int {
-	when ODIN_ARCH != "arm64" {
+	when ODIN_ARCH != .arm64 {
 		return int(intrinsics.syscall(unix.SYS_rename, uintptr(rawptr(old)), uintptr(rawptr(new))))
 	} else { // NOTE: arm64 does not have rename
 		return int(intrinsics.syscall(unix.SYS_renameat, uintptr(AT_FDCWD), uintptr(rawptr(old)), uintptr(rawptr(new))))
@@ -364,7 +364,7 @@ _unix_rename :: proc(old, new: cstring) -> int {
 }
 
 _unix_unlink :: proc(path: cstring) -> int {
-	when ODIN_ARCH != "arm64" {
+	when ODIN_ARCH != .arm64 {
 		return int(intrinsics.syscall(unix.SYS_unlink, uintptr(rawptr(path))))
 	} else { // NOTE: arm64 does not have unlink
 		return int(intrinsics.syscall(unix.SYS_unlinkat, uintptr(AT_FDCWD), uintptr(rawptr(path), 0)))
@@ -372,7 +372,7 @@ _unix_unlink :: proc(path: cstring) -> int {
 }
 
 _unix_rmdir :: proc(path: cstring) -> int {
-	when ODIN_ARCH != "arm64" {
+	when ODIN_ARCH != .arm64 {
 		return int(intrinsics.syscall(unix.SYS_rmdir, uintptr(rawptr(path))))
 	} else { // NOTE: arm64 does not have rmdir
 		return int(intrinsics.syscall(unix.SYS_unlinkat, uintptr(AT_FDCWD), uintptr(rawptr(path)), AT_REMOVEDIR))
@@ -380,7 +380,7 @@ _unix_rmdir :: proc(path: cstring) -> int {
 }
 
 _unix_mkdir :: proc(path: cstring, mode: u32) -> int {
-	when ODIN_ARCH != "arm64" {
+	when ODIN_ARCH != .arm64 {
 		return int(intrinsics.syscall(unix.SYS_mkdir, uintptr(rawptr(path)), uintptr(mode)))
 	} else { // NOTE: arm64 does not have mkdir
 		return int(intrinsics.syscall(unix.SYS_mkdirat, uintptr(AT_FDCWD), uintptr(rawptr(path)), uintptr(mode)))
diff --git a/core/os/stream.odin b/core/os/stream.odin
index 5cf5c8405..2c6e1d47f 100644
--- a/core/os/stream.odin
+++ b/core/os/stream.odin
@@ -19,7 +19,7 @@ _file_stream_vtable := &io.Stream_VTable{
 		return
 	},
 	impl_read_at = proc(s: io.Stream, p: []byte, offset: i64) -> (n: int, err: io.Error) {
-		when ODIN_OS == "windows" || ODIN_OS == "wasi" {
+		when ODIN_OS == .Windows || ODIN_OS == .WASI {
 			fd := Handle(uintptr(s.stream_data))
 			os_err: Errno
 			n, os_err = read_at(fd, p, offset)
@@ -33,7 +33,7 @@ _file_stream_vtable := &io.Stream_VTable{
 		return
 	},
 	impl_write_at = proc(s: io.Stream, p: []byte, offset: i64) -> (n: int, err: io.Error) {
-		when ODIN_OS == "windows" || ODIN_OS == "wasi" {
+		when ODIN_OS == .Windows || ODIN_OS == .WASI {
 			fd := Handle(uintptr(s.stream_data))
 			os_err: Errno
 			n, os_err = write_at(fd, p, offset)
@@ -53,7 +53,7 @@ _file_stream_vtable := &io.Stream_VTable{
 		return sz
 	},
 	impl_flush = proc(s: io.Stream) -> io.Error {
-		when ODIN_OS == "windows" {
+		when ODIN_OS == .Windows {
 			fd := Handle(uintptr(s.stream_data))
 			flush(fd)
 		} else {
diff --git a/core/path/filepath/match.odin b/core/path/filepath/match.odin
index cba44953d..c045f3ece 100644
--- a/core/path/filepath/match.odin
+++ b/core/path/filepath/match.odin
@@ -89,7 +89,7 @@ scan_chunk :: proc(pattern: string) -> (star: bool, chunk, rest: string) {
 	scan_loop: for i = 0; i < len(pattern); i += 1 {
 		switch pattern[i] {
 		case '\\':
-			when ODIN_OS != "windows" {
+			when ODIN_OS != .Windows {
 				if i+1 < len(pattern) {
 					i += 1
 				}
@@ -161,7 +161,7 @@ match_chunk :: proc(chunk, s: string) -> (rest: string, ok: bool, err: Match_Err
 			chunk = chunk[1:]
 
 		case '\\':
-			when ODIN_OS != "windows" {
+			when ODIN_OS != .Windows {
 				chunk = chunk[1:]
 				if len(chunk) == 0 {
 					err = .Syntax_Error
@@ -188,7 +188,7 @@ get_escape :: proc(chunk: string) -> (r: rune, next_chunk: string, err: Match_Er
 		return
 	}
 	chunk := chunk
-	if chunk[0] == '\\' && ODIN_OS != "windows" {
+	if chunk[0] == '\\' && ODIN_OS != .Windows {
 		chunk = chunk[1:]
 		if len(chunk) == 0 {
 			err = .Syntax_Error
@@ -231,7 +231,7 @@ glob :: proc(pattern: string, allocator := context.allocator) -> (matches: []str
 
 	dir, file := split(pattern)
 	volume_len := 0
-	when ODIN_OS == "windows" {
+	when ODIN_OS == .Windows {
 		volume_len, dir = clean_glob_path_windows(dir, temp_buf[:])
 	} else {
 		dir = clean_glob_path(dir)
@@ -308,7 +308,7 @@ _glob :: proc(dir, pattern: string, matches: ^[dynamic]string) -> (m: [dynamic]s
 
 @(private)
 has_meta :: proc(path: string) -> bool {
-	when ODIN_OS == "windows" {
+	when ODIN_OS == .Windows {
 		CHARS :: `*?[`
 	} else {
 		CHARS :: `*?[\`
diff --git a/core/path/filepath/path.odin b/core/path/filepath/path.odin
index 39cd80a47..d6e36f649 100644
--- a/core/path/filepath/path.odin
+++ b/core/path/filepath/path.odin
@@ -8,7 +8,7 @@ import "core:strings"
 is_separator :: proc(c: byte) -> bool {
 	switch c {
 	case '/':  return true
-	case '\\': return ODIN_OS == "windows"
+	case '\\': return ODIN_OS == .Windows
 	}
 	return false
 }
@@ -32,7 +32,7 @@ volume_name :: proc(path: string) -> string {
 }
 
 volume_name_len :: proc(path: string) -> int {
-	if ODIN_OS == "windows" {
+	if ODIN_OS == .Windows {
 		if len(path) < 2 {
 			return 0
 		}
diff --git a/core/path/filepath/path_unix.odin b/core/path/filepath/path_unix.odin
index 1db528a2f..3e49c4710 100644
--- a/core/path/filepath/path_unix.odin
+++ b/core/path/filepath/path_unix.odin
@@ -1,7 +1,7 @@
 //+build linux, darwin, freebsd
 package filepath
 
-when ODIN_OS == "darwin" {
+when ODIN_OS == .Darwin {
 	foreign import libc "System.framework"
 } else {
 	foreign import libc "system:c"
@@ -54,7 +54,7 @@ foreign libc {
 	@(link_name="free") _unix_free :: proc(ptr: rawptr) ---
 
 }
-when ODIN_OS == "darwin" {
+when ODIN_OS == .Darwin {
 	@(private)
 	foreign libc {
 		@(link_name="__error")          __error :: proc() -> ^i32 ---
diff --git a/core/runtime/core.odin b/core/runtime/core.odin
index 424650828..cd76b0bb5 100644
--- a/core/runtime/core.odin
+++ b/core/runtime/core.odin
@@ -539,7 +539,7 @@ __init_context :: proc "contextless" (c: ^Context) {
 }
 
 default_assertion_failure_proc :: proc(prefix, message: string, loc: Source_Code_Location) -> ! {
-	when ODIN_OS == "freestanding" {
+	when ODIN_OS == .Freestanding {
 		// Do nothing
 	} else {
 		print_caller_location(loc)
diff --git a/core/runtime/default_allocators_nil.odin b/core/runtime/default_allocators_nil.odin
index ccb4a3381..04dea0e19 100644
--- a/core/runtime/default_allocators_nil.odin
+++ b/core/runtime/default_allocators_nil.odin
@@ -32,7 +32,7 @@ nil_allocator :: proc() -> Allocator {
 
 
 
-when ODIN_OS == "freestanding" {
+when ODIN_OS == .Freestanding {
 	default_allocator_proc :: nil_allocator_proc
 	default_allocator :: nil_allocator
 } 
\ No newline at end of file
diff --git a/core/runtime/default_temporary_allocator.odin b/core/runtime/default_temporary_allocator.odin
index 01143e222..4337e555b 100644
--- a/core/runtime/default_temporary_allocator.odin
+++ b/core/runtime/default_temporary_allocator.odin
@@ -3,7 +3,7 @@ package runtime
 DEFAULT_TEMP_ALLOCATOR_BACKING_SIZE: int : #config(DEFAULT_TEMP_ALLOCATOR_BACKING_SIZE, 1<<22)
 
 
-when ODIN_OS == "freestanding" || ODIN_OS == "js" || ODIN_DEFAULT_TO_NIL_ALLOCATOR {
+when ODIN_OS == .Freestanding || ODIN_OS == .JS || ODIN_DEFAULT_TO_NIL_ALLOCATOR {
 	Default_Temp_Allocator :: struct {}
 	
 	default_temp_allocator_init :: proc(s: ^Default_Temp_Allocator, size: int, backup_allocator := context.allocator) {}
diff --git a/core/runtime/entry_windows.odin b/core/runtime/entry_windows.odin
index 35a6bb421..2f323cb41 100644
--- a/core/runtime/entry_windows.odin
+++ b/core/runtime/entry_windows.odin
@@ -22,7 +22,7 @@ when ODIN_BUILD_MODE == .Dynamic {
 		return true
 	}
 } else when !ODIN_TEST && !ODIN_NO_ENTRY_POINT {
-	when ODIN_ARCH == "i386" || ODIN_NO_CRT {
+	when ODIN_ARCH == .i386 || ODIN_NO_CRT {
 		@(link_name="mainCRTStartup", linkage="strong", require)
 		mainCRTStartup :: proc "stdcall" () -> i32 {
 			context = default_context()
diff --git a/core/runtime/error_checks.odin b/core/runtime/error_checks.odin
index 7f1aeb2d7..ed75cbea6 100644
--- a/core/runtime/error_checks.odin
+++ b/core/runtime/error_checks.odin
@@ -1,7 +1,7 @@
 package runtime
 
 bounds_trap :: proc "contextless" () -> ! {
-	when ODIN_OS == "windows" {
+	when ODIN_OS == .Windows {
 		windows_trap_array_bounds()
 	} else {
 		trap()
@@ -9,7 +9,7 @@ bounds_trap :: proc "contextless" () -> ! {
 }
 
 type_assertion_trap :: proc "contextless" () -> ! {
-	when ODIN_OS == "windows" {
+	when ODIN_OS == .Windows {
 		windows_trap_type_assertion()
 	} else {
 		trap()
diff --git a/core/runtime/internal.odin b/core/runtime/internal.odin
index 7b283a132..0d0e196c4 100644
--- a/core/runtime/internal.odin
+++ b/core/runtime/internal.odin
@@ -3,7 +3,7 @@ package runtime
 import "core:intrinsics"
 
 @(private="file")
-IS_WASM :: ODIN_ARCH == "wasm32" || ODIN_ARCH == "wasm64"
+IS_WASM :: ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64
 
 @(private)
 RUNTIME_LINKAGE :: "strong" when (
diff --git a/core/runtime/procs.odin b/core/runtime/procs.odin
index 961f6376f..5a1d11fe0 100644
--- a/core/runtime/procs.odin
+++ b/core/runtime/procs.odin
@@ -1,6 +1,6 @@
 package runtime
 
-when ODIN_NO_CRT && ODIN_OS == "windows" {
+when ODIN_NO_CRT && ODIN_OS == .Windows {
 	foreign import lib "system:NtDll.lib"
 	
 	@(private="file")
@@ -25,7 +25,7 @@ when ODIN_NO_CRT && ODIN_OS == "windows" {
 		RtlMoveMemory(dst, src, len)
 		return dst
 	}
-} else when ODIN_NO_CRT || (ODIN_ARCH == "wasm32" || ODIN_ARCH == "wasm64") {
+} else when ODIN_NO_CRT || (ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64) {
 	@(link_name="memset", linkage="strong", require)
 	memset :: proc "c" (ptr: rawptr, val: i32, len: int) -> rawptr {
 		if ptr != nil && len != 0 {
diff --git a/core/sync/sync2/primitives.odin b/core/sync/sync2/primitives.odin
index 6d056d439..046ecbc35 100644
--- a/core/sync/sync2/primitives.odin
+++ b/core/sync/sync2/primitives.odin
@@ -11,7 +11,7 @@ current_thread_id :: proc "contextless" () -> int {
 //
 // A Mutex must not be copied after first use
 Mutex :: struct {
-	impl: _Mutex,
+	impl: _Mutex `This is a tag`,
 }
 
 // mutex_lock locks m
diff --git a/core/sync/sync2/primitives_internal.odin b/core/sync/sync2/primitives_internal.odin
index ae7e2599c..eb692c6ae 100644
--- a/core/sync/sync2/primitives_internal.odin
+++ b/core/sync/sync2/primitives_internal.odin
@@ -93,7 +93,7 @@ when #config(ODIN_SYNC_RECURSIVE_MUTEX_USE_FUTEX, true) {
 }
 
 
-when ODIN_OS != "windows" {
+when ODIN_OS != .Windows {
 	RW_Mutex_State :: distinct uint
 	RW_Mutex_State_Half_Width :: size_of(RW_Mutex_State)*8/2
 	RW_Mutex_State_Is_Writing :: RW_Mutex_State(1)
diff --git a/core/sys/unix/syscalls_linux.odin b/core/sys/unix/syscalls_linux.odin
index 3dc3d2c74..0082c7261 100644
--- a/core/sys/unix/syscalls_linux.odin
+++ b/core/sys/unix/syscalls_linux.odin
@@ -15,7 +15,7 @@ import "core:intrinsics"
 //  386: arch/x86/entry/syscalls/sycall_32.tbl
 //  arm: arch/arm/tools/syscall.tbl
 
-when ODIN_ARCH == "amd64" {
+when ODIN_ARCH == .amd64 {
 	SYS_read : uintptr : 0
 	SYS_write : uintptr : 1
 	SYS_open : uintptr : 2
@@ -374,7 +374,7 @@ when ODIN_ARCH == "amd64" {
 	SYS_landlock_add_rule : uintptr : 445
 	SYS_landlock_restrict_self : uintptr : 446
 	SYS_memfd_secret : uintptr : 447
-} else when ODIN_ARCH == "arm64" {
+} else when ODIN_ARCH == .arm64 {
 	SYS_io_setup : uintptr : 0
 	SYS_io_destroy : uintptr : 1
 	SYS_io_submit : uintptr : 2
@@ -675,7 +675,7 @@ when ODIN_ARCH == "amd64" {
 	SYS_landlock_create_ruleset : uintptr : 444
 	SYS_landlock_add_rule : uintptr : 445
 	SYS_landlock_restrict_self : uintptr : 446
-} else when ODIN_ARCH == "i386" {
+} else when ODIN_ARCH == .i386 {
 	SYS_restart_syscall : uintptr : 0
 	SYS_exit : uintptr : 1
 	SYS_fork : uintptr : 2
@@ -1112,7 +1112,7 @@ when ODIN_ARCH == "amd64" {
 	SYS_landlock_add_rule : uintptr : 445
 	SYS_landlock_restrict_self : uintptr : 446
 	SYS_memfd_secret : uintptr : 447
-} else when ODIN_ARCH == "arm" {
+} else when false /*ODIN_ARCH == .arm*/ { // TODO
 	SYS_restart_syscall : uintptr : 0
 	SYS_exit : uintptr : 1
 	SYS_fork : uintptr : 2
diff --git a/core/time/time_unix.odin b/core/time/time_unix.odin
index 0d765b72d..9c5c5cc35 100644
--- a/core/time/time_unix.odin
+++ b/core/time/time_unix.odin
@@ -3,7 +3,7 @@ package time
 
 IS_SUPPORTED :: true // NOTE: Times on Darwin are UTC.
 
-when ODIN_OS == "darwin" {
+when ODIN_OS == .Darwin {
 	foreign import libc "System.framework"
 } else  {
 	foreign import libc "system:c"
diff --git a/src/checker.cpp b/src/checker.cpp
index 63a697072..055d0d356 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -856,11 +856,42 @@ void init_universal(void) {
 	add_global_bool_constant("false", false);
 
 	// TODO(bill): Set through flags in the compiler
-	add_global_string_constant("ODIN_OS",      bc->ODIN_OS);
-	add_global_string_constant("ODIN_ARCH",    bc->ODIN_ARCH);
 	add_global_string_constant("ODIN_VENDOR",  bc->ODIN_VENDOR);
 	add_global_string_constant("ODIN_VERSION", bc->ODIN_VERSION);
 	add_global_string_constant("ODIN_ROOT",    bc->ODIN_ROOT);
+
+	{
+		GlobalEnumValue values[TargetOs_COUNT] = {
+			{"Unknown",      TargetOs_Invalid},
+			{"Windows",      TargetOs_windows},
+			{"Darwin",       TargetOs_darwin},
+			{"Linux",        TargetOs_linux},
+			{"Essence",      TargetOs_essence},
+			{"FreeBSD",      TargetOs_freebsd},
+			{"WASI",         TargetOs_wasi},
+			{"JS",           TargetOs_js},
+			{"Freestanding", TargetOs_freestanding},
+		};
+
+		auto fields = add_global_enum_type(str_lit("Odin_OS_Type"), values, gb_count_of(values));
+		add_global_enum_constant(fields, "ODIN_OS", bc->metrics.os);
+		add_global_string_constant("ODIN_OS_STRING", target_os_names[bc->metrics.os]);
+	}
+
+	{
+		GlobalEnumValue values[TargetArch_COUNT] = {
+			{"Unknown", TargetArch_Invalid},
+			{"amd64",   TargetArch_amd64},
+			{"i386",    TargetArch_i386},
+			{"arm64",   TargetArch_arm64},
+			{"wasm32",  TargetArch_wasm32},
+			{"wasm64",  TargetArch_wasm64},
+		};
+
+		auto fields = add_global_enum_type(str_lit("Odin_Arch_Type"), values, gb_count_of(values));
+		add_global_enum_constant(fields, "ODIN_ARCH", bc->metrics.arch);
+		add_global_string_constant("ODIN_ARCH_STRING", target_arch_names[bc->metrics.arch]);
+	}
 	
 	{
 		GlobalEnumValue values[BuildMode_COUNT] = {
@@ -875,7 +906,6 @@ void init_universal(void) {
 		add_global_enum_constant(fields, "ODIN_BUILD_MODE", bc->build_mode);
 	}
 
-	add_global_string_constant("ODIN_ENDIAN_STRING", target_endian_names[target_endians[bc->metrics.arch]]);
 	{
 		GlobalEnumValue values[TargetEndian_COUNT] = {
 			{"Unknown", TargetEndian_Invalid},
@@ -886,6 +916,7 @@ void init_universal(void) {
 
 		auto fields = add_global_enum_type(str_lit("Odin_Endian_Type"), values, gb_count_of(values));
 		add_global_enum_constant(fields, "ODIN_ENDIAN", target_endians[bc->metrics.arch]);
+		add_global_string_constant("ODIN_ENDIAN_STRING", target_endian_names[target_endians[bc->metrics.arch]]);
 	}
 
 
diff --git a/vendor/ENet/enet.odin b/vendor/ENet/enet.odin
index 8d068fbfc..37e65b497 100644
--- a/vendor/ENet/enet.odin
+++ b/vendor/ENet/enet.odin
@@ -1,7 +1,7 @@
 package ENet
 
-when ODIN_OS == "windows" {
-	when ODIN_ARCH == "amd64" {
+when ODIN_OS == .Windows {
+	when ODIN_ARCH == .amd64 {
 		foreign import ENet {
 			"lib/enet64.lib",
 			"system:Ws2_32.lib",
diff --git a/vendor/OpenGL/helpers.odin b/vendor/OpenGL/helpers.odin
index 0a9cffefa..661de318c 100644
--- a/vendor/OpenGL/helpers.odin
+++ b/vendor/OpenGL/helpers.odin
@@ -188,7 +188,7 @@ load_shaders_source :: proc(vs_source, fs_source: string, binary_retrievable :=
 load_shaders :: proc{load_shaders_file}
 
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	update_shader_if_changed :: proc(
 		vertex_name, fragment_name: string, 
 		program: u32, 
diff --git a/vendor/botan/bindings/botan.odin b/vendor/botan/bindings/botan.odin
index d1d88cda0..fdddc99a9 100644
--- a/vendor/botan/bindings/botan.odin
+++ b/vendor/botan/bindings/botan.odin
@@ -136,11 +136,11 @@ totp_t               :: ^totp_struct
 fpe_struct           :: struct{}
 fpe_t                :: ^fpe_struct
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
     foreign import botan_lib "botan.lib"
-} else when ODIN_OS == "linux" {
+} else when ODIN_OS == .Linux {
     foreign import botan_lib "system:botan-2"
-} else when ODIN_OS == "darwin" {
+} else when ODIN_OS == .Darwin {
     foreign import botan_lib "system:botan-2"
 }
 
diff --git a/vendor/glfw/bindings/bindings.odin b/vendor/glfw/bindings/bindings.odin
index 84905f603..f4e39015e 100644
--- a/vendor/glfw/bindings/bindings.odin
+++ b/vendor/glfw/bindings/bindings.odin
@@ -3,9 +3,9 @@ package glfw_bindings
 import "core:c"
 import vk "vendor:vulkan"
 
-when ODIN_OS == "linux"   { foreign import glfw "system:glfw" } // TODO: Add the billion-or-so static libs to link to in linux
-when ODIN_OS == "darwin"  { foreign import glfw "system:glfw" }
-when ODIN_OS == "windows" { 
+when ODIN_OS == .Linux   { foreign import glfw "system:glfw" } // TODO: Add the billion-or-so static libs to link to in linux
+when ODIN_OS == .Darwin  { foreign import glfw "system:glfw" }
+when ODIN_OS == .Windows {
 	foreign import glfw { 
 		"../lib/glfw3_mt.lib",
 		"system:user32.lib", 
diff --git a/vendor/glfw/native.odin b/vendor/glfw/native.odin
index 871c42af9..902b30656 100644
--- a/vendor/glfw/native.odin
+++ b/vendor/glfw/native.odin
@@ -1,6 +1,6 @@
 package glfw
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	import win32 "core:sys/windows"
 	
 	foreign import glfw { "lib/glfw3.lib", "system:user32.lib", "system:gdi32.lib", "system:shell32.lib" }
@@ -12,7 +12,7 @@ when ODIN_OS == "windows" {
 		GetWin32Window  :: proc(window: WindowHandle) -> win32.HWND ---
 		GetWGLContext   :: proc(window: WindowHandle) -> rawptr ---
 	}
-} else when ODIN_OS == "linux" {
+} else when ODIN_OS == .Linux {
 	// TODO: Native Linux
 	// Display* glfwGetX11Display(void);
 	// RRCrtc glfwGetX11Adapter(GLFWmonitor* monitor);
@@ -24,7 +24,7 @@ when ODIN_OS == "windows" {
 	// struct wl_display* glfwGetWaylandDisplay(void);
 	// struct wl_output* glfwGetWaylandMonitor(GLFWmonitor* monitor);
 	// struct wl_surface* glfwGetWaylandWindow(GLFWwindow* window);
-} else when ODIN_OS == "darwin" {
+} else when ODIN_OS == .Darwin {
 	// TODO: Native Darwin
 	// CGDirectDisplayID glfwGetCocoaMonitor(GLFWmonitor* monitor);
 	// id glfwGetCocoaWindow(GLFWwindow* window);
diff --git a/vendor/miniaudio/common.odin b/vendor/miniaudio/common.odin
index 62e32e8b1..75b66101f 100644
--- a/vendor/miniaudio/common.odin
+++ b/vendor/miniaudio/common.odin
@@ -2,8 +2,8 @@ package miniaudio
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "lib/miniaudio.lib" }
-when ODIN_OS == "linux"   { foreign import lib "lib/miniaudio.a" }
+when ODIN_OS == .Windows { foreign import lib "lib/miniaudio.lib" }
+when ODIN_OS == .Linux   { foreign import lib "lib/miniaudio.a" }
 
 handle :: distinct rawptr
 
@@ -270,7 +270,7 @@ thread_priority :: enum c.int {
 /* Spinlocks are 32-bit for compatibility reasons. */
 spinlock :: distinct u32
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	thread    :: distinct rawptr
 	mutex     :: distinct rawptr
 	event     :: distinct rawptr
diff --git a/vendor/miniaudio/data_conversion.odin b/vendor/miniaudio/data_conversion.odin
index 1a5c9d265..8a53cc19e 100644
--- a/vendor/miniaudio/data_conversion.odin
+++ b/vendor/miniaudio/data_conversion.odin
@@ -2,8 +2,8 @@ package miniaudio
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "lib/miniaudio.lib" }
-when ODIN_OS == "linux"   { foreign import lib "lib/miniaudio.a" }
+when ODIN_OS == .Windows { foreign import lib "lib/miniaudio.lib" }
+when ODIN_OS == .Linux   { foreign import lib "lib/miniaudio.a" }
 
 
 /************************************************************************************************************************************************************
diff --git a/vendor/miniaudio/decoding.odin b/vendor/miniaudio/decoding.odin
index cdddd06fe..52b315f10 100644
--- a/vendor/miniaudio/decoding.odin
+++ b/vendor/miniaudio/decoding.odin
@@ -2,8 +2,8 @@ package miniaudio
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "lib/miniaudio.lib" }
-when ODIN_OS == "linux"   { foreign import lib "lib/miniaudio.a" }
+when ODIN_OS == .Windows { foreign import lib "lib/miniaudio.lib" }
+when ODIN_OS == .Linux   { foreign import lib "lib/miniaudio.a" }
 
 
 
diff --git a/vendor/miniaudio/device_io_procs.odin b/vendor/miniaudio/device_io_procs.odin
index c9cfb7c04..8d6609186 100644
--- a/vendor/miniaudio/device_io_procs.odin
+++ b/vendor/miniaudio/device_io_procs.odin
@@ -1,7 +1,7 @@
 package miniaudio
 
-when ODIN_OS == "windows" { foreign import lib "lib/miniaudio.lib" }
-when ODIN_OS == "linux"   { foreign import lib "lib/miniaudio.a" }
+when ODIN_OS == .Windows { foreign import lib "lib/miniaudio.lib" }
+when ODIN_OS == .Linux   { foreign import lib "lib/miniaudio.a" }
 
 import "core:c"
 
diff --git a/vendor/miniaudio/device_io_types.odin b/vendor/miniaudio/device_io_types.odin
index 8f43b8640..7778e85cf 100644
--- a/vendor/miniaudio/device_io_types.odin
+++ b/vendor/miniaudio/device_io_types.odin
@@ -2,21 +2,21 @@ package miniaudio
 
 import "core:c"
 
-SUPPORT_WASAPI     :: ODIN_OS == "windows"
-SUPPORT_DSOUND     :: ODIN_OS == "windows"
-SUPPORT_WINMM      :: ODIN_OS == "windows"
-SUPPORT_COREAUDIO  :: ODIN_OS == "darwin"
-SUPPORT_SNDIO      :: ODIN_OS == "openbsd"
-SUPPORT_AUDIO4     :: ODIN_OS == "openbsd" || ODIN_OS == "netbsd"
-SUPPORT_OSS        :: ODIN_OS == "freebsd"
-SUPPORT_PULSEAUDIO :: ODIN_OS == "linux"
-SUPPORT_ALSA       :: ODIN_OS == "linux"
-SUPPORT_JACK       :: ODIN_OS == "windows"
-SUPPORT_AAUDIO     :: ODIN_OS == "android"
-SUPPORT_OPENSL     :: ODIN_OS == "android"
-SUPPORT_WEBAUDIO   :: ODIN_OS == "emscripten"
+SUPPORT_WASAPI     :: ODIN_OS == .Windows
+SUPPORT_DSOUND     :: ODIN_OS == .Windows
+SUPPORT_WINMM      :: ODIN_OS == .Windows
+SUPPORT_COREAUDIO  :: ODIN_OS == .Darwin
+SUPPORT_SNDIO      :: false // ODIN_OS == .OpenBSD
+SUPPORT_AUDIO4     :: false // ODIN_OS == .OpenBSD || ODIN_OS == .NetBSD
+SUPPORT_OSS        :: ODIN_OS == .FreeBSD
+SUPPORT_PULSEAUDIO :: ODIN_OS == .Linux
+SUPPORT_ALSA       :: ODIN_OS == .Linux
+SUPPORT_JACK       :: ODIN_OS == .Windows
+SUPPORT_AAUDIO     :: false // ODIN_OS == .Android
+SUPPORT_OPENSL     :: false // ODIN_OS == .Android
+SUPPORT_WEBAUDIO   :: false // ODIN_OS == .Emscripten
 SUPPORT_CUSTOM     :: true
-SUPPORT_NULL       :: ODIN_OS != "emscripten"
+SUPPORT_NULL       :: true // ODIN_OS != .Emscripten
 
 STATE_UNINITIALIZED :: 0
 STATE_STOPPED       :: 1   /* The device's default state after initialization. */
@@ -895,7 +895,7 @@ context_type :: struct {
 			RegOpenKeyExA:               proc "system" (),
 			RegCloseKey:                 proc "system" (),
 			RegQueryValueExA:            proc "system" (),
-		} when ODIN_OS == "windows" else struct {}),
+		} when ODIN_OS == .Windows else struct {}),
 		
 		posix: (struct {
 			pthreadSO:                   handle,
@@ -914,7 +914,7 @@ context_type :: struct {
 			pthread_attr_setschedpolicy: proc "system" (),
 			pthread_attr_getschedparam:  proc "system" (),
 			pthread_attr_setschedparam:  proc "system" (),
-		} when ODIN_OS != "windows" else struct {}),
+		} when ODIN_OS != .Windows else struct {}),
 		
 		_unused: c.int,
 	},
diff --git a/vendor/miniaudio/encoding.odin b/vendor/miniaudio/encoding.odin
index 866c19010..83f9d5252 100644
--- a/vendor/miniaudio/encoding.odin
+++ b/vendor/miniaudio/encoding.odin
@@ -2,8 +2,8 @@ package miniaudio
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "lib/miniaudio.lib" }
-when ODIN_OS == "linux"   { foreign import lib "lib/miniaudio.a" }
+when ODIN_OS == .Windows { foreign import lib "lib/miniaudio.lib" }
+when ODIN_OS == .Linux   { foreign import lib "lib/miniaudio.a" }
 
 /************************************************************************************************************************************************************
 
diff --git a/vendor/miniaudio/filtering.odin b/vendor/miniaudio/filtering.odin
index fec21f33d..4956da173 100644
--- a/vendor/miniaudio/filtering.odin
+++ b/vendor/miniaudio/filtering.odin
@@ -1,7 +1,7 @@
 package miniaudio
 
-when ODIN_OS == "windows" { foreign import lib "lib/miniaudio.lib" }
-when ODIN_OS == "linux"   { foreign import lib "lib/miniaudio.a" }
+when ODIN_OS == .Windows { foreign import lib "lib/miniaudio.lib" }
+when ODIN_OS == .Linux   { foreign import lib "lib/miniaudio.a" }
 
 /**************************************************************************************************************************************************************
 
diff --git a/vendor/miniaudio/generation.odin b/vendor/miniaudio/generation.odin
index c2009967c..c241f00b1 100644
--- a/vendor/miniaudio/generation.odin
+++ b/vendor/miniaudio/generation.odin
@@ -2,8 +2,8 @@ package miniaudio
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "lib/miniaudio.lib" }
-when ODIN_OS == "linux"   { foreign import lib "lib/miniaudio.a" }
+when ODIN_OS == .Windows { foreign import lib "lib/miniaudio.lib" }
+when ODIN_OS == .Linux   { foreign import lib "lib/miniaudio.a" }
 
 waveform_type :: enum c.int {
 	sine,
diff --git a/vendor/miniaudio/logging.odin b/vendor/miniaudio/logging.odin
index 54792bff9..35aa54bc9 100644
--- a/vendor/miniaudio/logging.odin
+++ b/vendor/miniaudio/logging.odin
@@ -2,8 +2,8 @@ package miniaudio
 
 import c "core:c/libc"
 
-when ODIN_OS == "windows" { foreign import lib "lib/miniaudio.lib" }
-when ODIN_OS == "linux"   { foreign import lib "lib/miniaudio.a" }
+when ODIN_OS == .Windows { foreign import lib "lib/miniaudio.lib" }
+when ODIN_OS == .Linux   { foreign import lib "lib/miniaudio.a" }
 
 MAX_LOG_CALLBACKS :: 4
 
diff --git a/vendor/miniaudio/utilities.odin b/vendor/miniaudio/utilities.odin
index 1a94550e4..19307a77d 100644
--- a/vendor/miniaudio/utilities.odin
+++ b/vendor/miniaudio/utilities.odin
@@ -1,7 +1,7 @@
 package miniaudio
 
-when ODIN_OS == "windows" { foreign import lib "lib/miniaudio.lib" }
-when ODIN_OS == "linux"   { foreign import lib "lib/miniaudio.a" }
+when ODIN_OS == .Windows { foreign import lib "lib/miniaudio.lib" }
+when ODIN_OS == .Linux   { foreign import lib "lib/miniaudio.a" }
 
 @(default_calling_convention="c", link_prefix="ma_")
 foreign lib {
diff --git a/vendor/miniaudio/vfs.odin b/vendor/miniaudio/vfs.odin
index fa18afb6b..547fbd265 100644
--- a/vendor/miniaudio/vfs.odin
+++ b/vendor/miniaudio/vfs.odin
@@ -2,8 +2,8 @@ package miniaudio
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "lib/miniaudio.lib" }
-when ODIN_OS == "linux"   { foreign import lib "lib/miniaudio.a" }
+when ODIN_OS == .Windows { foreign import lib "lib/miniaudio.lib" }
+when ODIN_OS == .Linux   { foreign import lib "lib/miniaudio.a" }
 
 /************************************************************************************************************************************************************
 
diff --git a/vendor/portmidi/portmidi.odin b/vendor/portmidi/portmidi.odin
index 08f78150c..40fd18b8b 100644
--- a/vendor/portmidi/portmidi.odin
+++ b/vendor/portmidi/portmidi.odin
@@ -3,7 +3,7 @@ package portmidi
 import "core:c"
 import "core:strings"
 
-when ODIN_OS == "windows" { 
+when ODIN_OS == .Windows {
 	foreign import lib {
 		"portmidi_s.lib",
 		"system:Winmm.lib",
diff --git a/vendor/portmidi/util.odin b/vendor/portmidi/util.odin
index d02142bd0..ca2e1f4ca 100644
--- a/vendor/portmidi/util.odin
+++ b/vendor/portmidi/util.odin
@@ -7,7 +7,7 @@ package portmidi
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "portmidi_s.lib" }
+when ODIN_OS == .Windows { foreign import lib "portmidi_s.lib" }
 
 
 Queue :: distinct rawptr
diff --git a/vendor/raylib/raylib.odin b/vendor/raylib/raylib.odin
index fb4d7dd92..0c8248683 100644
--- a/vendor/raylib/raylib.odin
+++ b/vendor/raylib/raylib.odin
@@ -91,7 +91,7 @@ MAX_TEXT_BUFFER_LENGTH :: #config(RAYLIB_MAX_TEXT_BUFFER_LENGTH, 1024)
 
 #assert(size_of(rune) == size_of(c.int))
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	foreign import lib {
 		"raylib.lib",
 		"system:Winmm.lib",
@@ -100,14 +100,14 @@ when ODIN_OS == "windows" {
 		"system:Shell32.lib",
 	}
 }
-when ODIN_OS == "linux"  { 
+when ODIN_OS == .Linux  {
 	foreign import lib { 
 		"linux/libraylib.a",
 		"system:dl",
 		"system:pthread",
 	}
 }
-when ODIN_OS == "darwin" { foreign import lib "macos/libraylib.a" }
+when ODIN_OS == .Darwin { foreign import lib "macos/libraylib.a" }
 
 VERSION :: "4.0"
 
diff --git a/vendor/raylib/rlgl.odin b/vendor/raylib/rlgl.odin
index 8f91486c1..936a34765 100644
--- a/vendor/raylib/rlgl.odin
+++ b/vendor/raylib/rlgl.odin
@@ -2,7 +2,7 @@ package raylib
 
 import "core:c"
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	foreign import lib {
 		"raylib.lib",
 		"system:Winmm.lib",
@@ -11,8 +11,8 @@ when ODIN_OS == "windows" {
 		"system:Shell32.lib",
 	}
 }
-when ODIN_OS == "linux"  { foreign import lib "linux/libraylib.a" }
-when ODIN_OS == "darwin" { foreign import lib "macos/libraylib.a" }
+when ODIN_OS == .Linux  { foreign import lib "linux/libraylib.a" }
+when ODIN_OS == .Darwin { foreign import lib "macos/libraylib.a" }
 
 GRAPHICS_API_OPENGL_11  :: false
 GRAPHICS_API_OPENGL_21  :: true
diff --git a/vendor/sdl2/image/sdl_image.odin b/vendor/sdl2/image/sdl_image.odin
index 1dbe048ed..30a7db6a8 100644
--- a/vendor/sdl2/image/sdl_image.odin
+++ b/vendor/sdl2/image/sdl_image.odin
@@ -3,10 +3,10 @@ package sdl2_image
 import "core:c"
 import SDL ".."
 
-when ODIN_OS == "windows" { foreign import lib "SDL2_image.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2_image" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2_image" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2_image" }
+when ODIN_OS == .Windows { foreign import lib "SDL2_image.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2_image" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2_image" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2_image" }
 
 bool :: SDL.bool
 
diff --git a/vendor/sdl2/mixer/sdl_mixer.odin b/vendor/sdl2/mixer/sdl_mixer.odin
index 90334d91a..7fa3f216f 100644
--- a/vendor/sdl2/mixer/sdl_mixer.odin
+++ b/vendor/sdl2/mixer/sdl_mixer.odin
@@ -3,10 +3,10 @@ package sdl2_mixer
 import "core:c"
 import SDL ".."
 
-when ODIN_OS == "windows" { foreign import lib "SDL2_mixer.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2_mixer" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2_mixer" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2_mixer" }
+when ODIN_OS == .Windows { foreign import lib "SDL2_mixer.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2_mixer" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2_mixer" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2_mixer" }
 
 
 MAJOR_VERSION :: 2
diff --git a/vendor/sdl2/net/sdl_net.odin b/vendor/sdl2/net/sdl_net.odin
index 49671764a..b3e2c2e62 100644
--- a/vendor/sdl2/net/sdl_net.odin
+++ b/vendor/sdl2/net/sdl_net.odin
@@ -3,10 +3,10 @@ package sdl2_net
 import "core:c"
 import SDL ".."
 
-when ODIN_OS == "windows" { foreign import lib "SDL2_net.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2_net" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2_net" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2_net" }
+when ODIN_OS == .Windows { foreign import lib "SDL2_net.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2_net" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2_net" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2_net" }
 
 bool :: SDL.bool
 
diff --git a/vendor/sdl2/sdl2.odin b/vendor/sdl2/sdl2.odin
index 4781483f7..e36c002dd 100644
--- a/vendor/sdl2/sdl2.odin
+++ b/vendor/sdl2/sdl2.odin
@@ -25,10 +25,10 @@ package sdl2
 import "core:c"
 import "core:intrinsics"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 version :: struct {
 	major: u8,        /**< major version */
diff --git a/vendor/sdl2/sdl_audio.odin b/vendor/sdl2/sdl_audio.odin
index 2c5b7fedb..a03031165 100644
--- a/vendor/sdl2/sdl_audio.odin
+++ b/vendor/sdl2/sdl_audio.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 /**
  *  \brief Audio format flags.
diff --git a/vendor/sdl2/sdl_blendmode.odin b/vendor/sdl2/sdl_blendmode.odin
index 3fb7c2e83..525cf0f38 100644
--- a/vendor/sdl2/sdl_blendmode.odin
+++ b/vendor/sdl2/sdl_blendmode.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 /**
  *  \brief The blend mode used in SDL_RenderCopy() and drawing operations.
diff --git a/vendor/sdl2/sdl_cpuinfo.odin b/vendor/sdl2/sdl_cpuinfo.odin
index 5fe5cf16c..7d2e681fe 100644
--- a/vendor/sdl2/sdl_cpuinfo.odin
+++ b/vendor/sdl2/sdl_cpuinfo.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 /* This is a guess for the cacheline size used for padding.
  * Most x86 processors have a 64 byte cache line.
diff --git a/vendor/sdl2/sdl_events.odin b/vendor/sdl2/sdl_events.odin
index 535269656..3f58b51c3 100644
--- a/vendor/sdl2/sdl_events.odin
+++ b/vendor/sdl2/sdl_events.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 RELEASED :: 0
 PRESSED  :: 1
diff --git a/vendor/sdl2/sdl_gamecontroller.odin b/vendor/sdl2/sdl_gamecontroller.odin
index 747cd1af6..9fef6b1ab 100644
--- a/vendor/sdl2/sdl_gamecontroller.odin
+++ b/vendor/sdl2/sdl_gamecontroller.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 GameController :: struct {}
 
diff --git a/vendor/sdl2/sdl_gesture_haptic.odin b/vendor/sdl2/sdl_gesture_haptic.odin
index 0d257a525..1c8616e99 100644
--- a/vendor/sdl2/sdl_gesture_haptic.odin
+++ b/vendor/sdl2/sdl_gesture_haptic.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 // Gesture
 
diff --git a/vendor/sdl2/sdl_hints.odin b/vendor/sdl2/sdl_hints.odin
index b5793bb02..a84e5a090 100644
--- a/vendor/sdl2/sdl_hints.odin
+++ b/vendor/sdl2/sdl_hints.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 HINT_ACCELEROMETER_AS_JOYSTICK                :: "SDL_ACCELEROMETER_AS_JOYSTICK"
 HINT_ALLOW_ALT_TAB_WHILE_GRABBED              :: "SDL_ALLOW_ALT_TAB_WHILE_GRABBED"
diff --git a/vendor/sdl2/sdl_joystick.odin b/vendor/sdl2/sdl_joystick.odin
index d2bb624b7..1178eae24 100644
--- a/vendor/sdl2/sdl_joystick.odin
+++ b/vendor/sdl2/sdl_joystick.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 Joystick :: struct {}
 
diff --git a/vendor/sdl2/sdl_keyboard.odin b/vendor/sdl2/sdl_keyboard.odin
index 86112863a..a68c644ab 100644
--- a/vendor/sdl2/sdl_keyboard.odin
+++ b/vendor/sdl2/sdl_keyboard.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 Keysym :: struct {
 	scancode: Scancode, /**< SDL physical key code - see ::SDL_Scancode for details */
diff --git a/vendor/sdl2/sdl_log.odin b/vendor/sdl2/sdl_log.odin
index b9f8a8d7d..d42d82b77 100644
--- a/vendor/sdl2/sdl_log.odin
+++ b/vendor/sdl2/sdl_log.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 MAX_LOG_MESSAGE :: 4096
 
diff --git a/vendor/sdl2/sdl_messagebox.odin b/vendor/sdl2/sdl_messagebox.odin
index d8a07c1e2..c66cc4911 100644
--- a/vendor/sdl2/sdl_messagebox.odin
+++ b/vendor/sdl2/sdl_messagebox.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 MessageBoxFlag :: enum u32 {
 	_ = 0,
diff --git a/vendor/sdl2/sdl_metal.odin b/vendor/sdl2/sdl_metal.odin
index 87a0313ef..953c6d45f 100644
--- a/vendor/sdl2/sdl_metal.odin
+++ b/vendor/sdl2/sdl_metal.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 MetalView :: distinct rawptr
 
diff --git a/vendor/sdl2/sdl_mouse.odin b/vendor/sdl2/sdl_mouse.odin
index d667addc8..5ca8d9b5e 100644
--- a/vendor/sdl2/sdl_mouse.odin
+++ b/vendor/sdl2/sdl_mouse.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 Cursor :: struct {}
 
diff --git a/vendor/sdl2/sdl_mutex.odin b/vendor/sdl2/sdl_mutex.odin
index 80d62f7c8..6b9c96319 100644
--- a/vendor/sdl2/sdl_mutex.odin
+++ b/vendor/sdl2/sdl_mutex.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 MUTEX_TIMEDOUT :: 1
 MUTEX_MAXWAIT  :: ~u32(0)
diff --git a/vendor/sdl2/sdl_pixels.odin b/vendor/sdl2/sdl_pixels.odin
index 22f6db440..3cd2da5f4 100644
--- a/vendor/sdl2/sdl_pixels.odin
+++ b/vendor/sdl2/sdl_pixels.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 ALPHA_OPAQUE      :: 255
 ALPHA_TRANSPARENT ::   0
diff --git a/vendor/sdl2/sdl_rect.odin b/vendor/sdl2/sdl_rect.odin
index 929897c26..b0d6242be 100644
--- a/vendor/sdl2/sdl_rect.odin
+++ b/vendor/sdl2/sdl_rect.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 Point :: struct {
 	x: c.int,
diff --git a/vendor/sdl2/sdl_render.odin b/vendor/sdl2/sdl_render.odin
index c92fd3eda..435c40570 100644
--- a/vendor/sdl2/sdl_render.odin
+++ b/vendor/sdl2/sdl_render.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 RendererFlag :: enum u32 {
 	SOFTWARE      = 0, /**< The renderer is a software fallback */
diff --git a/vendor/sdl2/sdl_rwops.odin b/vendor/sdl2/sdl_rwops.odin
index 590815c90..3bee66290 100644
--- a/vendor/sdl2/sdl_rwops.odin
+++ b/vendor/sdl2/sdl_rwops.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 /* RWops Types */
 RWOPS_UNKNOWN   :: 0 /**< Unknown stream type */
diff --git a/vendor/sdl2/sdl_stdinc.odin b/vendor/sdl2/sdl_stdinc.odin
index bf098a591..9bd5df4da 100644
--- a/vendor/sdl2/sdl_stdinc.odin
+++ b/vendor/sdl2/sdl_stdinc.odin
@@ -5,10 +5,10 @@ import "core:intrinsics"
 import "core:runtime"
 _, _ :: intrinsics, runtime
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 bool :: distinct b32
 #assert(size_of(bool) == size_of(c.int))
diff --git a/vendor/sdl2/sdl_surface.odin b/vendor/sdl2/sdl_surface.odin
index c0b20be63..e5a5da7ef 100644
--- a/vendor/sdl2/sdl_surface.odin
+++ b/vendor/sdl2/sdl_surface.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 SWSURFACE       :: 0           /**< Just here for compatibility */
 PREALLOC        :: 0x00000001  /**< Surface uses preallocated memory */
diff --git a/vendor/sdl2/sdl_system.odin b/vendor/sdl2/sdl_system.odin
index 31f1b590b..89ae4c707 100644
--- a/vendor/sdl2/sdl_system.odin
+++ b/vendor/sdl2/sdl_system.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 // General
 @(default_calling_convention="c", link_prefix="SDL_")
diff --git a/vendor/sdl2/sdl_syswm.odin b/vendor/sdl2/sdl_syswm.odin
index e374e72b7..37da1d298 100644
--- a/vendor/sdl2/sdl_syswm.odin
+++ b/vendor/sdl2/sdl_syswm.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 SYSWM_TYPE :: enum c.int {
 	UNKNOWN,
diff --git a/vendor/sdl2/sdl_thread.odin b/vendor/sdl2/sdl_thread.odin
index cbaf3ac00..98354438b 100644
--- a/vendor/sdl2/sdl_thread.odin
+++ b/vendor/sdl2/sdl_thread.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 Thread :: struct {}
 
diff --git a/vendor/sdl2/sdl_timer.odin b/vendor/sdl2/sdl_timer.odin
index 5b26c7346..357fdd437 100644
--- a/vendor/sdl2/sdl_timer.odin
+++ b/vendor/sdl2/sdl_timer.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 TimerCallback :: proc "c" (interval: u32, param: rawptr) -> u32
 TimerID :: distinct c.int
diff --git a/vendor/sdl2/sdl_touch.odin b/vendor/sdl2/sdl_touch.odin
index c393b74ef..d90939cb9 100644
--- a/vendor/sdl2/sdl_touch.odin
+++ b/vendor/sdl2/sdl_touch.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 TouchID  :: distinct i64
 FingerID :: distinct i64
diff --git a/vendor/sdl2/sdl_video.odin b/vendor/sdl2/sdl_video.odin
index 97a134739..01aaee1e7 100644
--- a/vendor/sdl2/sdl_video.odin
+++ b/vendor/sdl2/sdl_video.odin
@@ -2,10 +2,10 @@ package sdl2
 
 import "core:c"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 DisplayMode :: struct {
 	format:       u32,    /**< pixel format */
diff --git a/vendor/sdl2/sdl_vulkan.odin b/vendor/sdl2/sdl_vulkan.odin
index 97a41bacf..66b054524 100644
--- a/vendor/sdl2/sdl_vulkan.odin
+++ b/vendor/sdl2/sdl_vulkan.odin
@@ -3,10 +3,10 @@ package sdl2
 import "core:c"
 import vk "vendor:vulkan"
 
-when ODIN_OS == "windows" { foreign import lib "SDL2.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2" }
+when ODIN_OS == .Windows { foreign import lib "SDL2.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2" }
 
 VkInstance   :: vk.Instance
 VkSurfaceKHR :: vk.SurfaceKHR
diff --git a/vendor/sdl2/ttf/sdl_ttf.odin b/vendor/sdl2/ttf/sdl_ttf.odin
index 6b41f07c2..20db09729 100644
--- a/vendor/sdl2/ttf/sdl_ttf.odin
+++ b/vendor/sdl2/ttf/sdl_ttf.odin
@@ -3,10 +3,10 @@ package sdl2_ttf
 import "core:c"
 import SDL ".."
 
-when ODIN_OS == "windows" { foreign import lib "SDL2_ttf.lib"    }
-when ODIN_OS == "linux"   { foreign import lib "system:SDL2_ttf" }
-when ODIN_OS == "darwin"  { foreign import lib "system:SDL2_ttf" }
-when ODIN_OS == "freebsd" { foreign import lib "system:SDL2_ttf" }
+when ODIN_OS == .Windows { foreign import lib "SDL2_ttf.lib"    }
+when ODIN_OS == .Linux   { foreign import lib "system:SDL2_ttf" }
+when ODIN_OS == .Darwin  { foreign import lib "system:SDL2_ttf" }
+when ODIN_OS == .FreeBSD { foreign import lib "system:SDL2_ttf" }
 
 bool :: SDL.bool
 
diff --git a/vendor/stb/image/stb_image.odin b/vendor/stb/image/stb_image.odin
index 9e72760ab..8a3582792 100644
--- a/vendor/stb/image/stb_image.odin
+++ b/vendor/stb/image/stb_image.odin
@@ -4,8 +4,8 @@ import c "core:c/libc"
 
 #assert(size_of(c.int) == size_of(b32))
 
-when ODIN_OS == "windows" { foreign import stbi "../lib/stb_image.lib" }
-when ODIN_OS == "linux"   { foreign import stbi "../lib/stb_image.a"   }
+when ODIN_OS == .Windows { foreign import stbi "../lib/stb_image.lib" }
+when ODIN_OS == .Linux   { foreign import stbi "../lib/stb_image.a"   }
 
 #assert(size_of(b32) == size_of(c.int))
 
diff --git a/vendor/stb/image/stb_image_resize.odin b/vendor/stb/image/stb_image_resize.odin
index bee29a15e..65bf3e4a9 100644
--- a/vendor/stb/image/stb_image_resize.odin
+++ b/vendor/stb/image/stb_image_resize.odin
@@ -2,8 +2,8 @@ package stb_image
 
 import c "core:c/libc"
 
-when ODIN_OS == "windows" { foreign import lib "../lib/stb_image_resize.lib" }
-when ODIN_OS == "linux"   { foreign import lib "../lib/stb_image_resize.a"   }
+when ODIN_OS == .Windows { foreign import lib "../lib/stb_image_resize.lib" }
+when ODIN_OS == .Linux   { foreign import lib "../lib/stb_image_resize.a"   }
 
 //////////////////////////////////////////////////////////////////////////////
 //
diff --git a/vendor/stb/image/stb_image_write.odin b/vendor/stb/image/stb_image_write.odin
index 1f0cfce85..67f4299fa 100644
--- a/vendor/stb/image/stb_image_write.odin
+++ b/vendor/stb/image/stb_image_write.odin
@@ -2,8 +2,8 @@ package stb_image
 
 import c "core:c/libc"
 
-when ODIN_OS == "windows" { foreign import stbiw "../lib/stb_image_write.lib" }
-when ODIN_OS == "linux"   { foreign import stbiw "../lib/stb_image_write.a"   }
+when ODIN_OS == .Windows { foreign import stbiw "../lib/stb_image_write.lib" }
+when ODIN_OS == .Linux   { foreign import stbiw "../lib/stb_image_write.a"   }
 
 
 write_func :: proc "c" (ctx: rawptr, data: rawptr, size: c.int)
diff --git a/vendor/stb/rect_pack/stb_rect_pack.odin b/vendor/stb/rect_pack/stb_rect_pack.odin
index 4142a73ec..f84f1cedc 100644
--- a/vendor/stb/rect_pack/stb_rect_pack.odin
+++ b/vendor/stb/rect_pack/stb_rect_pack.odin
@@ -4,8 +4,8 @@ import c "core:c/libc"
 
 #assert(size_of(b32) == size_of(c.int))
 
-when ODIN_OS == "windows" { foreign import lib "../lib/stb_rect_pack.lib" }
-when ODIN_OS == "linux"   { foreign import lib "../lib/stb_rect_pack.a"   }
+when ODIN_OS == .Windows { foreign import lib "../lib/stb_rect_pack.lib" }
+when ODIN_OS == .Linux   { foreign import lib "../lib/stb_rect_pack.a"   }
 
 Coord :: distinct c.int
 _MAXVAL :: max(Coord)
diff --git a/vendor/stb/truetype/stb_truetype.odin b/vendor/stb/truetype/stb_truetype.odin
index 3abb187c2..cf4af15e9 100644
--- a/vendor/stb/truetype/stb_truetype.odin
+++ b/vendor/stb/truetype/stb_truetype.odin
@@ -3,8 +3,8 @@ package stb_truetype
 import c "core:c"
 import stbrp "vendor:stb/rect_pack"
 
-when ODIN_OS == "windows" { foreign import stbtt "../lib/stb_truetype.lib" }
-when ODIN_OS == "linux"   { foreign import stbtt "../lib/stb_truetype.a"   }
+when ODIN_OS == .Windows { foreign import stbtt "../lib/stb_truetype.lib" }
+when ODIN_OS == .Linux   { foreign import stbtt "../lib/stb_truetype.a"   }
 
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/vendor/stb/vorbis/stb_vorbis.odin b/vendor/stb/vorbis/stb_vorbis.odin
index 7ec248df5..f35b58e04 100644
--- a/vendor/stb/vorbis/stb_vorbis.odin
+++ b/vendor/stb/vorbis/stb_vorbis.odin
@@ -3,8 +3,8 @@ package stb_vorbis
 import c "core:c/libc"
 
 
-when ODIN_OS == "windows" { foreign import lib "../lib/stb_vorbis.lib" }
-when ODIN_OS == "linux"   { foreign import lib "../lib/stb_vorbis.a"   }
+when ODIN_OS == .Windows { foreign import lib "../lib/stb_vorbis.lib" }
+when ODIN_OS == .Linux   { foreign import lib "../lib/stb_vorbis.a"   }
 
 
 
diff --git a/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py b/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py
index 1525f4e15..e7fb234c8 100644
--- a/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py
+++ b/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py
@@ -591,7 +591,7 @@ MAX_GLOBAL_PRIORITY_SIZE_EXT  :: 16
         f.write("""
 import "core:c"
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 \timport win32 "core:sys/windows"
 
 \tHINSTANCE           :: win32.HINSTANCE
diff --git a/vendor/vulkan/structs.odin b/vendor/vulkan/structs.odin
index 4d90a53fa..3c655a4fa 100644
--- a/vendor/vulkan/structs.odin
+++ b/vendor/vulkan/structs.odin
@@ -5,7 +5,7 @@ package vulkan
 
 import "core:c"
 
-when ODIN_OS == "windows" {
+when ODIN_OS == .Windows {
 	import win32 "core:sys/windows"
 
 	HINSTANCE           :: win32.HINSTANCE
-- 
cgit v1.2.3


From 77b91352aeb72d9b22a05e3094607a8a5ab4e091 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Thu, 20 Jan 2022 19:58:35 +0000
Subject: Add `Odin_OS_Type` and `Odin_Arch_Type` to `core:runtime`

---
 core/runtime/core.odin | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

(limited to 'core/runtime')

diff --git a/core/runtime/core.odin b/core/runtime/core.odin
index cd76b0bb5..6c2ab1405 100644
--- a/core/runtime/core.odin
+++ b/core/runtime/core.odin
@@ -386,6 +386,35 @@ Raw_Cstring :: struct {
 }
 
 
+/*
+	// Defined internally by the compiler
+	Odin_OS_Type :: enum int {
+		Unknown,
+		Windows,
+		Darwin,
+		Linux,
+		Essence,
+		FreeBSD,
+		WASI,
+		JS,
+		Freestanding,
+	}
+*/
+Odin_OS_Type :: type_of(ODIN_OS)
+
+/*
+	// Defined internally by the compiler
+	Odin_Arch_Type :: enum int {
+		Unknown,
+		amd64,
+		i386,
+		arm64,
+		wasm32,
+		wasm64,
+	}
+*/
+Odin_Arch_Type :: type_of(ODIN_ARCH)
+
 /*
 	// Defined internally by the compiler
 	Odin_Build_Mode_Type :: enum int {
-- 
cgit v1.2.3


From d269dbcd40d5b81f060a17ed4ca89d97dafcc49c Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sun, 23 Jan 2022 22:01:54 +0000
Subject: Add comment for the internals of `assert`

---
 core/runtime/core_builtin.odin | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'core/runtime')

diff --git a/core/runtime/core_builtin.odin b/core/runtime/core_builtin.odin
index 44da894c1..3bafc0b1d 100644
--- a/core/runtime/core_builtin.odin
+++ b/core/runtime/core_builtin.odin
@@ -614,6 +614,10 @@ raw_data :: proc{raw_array_data, raw_slice_data, raw_dynamic_array_data, raw_str
 @(disabled=ODIN_DISABLE_ASSERT)
 assert :: proc(condition: bool, message := "", loc := #caller_location) {
 	if !condition {
+		// NOTE(bill): This is wrapped in a procedure call
+		// to improve performance to make the CPU not
+		// execute speculatively, making it about an order of
+		// magnitude faster
 		proc(message: string, loc: Source_Code_Location) {
 			p := context.assertion_failure_proc
 			if p == nil {
-- 
cgit v1.2.3


From 070b4507686570335cb3624ef1ede6f442bd4866 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 26 Jan 2022 17:34:39 +0000
Subject: Add `ODIN_ERROR_POS_STYLE` constant and change
 `runtime.print_caller_location` based on that constant

---
 core/runtime/print.odin | 20 +++++++++++++++-----
 src/build_settings.cpp  |  2 ++
 src/checker.cpp         | 10 ++++++++++
 3 files changed, 27 insertions(+), 5 deletions(-)

(limited to 'core/runtime')

diff --git a/core/runtime/print.odin b/core/runtime/print.odin
index 8a14eba08..8c0b65864 100644
--- a/core/runtime/print.odin
+++ b/core/runtime/print.odin
@@ -143,11 +143,21 @@ print_int     :: proc "contextless" (x: int)     { print_i64(i64(x)) }
 
 print_caller_location :: proc "contextless" (using loc: Source_Code_Location) {
 	print_string(file_path)
-	print_byte('(')
-	print_u64(u64(line))
-	print_byte(':')
-	print_u64(u64(column))
-	print_byte(')')
+	when ODIN_ERROR_POS_STYLE == .Default {
+		print_byte('(')
+		print_u64(u64(line))
+		print_byte(':')
+		print_u64(u64(column))
+		print_byte(')')
+	} else when ODIN_ERROR_POS_STYLE == .Unix {
+		print_byte(':')
+		print_u64(u64(line))
+		print_byte(':')
+		print_u64(u64(column))
+		print_byte(':')
+	} else {
+		#panic("unhandled ODIN_ERROR_POS_STYLE")
+	}
 }
 print_typeid :: proc "contextless" (id: typeid) {
 	if id == nil {
diff --git a/src/build_settings.cpp b/src/build_settings.cpp
index 96339be29..610e4f847 100644
--- a/src/build_settings.cpp
+++ b/src/build_settings.cpp
@@ -168,6 +168,8 @@ enum TimingsExportFormat : i32 {
 enum ErrorPosStyle {
 	ErrorPosStyle_Default, // path(line:column) msg
 	ErrorPosStyle_Unix,    // path:line:column: msg
+
+	ErrorPosStyle_COUNT
 };
 
 // This stores the information for the specify architecture of this build
diff --git a/src/checker.cpp b/src/checker.cpp
index b81d9987b..e0c756bb8 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -893,6 +893,16 @@ void init_universal(void) {
 		add_global_enum_constant(fields, "ODIN_ENDIAN", target_endians[bc->metrics.arch]);
 	}
 
+	{
+		GlobalEnumValue values[ErrorPosStyle_COUNT] = {
+			{"Default", ErrorPosStyle_Default},
+			{"Unix",    ErrorPosStyle_Unix},
+		};
+
+		auto fields = add_global_enum_type(str_lit("Odin_Error_Pos_Style_Type"), values, gb_count_of(values));
+		add_global_enum_constant(fields, "ODIN_ERROR_POS_STYLE", build_context.ODIN_ERROR_POS_STYLE);
+	}
+
 
 	add_global_bool_constant("ODIN_DEBUG",                    bc->ODIN_DEBUG);
 	add_global_bool_constant("ODIN_DISABLE_ASSERT",           bc->ODIN_DISABLE_ASSERT);
-- 
cgit v1.2.3


From cf9f3d5e2d33a9004a322db980de307de13dc3a0 Mon Sep 17 00:00:00 2001
From: Andrea Piseri <andrea.piseri@gmail.com>
Date: Thu, 3 Feb 2022 15:50:39 +0100
Subject: fix logic in bswap_128

---
 core/runtime/internal.odin | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

(limited to 'core/runtime')

diff --git a/core/runtime/internal.odin b/core/runtime/internal.odin
index 7b283a132..c07bcc60d 100644
--- a/core/runtime/internal.odin
+++ b/core/runtime/internal.odin
@@ -37,10 +37,8 @@ bswap_64 :: proc "contextless" (x: u64) -> u64 {
 
 bswap_128 :: proc "contextless" (x: u128) -> u128 {
 	z := transmute([4]u32)x
-	z[0] = bswap_32(z[3])
-	z[1] = bswap_32(z[2])
-	z[2] = bswap_32(z[1])
-	z[3] = bswap_32(z[0])
+	z[0], z[3] = bswap_32(z[3]), bswap_32(z[0])
+	z[1], z[2] = bswap_32(z[2]), bswap_32(z[1])
 	return transmute(u128)z
 }
 
-- 
cgit v1.2.3


From 97be86710306702a672309b23fbe8d38f1e6eeec Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sat, 5 Feb 2022 13:01:15 +0000
Subject: Rename `#partial[Enum]Type` to `#sparse[Enum]Type` for non-contiguous
 enum fields

---
 core/reflect/types.odin   |  3 +++
 core/runtime/core.odin    |  1 +
 core/runtime/print.odin   |  3 +++
 src/check_type.cpp        | 13 +++++++------
 src/llvm_backend_type.cpp |  4 +++-
 src/parser.cpp            |  2 +-
 src/types.cpp             |  4 ++++
 7 files changed, 22 insertions(+), 8 deletions(-)

(limited to 'core/runtime')

diff --git a/core/reflect/types.odin b/core/reflect/types.odin
index 74778013a..a9a4a8d48 100644
--- a/core/reflect/types.odin
+++ b/core/reflect/types.odin
@@ -472,6 +472,9 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info, n_written: ^int = nil) -
 		write_type(w, info.elem,             &n) or_return
 
 	case Type_Info_Enumerated_Array:
+		if info.is_sparse {
+			io.write_string(w, "#sparse", &n) or_return
+		}
 		io.write_string(w, "[",   &n) or_return
 		write_type(w, info.index, &n) or_return
 		io.write_string(w, "]",   &n) or_return
diff --git a/core/runtime/core.odin b/core/runtime/core.odin
index 424650828..35144473b 100644
--- a/core/runtime/core.odin
+++ b/core/runtime/core.odin
@@ -95,6 +95,7 @@ Type_Info_Enumerated_Array :: struct {
 	count:     int,
 	min_value: Type_Info_Enum_Value,
 	max_value: Type_Info_Enum_Value,
+	is_sparse: bool,
 }
 Type_Info_Dynamic_Array :: struct {elem: ^Type_Info, elem_size: int}
 Type_Info_Slice         :: struct {elem: ^Type_Info, elem_size: int}
diff --git a/core/runtime/print.odin b/core/runtime/print.odin
index 8c0b65864..06740bc75 100644
--- a/core/runtime/print.odin
+++ b/core/runtime/print.odin
@@ -260,6 +260,9 @@ print_type :: proc "contextless" (ti: ^Type_Info) {
 		print_type(info.elem)
 
 	case Type_Info_Enumerated_Array:
+		if info.is_sparse {
+			print_string("#sparse")
+		}
 		print_byte('[')
 		print_type(info.index)
 		print_byte(']')
diff --git a/src/check_type.cpp b/src/check_type.cpp
index a6d82c86e..6d3e32466 100644
--- a/src/check_type.cpp
+++ b/src/check_type.cpp
@@ -2713,29 +2713,30 @@ bool check_type_internal(CheckerContext *ctx, Ast *e, Type **type, Type *named_t
 
 				Type *t = alloc_type_enumerated_array(elem, index, bt->Enum.min_value, bt->Enum.max_value, Token_Invalid);
 
-				bool is_partial = false;
+				bool is_sparse = false;
 				if (at->tag != nullptr) {
 					GB_ASSERT(at->tag->kind == Ast_BasicDirective);
 					String name = at->tag->BasicDirective.name.string;
-					if (name == "partial") {
-						is_partial = true;
+					if (name == "sparse") {
+						is_sparse = true;
 					} else {
 						error(at->tag, "Invalid tag applied to an enumerated array, got #%.*s", LIT(name));
 					}
 				}
 
-				if (!is_partial && t->EnumeratedArray.count > bt->Enum.fields.count) {
+				if (!is_sparse && t->EnumeratedArray.count > bt->Enum.fields.count) {
 					error(e, "Non-contiguous enumeration used as an index in an enumerated array");
 					long long ea_count   = cast(long long)t->EnumeratedArray.count;
 					long long enum_count = cast(long long)bt->Enum.fields.count;
 					error_line("\tenumerated array length: %lld\n", ea_count);
 					error_line("\tenum field count: %lld\n", enum_count);
-					error_line("\tSuggestion: prepend #partial to the enumerated array to allow for non-named elements\n");
+					error_line("\tSuggestion: prepend #sparse to the enumerated array to allow for non-contiguous elements\n");
 					if (2*enum_count < ea_count) {
 						error_line("\tWarning: the number of named elements is much smaller than the length of the array, are you sure this is what you want?\n");
-						error_line("\t         this warning will be removed if #partial is applied\n");
+						error_line("\t         this warning will be removed if #sparse is applied\n");
 					}
 				}
+				t->EnumeratedArray.is_sparse = is_sparse;
 
 				*type = t;
 
diff --git a/src/llvm_backend_type.cpp b/src/llvm_backend_type.cpp
index e1332c6f3..1d6297164 100644
--- a/src/llvm_backend_type.cpp
+++ b/src/llvm_backend_type.cpp
@@ -454,7 +454,7 @@ void lb_setup_type_info_data(lbProcedure *p) { // NOTE(bill): Setup type_info da
 		case Type_EnumeratedArray: {
 			tag = lb_const_ptr_cast(m, variant_ptr, t_type_info_enumerated_array_ptr);
 
-			LLVMValueRef vals[6] = {
+			LLVMValueRef vals[7] = {
 				lb_get_type_info_ptr(m, t->EnumeratedArray.elem).value,
 				lb_get_type_info_ptr(m, t->EnumeratedArray.index).value,
 				lb_const_int(m, t_int, type_size_of(t->EnumeratedArray.elem)).value,
@@ -463,6 +463,8 @@ void lb_setup_type_info_data(lbProcedure *p) { // NOTE(bill): Setup type_info da
 				// Unions
 				LLVMConstNull(lb_type(m, t_type_info_enum_value)),
 				LLVMConstNull(lb_type(m, t_type_info_enum_value)),
+
+				lb_const_bool(m, t_bool, t->EnumeratedArray.is_sparse).value,
 			};
 
 			lbValue res = {};
diff --git a/src/parser.cpp b/src/parser.cpp
index 6db71bc4a..7302b18a9 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -2134,7 +2134,7 @@ Ast *parse_operand(AstFile *f, bool lhs) {
 				break;
 			}
 			return original_type;
-		} else if (name.string == "partial") {
+		} else if (name.string == "sparse") {
 			Ast *tag = ast_basic_directive(f, token, name);
 			Ast *original_type = parse_type(f);
 			Ast *type = unparen_expr(original_type);
diff --git a/src/types.cpp b/src/types.cpp
index 07951196a..e0d35a12c 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -221,6 +221,7 @@ struct TypeProc {
 		ExactValue *max_value;                            \
 		i64 count;                                        \
 		TokenKind op;                                     \
+		bool is_sparse;                                   \
 	})                                                        \
 	TYPE_KIND(Slice,   struct { Type *elem; })                \
 	TYPE_KIND(DynamicArray, struct { Type *elem; })           \
@@ -3830,6 +3831,9 @@ gbString write_type_to_string(gbString str, Type *type) {
 		break;
 
 	case Type_EnumeratedArray:
+		if (type->EnumeratedArray.is_sparse) {
+			str = gb_string_appendc(str, "#sparse");
+		}
 		str = gb_string_append_rune(str, '[');
 		str = write_type_to_string(str, type->EnumeratedArray.index);
 		str = gb_string_append_rune(str, ']');
-- 
cgit v1.2.3


From 340838c8789385212eb3225c15cabbd38b51dbea Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Tue, 8 Feb 2022 23:00:00 +0000
Subject: Add procs_darwin.odin

---
 core/runtime/procs_darwin.odin | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 core/runtime/procs_darwin.odin

(limited to 'core/runtime')

diff --git a/core/runtime/procs_darwin.odin b/core/runtime/procs_darwin.odin
new file mode 100644
index 000000000..79fd777d7
--- /dev/null
+++ b/core/runtime/procs_darwin.odin
@@ -0,0 +1,20 @@
+//+private
+package runtime
+
+foreign import "system:Foundation.framework"
+
+import "core:intrinsics"
+
+objc_id :: ^intrinsics.objc_object
+objc_Class :: ^intrinsics.objc_class
+objc_SEL :: ^intrinsics.objc_selector
+
+foreign Foundation {
+	objc_lookUpClass :: proc "c" (name: cstring) -> objc_Class ---
+	sel_registerName :: proc "c" (name: cstring) -> objc_SEL ---
+
+	objc_msgSend        :: proc "c" (self: objc_id, op: objc_SEL, #c_vararg args: ..any) ---
+	objc_msgSend_fpret  :: proc "c" (self: objc_id, op: objc_SEL, #c_vararg args: ..any) -> f64 ---
+	objc_msgSend_fp2ret :: proc "c" (self: objc_id, op: objc_SEL, #c_vararg args: ..any) -> complex128 ---
+	objc_msgSend_stret  :: proc "c" (self: objc_id, op: objc_SEL, #c_vararg args: ..any) ---
+}
-- 
cgit v1.2.3


From 32c7e817450e8f089eec81a147d20b919db088ff Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Mon, 14 Feb 2022 18:32:10 +0000
Subject: Use `objc_allocateClassPair` for `intrinsics.objc_register_class`

---
 core/runtime/procs_darwin.odin | 1 +
 src/check_builtin.cpp          | 1 +
 src/llvm_backend_utility.cpp   | 8 +++++---
 3 files changed, 7 insertions(+), 3 deletions(-)

(limited to 'core/runtime')

diff --git a/core/runtime/procs_darwin.odin b/core/runtime/procs_darwin.odin
index 79fd777d7..b54a28dcc 100644
--- a/core/runtime/procs_darwin.odin
+++ b/core/runtime/procs_darwin.odin
@@ -12,6 +12,7 @@ objc_SEL :: ^intrinsics.objc_selector
 foreign Foundation {
 	objc_lookUpClass :: proc "c" (name: cstring) -> objc_Class ---
 	sel_registerName :: proc "c" (name: cstring) -> objc_SEL ---
+	objc_allocateClassPair :: proc "c" (superclass: objc_Class, name: cstring, extraBytes: uint) ---
 
 	objc_msgSend        :: proc "c" (self: objc_id, op: objc_SEL, #c_vararg args: ..any) ---
 	objc_msgSend_fpret  :: proc "c" (self: objc_id, op: objc_SEL, #c_vararg args: ..any) -> f64 ---
diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp
index a6b1759f5..c7ada8e03 100644
--- a/src/check_builtin.cpp
+++ b/src/check_builtin.cpp
@@ -225,6 +225,7 @@ void add_objc_proc_type(CheckerContext *c, Ast *call, Type *return_type, Slice<T
 
 	add_package_dependency(c, "runtime", "objc_lookUpClass");
 	add_package_dependency(c, "runtime", "sel_registerName");
+	add_package_dependency(c, "runtime", "objc_allocateClassPair");
 
 	add_package_dependency(c, "runtime", "objc_msgSend");
 	add_package_dependency(c, "runtime", "objc_msgSend_fpret");
diff --git a/src/llvm_backend_utility.cpp b/src/llvm_backend_utility.cpp
index 75fb89314..98b7e07f0 100644
--- a/src/llvm_backend_utility.cpp
+++ b/src/llvm_backend_utility.cpp
@@ -1908,9 +1908,11 @@ lbValue lb_handle_objc_register_class(lbProcedure *p, Ast *expr) {
 	String name = tav.value.value_string;
 	lbAddr dst = lb_handle_objc_find_or_register_class(p, name);
 
-	auto args = array_make<lbValue>(permanent_allocator(), 1);
-	args[0] = lb_const_value(m, t_cstring, exact_value_string(name));
-	lbValue ptr = lb_emit_runtime_call(p, "objc_lookUpClass", args);
+	auto args = array_make<lbValue>(permanent_allocator(), 3);
+	args[0] = lb_const_nil(m, t_objc_Class);
+	args[1] = lb_const_nil(m, t_objc_Class);
+	args[2] = lb_const_int(m, t_uint, 0);
+	lbValue ptr = lb_emit_runtime_call(p, "objc_allocateClassPair", args);
 	lb_addr_store(p, dst, ptr);
 
 	return lb_addr_load(p, dst);
-- 
cgit v1.2.3


From 1857bc7b02eec221bc0d89a4702b9c8c5e003e3f Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 16 Feb 2022 14:51:54 +0000
Subject: Improve slice bounds checking runtime error messages

---
 core/runtime/error_checks.odin | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'core/runtime')

diff --git a/core/runtime/error_checks.odin b/core/runtime/error_checks.odin
index ed75cbea6..14d55c64c 100644
--- a/core/runtime/error_checks.odin
+++ b/core/runtime/error_checks.odin
@@ -25,7 +25,7 @@ bounds_check_error :: proc "contextless" (file: string, line, column: i32, index
 		print_caller_location(Source_Code_Location{file, line, column, ""})
 		print_string(" Index ")
 		print_i64(i64(index))
-		print_string(" is out of bounds range 0:")
+		print_string(" is out of range 0..<")
 		print_i64(i64(count))
 		print_byte('\n')
 		bounds_trap()
@@ -35,11 +35,11 @@ bounds_check_error :: proc "contextless" (file: string, line, column: i32, index
 
 slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int, len: int) -> ! {
 	print_caller_location(Source_Code_Location{file, line, column, ""})
-	print_string(" Invalid slice indices: ")
+	print_string(" Invalid slice indices ")
 	print_i64(i64(lo))
 	print_string(":")
 	print_i64(i64(hi))
-	print_string(":")
+	print_string(" is out of range 0..<")
 	print_i64(i64(len))
 	print_byte('\n')
 	bounds_trap()
@@ -47,7 +47,7 @@ slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, h
 
 multi_pointer_slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int) -> ! {
 	print_caller_location(Source_Code_Location{file, line, column, ""})
-	print_string(" Invalid slice indices: ")
+	print_string(" Invalid slice indices ")
 	print_i64(i64(lo))
 	print_string(":")
 	print_i64(i64(hi))
@@ -83,11 +83,11 @@ dynamic_array_expr_error :: proc "contextless" (file: string, line, column: i32,
 	}
 	handle_error :: proc "contextless" (file: string, line, column: i32, low, high, max: int) {
 		print_caller_location(Source_Code_Location{file, line, column, ""})
-		print_string(" Invalid dynamic array values: ")
+		print_string(" Invalid dynamic array indices ")
 		print_i64(i64(low))
 		print_string(":")
 		print_i64(i64(high))
-		print_string(":")
+		print_string(" is out of range 0..<")
 		print_i64(i64(max))
 		print_byte('\n')
 		bounds_trap()
@@ -107,7 +107,7 @@ matrix_bounds_check_error :: proc "contextless" (file: string, line, column: i32
 		print_i64(i64(row_index))
 		print_string(", ")
 		print_i64(i64(column_index))
-		print_string(" is out of bounds range [0..<")
+		print_string(" is out of range [0..<")
 		print_i64(i64(row_count))
 		print_string(", 0..<")
 		print_i64(i64(column_count))
-- 
cgit v1.2.3


From db6bd9b358f17c0259ff5fe6411ce93407613338 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 16 Feb 2022 16:03:49 +0000
Subject: Allow sysv and win64 calling conventions to be used on any platform
 on amd64

---
 core/runtime/core.odin    |  5 +++++
 src/check_type.cpp        | 19 +++++++++++++++++++
 src/docs_writer.cpp       | 35 +----------------------------------
 src/llvm_abi.cpp          |  6 ++++++
 src/llvm_backend.hpp      |  4 ++++
 src/llvm_backend_proc.cpp |  2 +-
 src/parser.cpp            |  6 ++++++
 src/parser.hpp            | 18 ++++++++++++++++++
 8 files changed, 60 insertions(+), 35 deletions(-)

(limited to 'core/runtime')

diff --git a/core/runtime/core.odin b/core/runtime/core.odin
index fec51f236..229d70417 100644
--- a/core/runtime/core.odin
+++ b/core/runtime/core.odin
@@ -33,6 +33,11 @@ Calling_Convention :: enum u8 {
 
 	None        = 6,
 	Naked       = 7,
+
+	_           = 8, // reserved
+
+	Win64       = 9,
+	SysV        = 10,
 }
 
 Type_Info_Enum_Value :: distinct i64
diff --git a/src/check_type.cpp b/src/check_type.cpp
index 32340070e..a11f5234b 100644
--- a/src/check_type.cpp
+++ b/src/check_type.cpp
@@ -1910,6 +1910,25 @@ bool check_procedure_type(CheckerContext *ctx, Type *type, Ast *proc_type_node,
 		c->scope->flags &= ~ScopeFlag_ContextDefined;
 	}
 
+	TargetArchKind arch = build_context.metrics.arch;
+	switch (cc) {
+	case ProcCC_StdCall:
+	case ProcCC_FastCall:
+		if (arch != TargetArch_i386 || arch != TargetArch_amd64) {
+			error(proc_type_node, "Invalid procedure calling convention \"%s\" for target architecture, expected either i386 or amd64, got %.*s",
+			      proc_calling_convention_strings[cc], LIT(target_arch_names[arch]));
+		}
+		break;
+	case ProcCC_Win64:
+	case ProcCC_SysV:
+		if (arch != TargetArch_amd64) {
+			error(proc_type_node, "Invalid procedure calling convention \"%s\" for target architecture, expected amd64, got %.*s",
+			      proc_calling_convention_strings[cc], LIT(target_arch_names[arch]));
+		}
+		break;
+	}
+
+
 	bool variadic = false;
 	isize variadic_index = -1;
 	bool success = true;
diff --git a/src/docs_writer.cpp b/src/docs_writer.cpp
index 0474ce8ff..2c5186c39 100644
--- a/src/docs_writer.cpp
+++ b/src/docs_writer.cpp
@@ -683,40 +683,7 @@ OdinDocTypeIndex odin_doc_type(OdinDocWriter *w, Type *type) {
 			types[1] = odin_doc_type(w, type->Proc.results);
 			doc_type.types = odin_write_slice(w, types, gb_count_of(types));
 
-			String calling_convention = {};
-			switch (type->Proc.calling_convention) {
-			case ProcCC_Invalid:
-				// no need
-				break;
-			case ProcCC_Odin:
-				if (default_calling_convention() != ProcCC_Odin) {
-					calling_convention = str_lit("odin");
-				}
-				break;
-			case ProcCC_Contextless:
-				if (default_calling_convention() != ProcCC_Contextless) {
-					calling_convention = str_lit("contextless");
-				}
-				break;
-			case ProcCC_CDecl:
-				calling_convention = str_lit("cdecl");
-				break;
-			case ProcCC_StdCall:
-				calling_convention = str_lit("stdcall");
-				break;
-			case ProcCC_FastCall:
-				calling_convention = str_lit("fastcall");
-				break;
-			case ProcCC_None:
-				calling_convention = str_lit("none");
-				break;
-			case ProcCC_Naked:
-				calling_convention = str_lit("naked");
-				break;
-			case ProcCC_InlineAsm:
-				calling_convention = str_lit("inline-assembly");
-				break;
-			}
+			String calling_convention = make_string_c(proc_calling_convention_strings[type->Proc.calling_convention]);
 			doc_type.calling_convention = odin_doc_write_string(w, calling_convention);
 		}
 		break;
diff --git a/src/llvm_abi.cpp b/src/llvm_abi.cpp
index 310df6639..0244b73d6 100644
--- a/src/llvm_abi.cpp
+++ b/src/llvm_abi.cpp
@@ -1184,6 +1184,12 @@ LB_ABI_INFO(lb_get_abi_info) {
 			ft->calling_convention = calling_convention;
 			return ft;
 		}
+	case ProcCC_Win64:
+		GB_ASSERT(build_context.metrics.arch == TargetArch_amd64);
+		return lbAbiAmd64Win64::abi_info(c, arg_types, arg_count, return_type, return_is_defined, calling_convention);
+	case ProcCC_SysV:
+		GB_ASSERT(build_context.metrics.arch == TargetArch_amd64);
+		return lbAbiAmd64SysV::abi_info(c, arg_types, arg_count, return_type, return_is_defined, calling_convention);
 	}
 
 	switch (build_context.metrics.arch) {
diff --git a/src/llvm_backend.hpp b/src/llvm_backend.hpp
index 087cda22a..f2bcfaff6 100644
--- a/src/llvm_backend.hpp
+++ b/src/llvm_backend.hpp
@@ -548,6 +548,10 @@ lbCallingConventionKind const lb_calling_convention_map[ProcCC_MAX] = {
 	lbCallingConvention_C,            // ProcCC_None,
 	lbCallingConvention_C,            // ProcCC_Naked,
 	lbCallingConvention_C,            // ProcCC_InlineAsm,
+
+	lbCallingConvention_Win64,        // ProcCC_Win64,
+	lbCallingConvention_X86_64_SysV,  // ProcCC_SysV,
+
 };
 
 enum : LLVMDWARFTypeEncoding {
diff --git a/src/llvm_backend_proc.cpp b/src/llvm_backend_proc.cpp
index ccb16ebe0..261e2819c 100644
--- a/src/llvm_backend_proc.cpp
+++ b/src/llvm_backend_proc.cpp
@@ -497,7 +497,7 @@ void lb_begin_procedure_body(lbProcedure *p) {
 						}
 						LLVMValueRef debug_storage_value = value;
 						if (original_value != value && LLVMIsALoadInst(value)) {
-							debug_storage_value = ptr.value;
+							debug_storage_value = LLVMGetOperand(value, 0);
 						}
 						lb_add_debug_param_variable(p, debug_storage_value, e->type, e->token, param_index+1, block);
 					}
diff --git a/src/parser.cpp b/src/parser.cpp
index 0914c77ca..bd0e55b7f 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -3412,12 +3412,18 @@ ProcCallingConvention string_to_calling_convention(String s) {
 	if (s == "fast")        return ProcCC_FastCall;
 	if (s == "none")        return ProcCC_None;
 	if (s == "naked")       return ProcCC_Naked;
+
+	if (s == "win64")	return ProcCC_Win64;
+	if (s == "sysv")        return ProcCC_SysV;
+
 	if (s == "system") {
 		if (build_context.metrics.os == TargetOs_windows) {
 			return ProcCC_StdCall;
 		}
 		return ProcCC_CDecl;
 	}
+
+
 	return ProcCC_Invalid;
 }
 
diff --git a/src/parser.hpp b/src/parser.hpp
index ff0df0382..9e93f4b26 100644
--- a/src/parser.hpp
+++ b/src/parser.hpp
@@ -249,12 +249,30 @@ enum ProcCallingConvention : i32 {
 
 	ProcCC_InlineAsm   = 8,
 
+	ProcCC_Win64       = 9,
+	ProcCC_SysV        = 10,
+
+
 	ProcCC_MAX,
 
 
 	ProcCC_ForeignBlockDefault = -1,
 };
 
+char const *proc_calling_convention_strings[ProcCC_MAX] = {
+	"",
+	"odin",
+	"contextless",
+	"cdecl",
+	"stdcall",
+	"fastcall",
+	"none",
+	"naked",
+	"inlineasm",
+	"win64",
+	"sysv",
+};
+
 ProcCallingConvention default_calling_convention(void) {
 	return ProcCC_Odin;
 }
-- 
cgit v1.2.3


From 0fa487f468b1f63d5ec97ae8bbb0da01717f32cc Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sun, 20 Feb 2022 14:27:44 +0000
Subject: Add `-foreign-error-procedures`

---
 core/runtime/error_checks.odin | 20 +++++++++++++++++++-
 src/build_settings.cpp         |  2 ++
 src/checker.cpp                |  1 +
 src/main.cpp                   | 12 ++++++++++++
 4 files changed, 34 insertions(+), 1 deletion(-)

(limited to 'core/runtime')

diff --git a/core/runtime/error_checks.odin b/core/runtime/error_checks.odin
index 14d55c64c..ad6902e2d 100644
--- a/core/runtime/error_checks.odin
+++ b/core/runtime/error_checks.odin
@@ -17,6 +17,24 @@ type_assertion_trap :: proc "contextless" () -> ! {
 }
 
 
+when ODIN_FOREIGN_ERROR_PROCEDURES {
+	foreign {
+		bounds_check_error               :: proc "contextless" (file: string, line, column: i32, index, count: int) ---
+		slice_handle_error               :: proc "contextless" (file: string, line, column: i32, lo, hi: int, len: int) -> ! ---
+		multi_pointer_slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int) -> ! ---
+		multi_pointer_slice_expr_error   :: proc "contextless" (file: string, line, column: i32, lo, hi: int) ---
+		slice_expr_error_hi              :: proc "contextless" (file: string, line, column: i32, hi: int, len: int) ---
+		slice_expr_error_lo_hi           :: proc "contextless" (file: string, line, column: i32, lo, hi: int, len: int) ---
+		dynamic_array_expr_error         :: proc "contextless" (file: string, line, column: i32, low, high, max: int) ---
+		matrix_bounds_check_error        :: proc "contextless" (file: string, line, column: i32, row_index, column_index, row_count, column_count: int) ---
+		type_assertion_check             :: proc "contextless" (ok: bool, file: string, line, column: i32, from, to: typeid) ---
+		type_assertion_check2            :: proc "contextless" (ok: bool, file: string, line, column: i32, from, to: typeid, from_data: rawptr) ---
+		make_slice_error_loc             :: proc "contextless" (loc := #caller_location, len: int) ---
+		make_dynamic_array_error_loc     :: proc "contextless" (using loc := #caller_location, len, cap: int) ---
+		make_map_expr_error_loc          :: proc "contextless" (loc := #caller_location, cap: int) ---
+	}
+} else {
+
 bounds_check_error :: proc "contextless" (file: string, line, column: i32, index, count: int) {
 	if 0 <= index && index < count {
 		return
@@ -231,7 +249,7 @@ make_map_expr_error_loc :: #force_inline proc "contextless" (loc := #caller_loca
 	handle_error(loc, cap)
 }
 
-
+}
 
 
 
diff --git a/src/build_settings.cpp b/src/build_settings.cpp
index cc76f9e7c..cd9bdb40c 100644
--- a/src/build_settings.cpp
+++ b/src/build_settings.cpp
@@ -200,6 +200,7 @@ struct BuildContext {
 	bool   ODIN_DEBUG;   // Odin in debug mode
 	bool   ODIN_DISABLE_ASSERT; // Whether the default 'assert' et al is disabled in code or not
 	bool   ODIN_DEFAULT_TO_NIL_ALLOCATOR; // Whether the default allocator is a "nil" allocator or not (i.e. it does nothing)
+	bool   ODIN_FOREIGN_ERROR_PROCEDURES;
 
 	ErrorPosStyle ODIN_ERROR_POS_STYLE;
 
@@ -269,6 +270,7 @@ struct BuildContext {
 	
 	bool copy_file_contents;
 
+
 	u32 cmd_doc_flags;
 	Array<String> extra_packages;
 
diff --git a/src/checker.cpp b/src/checker.cpp
index f440b7c9a..fe1d362fa 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -976,6 +976,7 @@ void init_universal(void) {
 	add_global_bool_constant("ODIN_USE_SEPARATE_MODULES",     bc->use_separate_modules);
 	add_global_bool_constant("ODIN_TEST",                     bc->command_kind == Command_test);
 	add_global_bool_constant("ODIN_NO_ENTRY_POINT",           bc->no_entry_point);
+	add_global_bool_constant("ODIN_FOREIGN_ERROR_PROCEDURES", bc->ODIN_FOREIGN_ERROR_PROCEDURES);
 
 
 // Builtin Procedures
diff --git a/src/main.cpp b/src/main.cpp
index 291b56996..5746ef146 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -632,6 +632,7 @@ enum BuildFlagKind {
 	BuildFlag_InsertSemicolon,
 	BuildFlag_StrictStyle,
 	BuildFlag_StrictStyleInitOnly,
+	BuildFlag_ForeignErrorProcedures,
 
 	BuildFlag_Compact,
 	BuildFlag_GlobalDefinitions,
@@ -785,10 +786,13 @@ bool parse_build_flags(Array<String> args) {
 	add_flag(&build_flags, BuildFlag_InsertSemicolon,       str_lit("insert-semicolon"),         BuildFlagParam_None, Command__does_check);
 	add_flag(&build_flags, BuildFlag_StrictStyle,           str_lit("strict-style"),             BuildFlagParam_None, Command__does_check);
 	add_flag(&build_flags, BuildFlag_StrictStyleInitOnly,   str_lit("strict-style-init-only"),   BuildFlagParam_None, Command__does_check);
+	add_flag(&build_flags, BuildFlag_ForeignErrorProcedures, str_lit("foreign-error-procedures"), BuildFlagParam_None, Command__does_check);
+
 	add_flag(&build_flags, BuildFlag_Compact,           str_lit("compact"),            BuildFlagParam_None, Command_query);
 	add_flag(&build_flags, BuildFlag_GlobalDefinitions, str_lit("global-definitions"), BuildFlagParam_None, Command_query);
 	add_flag(&build_flags, BuildFlag_GoToDefinitions,   str_lit("go-to-definitions"),  BuildFlagParam_None, Command_query);
 
+
 	add_flag(&build_flags, BuildFlag_Short,         str_lit("short"),        BuildFlagParam_None, Command_doc);
 	add_flag(&build_flags, BuildFlag_AllPackages,   str_lit("all-packages"), BuildFlagParam_None, Command_doc);
 	add_flag(&build_flags, BuildFlag_DocFormat,     str_lit("doc-format"),   BuildFlagParam_None, Command_doc);
@@ -1356,6 +1360,9 @@ bool parse_build_flags(Array<String> args) {
 						case BuildFlag_DefaultToNilAllocator:
 							build_context.ODIN_DEFAULT_TO_NIL_ALLOCATOR = true;
 							break;
+						case BuildFlag_ForeignErrorProcedures:
+							build_context.ODIN_FOREIGN_ERROR_PROCEDURES = true;
+							break;
 						case BuildFlag_InsertSemicolon: {
 							gb_printf_err("-insert-semicolon flag is not required any more\n");
 							bad_flags = true;
@@ -2084,6 +2091,11 @@ void print_show_help(String const arg0, String const &command) {
 		print_usage_line(1, "-verbose-errors");
 		print_usage_line(2, "Prints verbose error messages showing the code on that line and the location in that line");
 		print_usage_line(0, "");
+
+		print_usage_line(1, "-foreign-error-procedures");
+		print_usage_line(2, "States that the error procedues used in the runtime are defined in a separate translation unit");
+		print_usage_line(0, "");
+
 	}
 
 	if (run_or_build) {
-- 
cgit v1.2.3


From 5676c9e7ebcec9af526c59ece1faf2e8b15e457c Mon Sep 17 00:00:00 2001
From: Sébastien Marie <semarie@online.fr>
Date: Fri, 25 Feb 2022 08:49:25 +0000
Subject: initial OpenBSD support

---
 Makefile                                 |   6 +
 core/c/libc/errno.odin                   |  13 +
 core/c/libc/stdio.odin                   |  25 ++
 core/c/libc/time.odin                    |   9 +-
 core/c/libc/wctype.odin                  |   5 +
 core/crypto/rand_generic.odin            |   2 +-
 core/crypto/rand_openbsd.odin            |  12 +
 core/dynlib/lib_unix.odin                |   2 +-
 core/os/dir_openbsd.odin                 |  71 ++++
 core/os/os_openbsd.odin                  | 706 +++++++++++++++++++++++++++++++
 core/os/stat_unix.odin                   |   2 +-
 core/path/filepath/path_unix.odin        |   7 +-
 core/runtime/entry_unix.odin             |   2 +-
 core/sync/channel_unix.odin              |   2 +-
 core/sync/sync2/futex_openbsd.odin       |  78 ++++
 core/sync/sync2/primitives_openbsd.odin  |   9 +
 core/sync/sync2/primitives_pthreads.odin |   2 +-
 core/sync/sync_openbsd.odin              |  36 ++
 core/sync/sync_unix.odin                 |   2 +-
 core/sys/unix/pthread_openbsd.odin       |  65 +++
 core/sys/unix/pthread_unix.odin          |   2 +-
 core/thread/thread_unix.odin             |   2 +-
 core/time/time_unix.odin                 |  34 +-
 src/bug_report.cpp                       |  14 +-
 src/build_settings.cpp                   |  18 +
 src/check_builtin.cpp                    |   1 +
 src/checker.cpp                          |   1 +
 src/common.cpp                           |   2 +-
 src/gb/gb.h                              |  46 +-
 src/threading.cpp                        |   2 +-
 30 files changed, 1151 insertions(+), 27 deletions(-)
 create mode 100644 core/crypto/rand_openbsd.odin
 create mode 100644 core/os/dir_openbsd.odin
 create mode 100644 core/os/os_openbsd.odin
 create mode 100644 core/sync/sync2/futex_openbsd.odin
 create mode 100644 core/sync/sync2/primitives_openbsd.odin
 create mode 100644 core/sync/sync_openbsd.odin
 create mode 100644 core/sys/unix/pthread_openbsd.odin

(limited to 'core/runtime')

diff --git a/Makefile b/Makefile
index d3d3c6a2d..99c71ccd9 100644
--- a/Makefile
+++ b/Makefile
@@ -58,6 +58,12 @@ ifeq ($(OS), Linux)
     CFLAGS:=$(CFLAGS) $(shell $(LLVM_CONFIG) --cxxflags --ldflags)
     LDFLAGS:=$(LDFLAGS) $(shell $(LLVM_CONFIG) --libs core native --system-libs)
 endif
+ifeq ($(OS), OpenBSD)
+    LLVM_CONFIG=/usr/local/bin/llvm-config
+
+    CFLAGS:=$(CFLAGS) $(shell $(LLVM_CONFIG) --cxxflags --ldflags)
+    LDFLAGS:=$(LDFLAGS) -liconv $(shell $(LLVM_CONFIG) --libs core native --system-libs)
+endif
 
 all: debug demo
 
diff --git a/core/c/libc/errno.odin b/core/c/libc/errno.odin
index ecde6af59..53437f42f 100644
--- a/core/c/libc/errno.odin
+++ b/core/c/libc/errno.odin
@@ -27,6 +27,19 @@ when ODIN_OS == .Linux || ODIN_OS == .FreeBSD {
 	ERANGE :: 34
 }
 
+when ODIN_OS == .OpenBSD {
+	@(private="file")
+	@(default_calling_convention="c")
+	foreign libc {
+		@(link_name="__errno")
+		_get_errno :: proc() -> ^int ---
+	}
+
+	EDOM   :: 33
+	EILSEQ :: 84
+	ERANGE :: 34
+}
+
 when ODIN_OS == .Windows {
 	@(private="file")
 	@(default_calling_convention="c")
diff --git a/core/c/libc/stdio.odin b/core/c/libc/stdio.odin
index 9c4a1a708..fc65b954a 100644
--- a/core/c/libc/stdio.odin
+++ b/core/c/libc/stdio.odin
@@ -78,6 +78,31 @@ when ODIN_OS == .Linux {
 	}
 }
 
+when ODIN_OS == .OpenBSD {
+	fpos_t :: i64
+
+	_IOFBF :: 0
+	_IOLBF :: 1
+	_IONBF :: 1
+
+	BUFSIZ :: 1024
+
+	EOF :: int(-1)
+
+	FOPEN_MAX	:: 20
+	FILENAME_MAX	:: 1024
+
+	SEEK_SET :: 0
+	SEEK_CUR :: 1
+	SEEK_END :: 2
+
+	foreign libc {
+		stderr: ^FILE
+		stdin:  ^FILE
+		stdout: ^FILE
+	}
+}
+
 when ODIN_OS == .Darwin {
 	fpos_t :: distinct i64
 	
diff --git a/core/c/libc/time.odin b/core/c/libc/time.odin
index b3539a227..b337e139a 100644
--- a/core/c/libc/time.odin
+++ b/core/c/libc/time.odin
@@ -45,7 +45,7 @@ when ODIN_OS == .Windows {
 	}
 }
 
-when ODIN_OS == .Linux || ODIN_OS == .FreeBSD || ODIN_OS == .Darwin {
+when ODIN_OS == .Linux || ODIN_OS == .FreeBSD || ODIN_OS == .Darwin || ODIN_OS == .OpenBSD {
 	@(default_calling_convention="c")
 	foreign libc {
 		// 7.27.2 Time manipulation functions
@@ -63,7 +63,12 @@ when ODIN_OS == .Linux || ODIN_OS == .FreeBSD || ODIN_OS == .Darwin {
 		strftime     :: proc(s: [^]char, maxsize: size_t, format: cstring, timeptr: ^tm) -> size_t ---
 	}
 
-	CLOCKS_PER_SEC :: 1000000
+	when ODIN_OS == .OpenBSD {
+		CLOCKS_PER_SEC :: 100
+	} else {
+		CLOCKS_PER_SEC :: 1000000
+	}
+
 	TIME_UTC       :: 1
 
 	time_t         :: distinct i64
diff --git a/core/c/libc/wctype.odin b/core/c/libc/wctype.odin
index 942726ba6..f833af51f 100644
--- a/core/c/libc/wctype.odin
+++ b/core/c/libc/wctype.odin
@@ -25,6 +25,11 @@ when ODIN_OS == .Darwin {
 	wctype_t  :: distinct u32
 }
 
+when ODIN_OS == .OpenBSD {
+	wctrans_t :: distinct rawptr
+	wctype_t  :: distinct rawptr
+}
+
 @(default_calling_convention="c")
 foreign libc {
 	// 7.30.2.1 Wide character classification functions
diff --git a/core/crypto/rand_generic.odin b/core/crypto/rand_generic.odin
index be6987ee2..10edc1c8a 100644
--- a/core/crypto/rand_generic.odin
+++ b/core/crypto/rand_generic.odin
@@ -1,6 +1,6 @@
 package crypto
 
-when ODIN_OS != .Linux {
+when ODIN_OS != .Linux && ODIN_OS != .OpenBSD {
 	_rand_bytes :: proc (dst: []byte) {
 		unimplemented("crypto: rand_bytes not supported on this OS")
 	}
diff --git a/core/crypto/rand_openbsd.odin b/core/crypto/rand_openbsd.odin
new file mode 100644
index 000000000..bae97e8f0
--- /dev/null
+++ b/core/crypto/rand_openbsd.odin
@@ -0,0 +1,12 @@
+package crypto
+
+import "core:c"
+
+foreign import libc "system:c"
+foreign libc {
+	arc4random_buf :: proc "c" (buf: rawptr, nbytes: c.size_t) ---
+}
+
+_rand_bytes :: proc (dst: []byte) {
+	arc4random_buf(raw_data(dst), len(dst))
+}
diff --git a/core/dynlib/lib_unix.odin b/core/dynlib/lib_unix.odin
index bb8affb79..e52ade153 100644
--- a/core/dynlib/lib_unix.odin
+++ b/core/dynlib/lib_unix.odin
@@ -1,4 +1,4 @@
-// +build linux, darwin, freebsd
+// +build linux, darwin, freebsd, openbsd
 package dynlib
 
 import "core:os"
diff --git a/core/os/dir_openbsd.odin b/core/os/dir_openbsd.odin
new file mode 100644
index 000000000..465fd35ae
--- /dev/null
+++ b/core/os/dir_openbsd.odin
@@ -0,0 +1,71 @@
+package os
+
+import "core:strings"
+import "core:mem"
+
+read_dir :: proc(fd: Handle, n: int, allocator := context.allocator) -> (fi: []File_Info, err: Errno) {
+	dirp: Dir
+	dirp, err = _fdopendir(fd)
+	if err != ERROR_NONE {
+		return
+	}
+
+	defer _closedir(dirp)
+
+	// XXX OpenBSD
+	dirpath: string
+	dirpath, err = absolute_path_from_handle(fd)
+
+	if err != ERROR_NONE {
+		return
+	}
+
+	defer delete(dirpath)
+
+	n := n
+	size := n
+	if n <= 0 {
+		n = -1
+		size = 100
+	}
+
+	dfi := make([dynamic]File_Info, 0, size, allocator)
+
+	for {
+		entry: Dirent
+		end_of_stream: bool
+		entry, err, end_of_stream = _readdir(dirp)
+		if err != ERROR_NONE {
+			for fi_ in dfi {
+				file_info_delete(fi_, allocator)
+			}
+			delete(dfi)
+			return
+		} else if end_of_stream {
+			break
+		}
+
+		fi_: File_Info
+		filename := cast(string)(transmute(cstring)mem.Raw_Cstring{ data = &entry.name[0] })
+
+		if filename == "." || filename == ".." {
+			continue
+		}
+
+		fullpath := strings.join( []string{ dirpath, filename }, "/", context.temp_allocator)
+		defer delete(fullpath, context.temp_allocator)
+
+		fi_, err = stat(fullpath, allocator)
+		if err != ERROR_NONE {
+			for fi__ in dfi {
+				file_info_delete(fi__, allocator)
+			}
+			delete(dfi)
+			return
+		}
+
+		append(&dfi, fi_)
+	}
+
+	return dfi[:], ERROR_NONE
+}
diff --git a/core/os/os_openbsd.odin b/core/os/os_openbsd.odin
new file mode 100644
index 000000000..3862851a1
--- /dev/null
+++ b/core/os/os_openbsd.odin
@@ -0,0 +1,706 @@
+package os
+
+foreign import libc "system:c"
+
+import "core:runtime"
+import "core:strings"
+import "core:c"
+
+Handle    :: distinct i32
+Pid       :: distinct i32
+File_Time :: distinct u64
+Errno     :: distinct i32
+
+INVALID_HANDLE :: ~Handle(0)
+
+ERROR_NONE:	Errno: 0
+
+EPERM:		Errno: 1
+ENOENT:		Errno: 2
+ESRCH:		Errno: 3
+EINTR:		Errno: 4
+EIO:		Errno: 5
+ENXIO:		Errno: 6
+E2BIG:		Errno: 7
+ENOEXEC:	Errno: 8
+EBADF:		Errno: 9
+ECHILD:		Errno: 10
+EDEADLK:	Errno: 11
+ENOMEM:		Errno: 12
+EACCES:		Errno: 13
+EFAULT:		Errno: 14
+ENOTBLK:	Errno: 15
+EBUSY:		Errno: 16
+EEXIST:		Errno: 17
+EXDEV:		Errno: 18
+ENODEV:		Errno: 19
+ENOTDIR:	Errno: 20
+EISDIR:		Errno: 21
+EINVAL:		Errno: 22
+ENFILE:		Errno: 23
+EMFILE:		Errno: 24
+ENOTTY:		Errno: 25
+ETXTBSY:	Errno: 26
+EFBIG:		Errno: 27
+ENOSPC:		Errno: 28
+ESPIPE:		Errno: 29
+EROFS:		Errno: 30
+EMLINK:		Errno: 31
+EPIPE:		Errno: 32
+EDOM:		Errno: 33
+ERANGE:		Errno: 34
+EAGAIN:		Errno: 35
+EWOULDBLOCK:	Errno: EAGAIN
+EINPROGRESS:	Errno: 36
+EALREADY:	Errno: 37
+ENOTSOCK:	Errno: 38
+EDESTADDRREQ:	Errno: 39
+EMSGSIZE:	Errno: 40
+EPROTOTYPE:	Errno: 41
+ENOPROTOOPT:	Errno: 42
+EPROTONOSUPPORT: Errno: 43
+ESOCKTNOSUPPORT: Errno: 44
+EOPNOTSUPP:	Errno: 45
+EPFNOSUPPORT:	Errno: 46
+EAFNOSUPPORT:	Errno: 47
+EADDRINUSE:	Errno: 48
+EADDRNOTAVAIL:	Errno: 49
+ENETDOWN:	Errno: 50
+ENETUNREACH:	Errno: 51
+ENETRESET:	Errno: 52
+ECONNABORTED:	Errno: 53
+ECONNRESET:	Errno: 54
+ENOBUFS:	Errno: 55
+EISCONN:	Errno: 56
+ENOTCONN:	Errno: 57
+ESHUTDOWN:	Errno: 58
+ETOOMANYREFS:	Errno: 59
+ETIMEDOUT:	Errno: 60
+ECONNREFUSED:	Errno: 61
+ELOOP:		Errno: 62
+ENAMETOOLONG:	Errno: 63
+EHOSTDOWN:	Errno: 64
+EHOSTUNREACH:	Errno: 65
+ENOTEMPTY:	Errno: 66
+EPROCLIM:	Errno: 67
+EUSERS:		Errno: 68
+EDQUOT:		Errno: 69
+ESTALE:		Errno: 70
+EREMOTE:	Errno: 71
+EBADRPC:	Errno: 72
+ERPCMISMATCH:	Errno: 73
+EPROGUNAVAIL:	Errno: 74
+EPROGMISMATCH:	Errno: 75
+EPROCUNAVAIL:	Errno: 76
+ENOLCK:		Errno: 77
+ENOSYS:		Errno: 78
+EFTYPE:		Errno: 79
+EAUTH:		Errno: 80
+ENEEDAUTH:	Errno: 81
+EIPSEC:		Errno: 82
+ENOATTR:	Errno: 83
+EILSEQ:		Errno: 84
+ENOMEDIUM:	Errno: 85
+EMEDIUMTYPE:	Errno: 86
+EOVERFLOW:	Errno: 87
+ECANCELED:	Errno: 88
+EIDRM:		Errno: 89
+ENOMSG:		Errno: 90
+ENOTSUP:	Errno: 91
+EBADMSG:	Errno: 92
+ENOTRECOVERABLE: Errno: 93
+EOWNERDEAD:	Errno: 94
+EPROTO:		Errno: 95
+
+O_RDONLY   :: 0x00000
+O_WRONLY   :: 0x00001
+O_RDWR     :: 0x00002
+O_NONBLOCK :: 0x00004
+O_APPEND   :: 0x00008
+O_ASYNC    :: 0x00040
+O_SYNC     :: 0x00080
+O_CREATE   :: 0x00200
+O_TRUNC    :: 0x00400
+O_EXCL     :: 0x00800
+O_NOCTTY   :: 0x08000
+O_CLOEXEC  :: 0x10000
+
+SEEK_SET :: 0
+SEEK_CUR :: 1
+SEEK_END :: 2
+
+RTLD_LAZY     :: 0x001
+RTLD_NOW      :: 0x002
+RTLD_LOCAL    :: 0x000
+RTLD_GLOBAL   :: 0x100
+RTLD_TRACE    :: 0x200
+RTLD_NODELETE :: 0x400
+
+MAX_PATH :: 1024
+
+// "Argv" arguments converted to Odin strings
+args := _alloc_command_line_arguments()
+
+pid_t     :: i32
+time_t    :: i64
+mode_t    :: u32
+dev_t     :: i32
+ino_t     :: u64
+nlink_t   :: u32
+uid_t     :: u32
+gid_t     :: u32
+off_t     :: i64
+blkcnt_t  :: u64
+blksize_t :: i32
+
+Unix_File_Time :: struct {
+	seconds:     time_t,
+	nanoseconds: c.long,
+}
+
+OS_Stat :: struct {
+	mode: mode_t,			// inode protection mode
+	device_id: dev_t,		// inode's device
+	serial: ino_t,			// inode's number
+	nlink: nlink_t,			// number of hard links
+	uid: uid_t,			// user ID of the file's owner
+	gid: gid_t,			// group ID of the file's group
+	rdev: dev_t,			// device type
+
+	last_access: Unix_File_Time,	// time of last access
+	modified: Unix_File_Time,	// time of last data modification
+	status_change: Unix_File_Time,	// time of last file status change
+
+	size: off_t,			// file size, in bytes
+	blocks: blkcnt_t,		// blocks allocated for file
+	block_size:	blksize_t,	// optimal blocksize for I/O
+
+	flags:		u32,		// user defined flags for file
+	gen:		u32,		// file generation number
+	birthtime:	Unix_File_Time,	// time of file creation
+}
+
+MAXNAMLEN :: 255
+
+// NOTE(laleksic, 2021-01-21): Comment and rename these to match OS_Stat above
+Dirent :: struct {
+	ino:      ino_t,	// file number of entry
+	off:      off_t,	// offset after this entry
+	reclen:   u16,		// length of this record
+	type:     u8,		// file type
+	namlen:   u8,		// length of string in name
+	_padding: [4]u8,
+	name:     [MAXNAMLEN + 1]byte, // name
+}
+
+Dir :: distinct rawptr // DIR*
+
+// File type
+S_IFMT   :: 0o170000 // Type of file mask
+S_IFIFO  :: 0o010000 // Named pipe (fifo)
+S_IFCHR  :: 0o020000 // Character special
+S_IFDIR  :: 0o040000 // Directory
+S_IFBLK  :: 0o060000 // Block special
+S_IFREG  :: 0o100000 // Regular
+S_IFLNK  :: 0o120000 // Symbolic link
+S_IFSOCK :: 0o140000 // Socket
+S_ISVTX  :: 0o001000 // Save swapped text even after use
+
+// File mode
+	// Read, write, execute/search by owner
+S_IRWXU :: 0o0700 // RWX mask for owner
+S_IRUSR :: 0o0400 // R for owner
+S_IWUSR :: 0o0200 // W for owner
+S_IXUSR :: 0o0100 // X for owner
+
+	// Read, write, execute/search by group
+S_IRWXG :: 0o0070 // RWX mask for group
+S_IRGRP :: 0o0040 // R for group
+S_IWGRP :: 0o0020 // W for group
+S_IXGRP :: 0o0010 // X for group
+
+	// Read, write, execute/search by others
+S_IRWXO :: 0o0007 // RWX mask for other
+S_IROTH :: 0o0004 // R for other
+S_IWOTH :: 0o0002 // W for other
+S_IXOTH :: 0o0001 // X for other
+
+S_ISUID :: 0o4000 // Set user id on execution
+S_ISGID :: 0o2000 // Set group id on execution
+S_ISTXT :: 0o1000 // Sticky bit
+
+S_ISLNK  :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFLNK  }
+S_ISREG  :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFREG  }
+S_ISDIR  :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFDIR  }
+S_ISCHR  :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFCHR  }
+S_ISBLK  :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFBLK  }
+S_ISFIFO :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFIFO  }
+S_ISSOCK :: #force_inline proc(m: u32) -> bool { return (m & S_IFMT) == S_IFSOCK }
+
+F_OK :: 0x00 // Test for file existance
+X_OK :: 0x01 // Test for execute permission
+W_OK :: 0x02 // Test for write permission
+R_OK :: 0x04 // Test for read permission
+
+AT_FDCWD            :: -100
+AT_EACCESS          :: 0x01
+AT_SYMLINK_NOFOLLOW :: 0x02
+AT_SYMLINK_FOLLOW   :: 0x04
+AT_REMOVEDIR        :: 0x08
+
+@(default_calling_convention="c")
+foreign libc {
+	@(link_name="__errno")	__errno		:: proc() -> ^int ---
+
+	@(link_name="fork")	_unix_fork	:: proc() -> pid_t ---
+	@(link_name="getthrid")	_unix_getthrid	:: proc() -> int ---
+
+	@(link_name="open")	_unix_open	:: proc(path: cstring, flags: c.int, mode: c.int) -> Handle ---
+	@(link_name="close")	_unix_close	:: proc(fd: Handle) -> c.int ---
+	@(link_name="read")	_unix_read	:: proc(fd: Handle, buf: rawptr, size: c.size_t) -> c.ssize_t ---
+	@(link_name="write")	_unix_write	:: proc(fd: Handle, buf: rawptr, size: c.size_t) -> c.ssize_t ---
+	@(link_name="lseek")	_unix_seek	:: proc(fd: Handle, offset: off_t, whence: c.int) -> off_t ---
+	@(link_name="stat")	_unix_stat	:: proc(path: cstring, sb: ^OS_Stat) -> c.int ---
+	@(link_name="fstat")	_unix_fstat	:: proc(fd: Handle, sb: ^OS_Stat) -> c.int ---
+	@(link_name="lstat")	_unix_lstat	:: proc(path: cstring, sb: ^OS_Stat) -> c.int ---
+	@(link_name="readlink")	_unix_readlink	:: proc(path: cstring, buf: ^byte, bufsiz: c.size_t) -> c.ssize_t ---
+	@(link_name="access")	_unix_access	:: proc(path: cstring, mask: c.int) -> c.int ---
+	@(link_name="getcwd")	_unix_getcwd	:: proc(buf: cstring, len: c.size_t) -> cstring ---
+	@(link_name="chdir")	_unix_chdir	:: proc(path: cstring) -> c.int ---
+	@(link_name="rename")	_unix_rename	:: proc(old, new: cstring) -> c.int ---
+	@(link_name="unlink")	_unix_unlink	:: proc(path: cstring) -> c.int ---
+	@(link_name="rmdir")	_unix_rmdir	:: proc(path: cstring) -> c.int ---
+	@(link_name="mkdir")	_unix_mkdir	:: proc(path: cstring, mode: mode_t) -> c.int ---
+
+	@(link_name="getpagesize") _unix_getpagesize :: proc() -> c.int ---
+	@(link_name="fdopendir") _unix_fdopendir :: proc(fd: Handle) -> Dir ---
+	@(link_name="closedir")	_unix_closedir	:: proc(dirp: Dir) -> c.int ---
+	@(link_name="rewinddir") _unix_rewinddir :: proc(dirp: Dir) ---
+	@(link_name="readdir_r") _unix_readdir_r :: proc(dirp: Dir, entry: ^Dirent, result: ^^Dirent) -> c.int ---
+
+	@(link_name="malloc")	_unix_malloc	:: proc(size: c.size_t) -> rawptr ---
+	@(link_name="calloc")	_unix_calloc	:: proc(num, size: c.size_t) -> rawptr ---
+	@(link_name="free")	_unix_free	:: proc(ptr: rawptr) ---
+	@(link_name="realloc")	_unix_realloc	:: proc(ptr: rawptr, size: c.size_t) -> rawptr ---
+
+	@(link_name="getenv")	_unix_getenv	:: proc(cstring) -> cstring ---
+	@(link_name="realpath")	_unix_realpath	:: proc(path: cstring, resolved_path: rawptr) -> rawptr ---
+
+	@(link_name="exit")	_unix_exit	:: proc(status: c.int) -> ! ---
+
+	@(link_name="dlopen")	_unix_dlopen	:: proc(filename: cstring, flags: c.int) -> rawptr ---
+	@(link_name="dlsym")	_unix_dlsym	:: proc(handle: rawptr, symbol: cstring) -> rawptr ---
+	@(link_name="dlclose")	_unix_dlclose	:: proc(handle: rawptr) -> c.int ---
+	@(link_name="dlerror")	_unix_dlerror	:: proc() -> cstring ---
+}
+
+is_path_separator :: proc(r: rune) -> bool {
+	return r == '/'
+}
+
+get_last_error :: proc() -> int {
+	return __errno()^
+}
+
+fork :: proc() -> (Pid, Errno) {
+	pid := _unix_fork()
+	if pid == -1 {
+		return Pid(-1), Errno(get_last_error())
+	}
+	return Pid(pid), ERROR_NONE
+}
+
+open :: proc(path: string, flags: int = O_RDONLY, mode: int = 0) -> (Handle, Errno) {
+	cstr := strings.clone_to_cstring(path, context.temp_allocator)
+	handle := _unix_open(cstr, c.int(flags), c.int(mode))
+	if handle == -1 {
+		return INVALID_HANDLE, Errno(get_last_error())
+	}
+	return handle, ERROR_NONE
+}
+
+close :: proc(fd: Handle) -> Errno {
+	result := _unix_close(fd)
+	if result == -1 {
+		return Errno(get_last_error())
+	}
+	return ERROR_NONE
+}
+
+read :: proc(fd: Handle, data: []byte) -> (int, Errno) {
+	bytes_read := _unix_read(fd, &data[0], c.size_t(len(data)))
+	if bytes_read == -1 {
+		return -1, Errno(get_last_error())
+	}
+	return int(bytes_read), ERROR_NONE
+}
+
+write :: proc(fd: Handle, data: []byte) -> (int, Errno) {
+	if len(data) == 0 {
+		return 0, ERROR_NONE
+	}
+	bytes_written := _unix_write(fd, &data[0], c.size_t(len(data)))
+	if bytes_written == -1 {
+		return -1, Errno(get_last_error())
+	}
+	return int(bytes_written), ERROR_NONE
+}
+
+seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) {
+	res := _unix_seek(fd, offset, c.int(whence))
+	if res == -1 {
+		return -1, Errno(get_last_error())
+	}
+	return res, ERROR_NONE
+}
+
+file_size :: proc(fd: Handle) -> (i64, Errno) {
+	s, err := _fstat(fd)
+	if err != ERROR_NONE {
+		return -1, err
+	}
+	return s.size, ERROR_NONE
+}
+
+rename :: proc(old_path, new_path: string) -> Errno {
+	old_path_cstr := strings.clone_to_cstring(old_path, context.temp_allocator)
+	new_path_cstr := strings.clone_to_cstring(new_path, context.temp_allocator)
+	res := _unix_rename(old_path_cstr, new_path_cstr)
+	if res == -1 {
+		return Errno(get_last_error())
+	}
+	return ERROR_NONE
+}
+
+remove :: proc(path: string) -> Errno {
+	path_cstr := strings.clone_to_cstring(path, context.temp_allocator)
+	res := _unix_unlink(path_cstr)
+	if res == -1 {
+		return Errno(get_last_error())
+	}
+	return ERROR_NONE
+}
+
+make_directory :: proc(path: string, mode: mode_t = 0o775) -> Errno {
+	path_cstr := strings.clone_to_cstring(path, context.temp_allocator)
+	res := _unix_mkdir(path_cstr, mode)
+	if res == -1 {
+		return Errno(get_last_error())
+	}
+	return ERROR_NONE
+}
+
+remove_directory :: proc(path: string) -> Errno {
+	path_cstr := strings.clone_to_cstring(path, context.temp_allocator)
+	res := _unix_rmdir(path_cstr)
+	if res == -1 {
+		return Errno(get_last_error())
+	}
+	return ERROR_NONE
+}
+
+is_file_handle :: proc(fd: Handle) -> bool {
+	s, err := _fstat(fd)
+	if err != ERROR_NONE {
+		return false
+	}
+	return S_ISREG(s.mode)
+}
+
+is_file_path :: proc(path: string, follow_links: bool = true) -> bool {
+	s: OS_Stat
+	err: Errno
+	if follow_links {
+		s, err = _stat(path)
+	} else {
+		s, err = _lstat(path)
+	}
+	if err != ERROR_NONE {
+		return false
+	}
+	return S_ISREG(s.mode)
+}
+
+is_dir_handle :: proc(fd: Handle) -> bool {
+	s, err := _fstat(fd)
+	if err != ERROR_NONE {
+		return false
+	}
+	return S_ISDIR(s.mode)
+}
+
+is_dir_path :: proc(path: string, follow_links: bool = true) -> bool {
+	s: OS_Stat
+	err: Errno
+	if follow_links {
+		s, err = _stat(path)
+	} else {
+		s, err = _lstat(path)
+	}
+	if err != ERROR_NONE {
+		return false
+	}
+	return S_ISDIR(s.mode)
+}
+
+is_file :: proc {is_file_path, is_file_handle}
+is_dir :: proc {is_dir_path, is_dir_handle}
+
+// NOTE(bill): Uses startup to initialize it
+
+stdin:  Handle = 0
+stdout: Handle = 1
+stderr: Handle = 2
+
+/* TODO(zangent): Implement these!                                                                                
+last_write_time :: proc(fd: Handle) -> File_Time {}                                                               
+last_write_time_by_name :: proc(name: string) -> File_Time {}                                                     
+*/
+last_write_time :: proc(fd: Handle) -> (File_Time, Errno) {
+	s, err := _fstat(fd)
+	if err != ERROR_NONE {
+		return 0, err
+	}
+	modified := s.modified.seconds * 1_000_000_000 + s.modified.nanoseconds
+	return File_Time(modified), ERROR_NONE
+}
+
+last_write_time_by_name :: proc(name: string) -> (File_Time, Errno) {
+	s, err := _stat(name)
+	if err != ERROR_NONE {
+		return 0, err
+	}
+	modified := s.modified.seconds * 1_000_000_000 + s.modified.nanoseconds
+	return File_Time(modified), ERROR_NONE
+}
+
+@private
+_stat :: proc(path: string) -> (OS_Stat, Errno) {
+	cstr := strings.clone_to_cstring(path, context.temp_allocator)
+
+	// deliberately uninitialized
+	s: OS_Stat = ---
+	res := _unix_stat(cstr, &s)
+	if res == -1 {
+		return s, Errno(get_last_error())
+	}
+	return s, ERROR_NONE
+}
+
+@private
+_lstat :: proc(path: string) -> (OS_Stat, Errno) {
+	cstr := strings.clone_to_cstring(path, context.temp_allocator)
+
+	// deliberately uninitialized
+	s: OS_Stat = ---
+	res := _unix_lstat(cstr, &s)
+	if res == -1 {
+		return s, Errno(get_last_error())
+	}
+	return s, ERROR_NONE
+}
+
+@private
+_fstat :: proc(fd: Handle) -> (OS_Stat, Errno) {
+	// deliberately uninitialized
+	s: OS_Stat = ---
+	res := _unix_fstat(fd, &s)
+	if res == -1 {
+		return s, Errno(get_last_error())
+	}
+	return s, ERROR_NONE
+}
+
+@private
+_fdopendir :: proc(fd: Handle) -> (Dir, Errno) {
+	dirp := _unix_fdopendir(fd)
+	if dirp == cast(Dir)nil {
+		return nil, Errno(get_last_error())
+	}
+	return dirp, ERROR_NONE
+}
+
+@private
+_closedir :: proc(dirp: Dir) -> Errno {
+	rc := _unix_closedir(dirp)
+	if rc != 0 {
+		return Errno(get_last_error())
+	}
+	return ERROR_NONE
+}
+
+@private
+_rewinddir :: proc(dirp: Dir) {
+	_unix_rewinddir(dirp)
+}
+
+@private
+_readdir :: proc(dirp: Dir) -> (entry: Dirent, err: Errno, end_of_stream: bool) {
+	result: ^Dirent
+	rc := _unix_readdir_r(dirp, &entry, &result)
+
+	if rc != 0 {
+		err = Errno(get_last_error())
+		return
+	}
+	err = ERROR_NONE
+
+	if result == nil {
+		end_of_stream = true
+		return
+	}
+
+	return
+}
+
+@private
+_readlink :: proc(path: string) -> (string, Errno) {
+	path_cstr := strings.clone_to_cstring(path, context.temp_allocator)
+
+	bufsz : uint = MAX_PATH
+	buf := make([]byte, MAX_PATH)
+	for {
+		rc := _unix_readlink(path_cstr, &(buf[0]), bufsz)
+		if rc == -1 {
+			delete(buf)
+			return "", Errno(get_last_error())
+		} else if rc == int(bufsz) {
+			bufsz += MAX_PATH
+			delete(buf)
+			buf = make([]byte, bufsz)
+		} else {
+			return strings.string_from_ptr(&buf[0], rc), ERROR_NONE
+		}	
+	}
+	unreachable()
+}
+
+// XXX OpenBSD
+absolute_path_from_handle :: proc(fd: Handle) -> (string, Errno) {
+	return "", Errno(ENOSYS)
+}
+
+absolute_path_from_relative :: proc(rel: string) -> (path: string, err: Errno) {
+	rel := rel
+	if rel == "" {
+		rel = "."
+	}
+
+	rel_cstr := strings.clone_to_cstring(rel, context.temp_allocator)
+
+	path_ptr := _unix_realpath(rel_cstr, nil)
+	if path_ptr == nil {
+		return "", Errno(get_last_error())
+	}
+	defer _unix_free(path_ptr)
+
+	path_cstr := transmute(cstring)path_ptr
+	path = strings.clone( string(path_cstr) )
+
+	return path, ERROR_NONE
+}
+
+access :: proc(path: string, mask: int) -> (bool, Errno) {
+	cstr := strings.clone_to_cstring(path, context.temp_allocator)
+	res := _unix_access(cstr, c.int(mask))
+	if res == -1 {
+		return false, Errno(get_last_error())
+	}
+	return true, ERROR_NONE
+}
+
+heap_alloc :: proc(size: int) -> rawptr {
+	assert(size >= 0)
+	return _unix_calloc(1, c.size_t(size))
+}
+
+heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
+	// NOTE: _unix_realloc doesn't guarantee new memory will be zeroed on
+	// POSIX platforms. Ensure your caller takes this into account.
+	return _unix_realloc(ptr, c.size_t(new_size))
+}
+
+heap_free :: proc(ptr: rawptr) {
+	_unix_free(ptr)
+}
+
+getenv :: proc(name: string) -> (string, bool) {
+	path_str := strings.clone_to_cstring(name, context.temp_allocator)
+	cstr := _unix_getenv(path_str)
+	if cstr == nil {
+		return "", false
+	}
+	return string(cstr), true
+}
+
+get_current_directory :: proc() -> string {
+	buf := make([dynamic]u8, MAX_PATH)
+	for {
+		cwd := _unix_getcwd(cstring(raw_data(buf)), c.size_t(len(buf)))
+		if cwd != nil {
+			return string(cwd)
+		}
+		if Errno(get_last_error()) != ERANGE {
+			return ""
+		}
+		resize(&buf, len(buf) + MAX_PATH)
+	}
+	unreachable()
+}
+
+set_current_directory :: proc(path: string) -> (err: Errno) {
+	cstr := strings.clone_to_cstring(path, context.temp_allocator)
+	res := _unix_chdir(cstr)
+	if res == -1 {
+		return Errno(get_last_error())
+	}
+	return ERROR_NONE
+}
+
+exit :: proc "contextless" (code: int) -> ! {
+	_unix_exit(c.int(code))
+}
+
+current_thread_id :: proc "contextless" () -> int {
+	return _unix_getthrid()
+}
+
+dlopen :: proc(filename: string, flags: int) -> rawptr {
+	cstr := strings.clone_to_cstring(filename, context.temp_allocator)
+	handle := _unix_dlopen(cstr, c.int(flags))
+	return handle
+}
+dlsym :: proc(handle: rawptr, symbol: string) -> rawptr {
+	assert(handle != nil)
+	cstr := strings.clone_to_cstring(symbol, context.temp_allocator)
+	proc_handle := _unix_dlsym(handle, cstr)
+	return proc_handle
+}
+dlclose :: proc(handle: rawptr) -> bool {
+	assert(handle != nil)
+	return _unix_dlclose(handle) == 0
+}
+dlerror :: proc() -> string {
+	return string(_unix_dlerror())
+}
+
+get_page_size :: proc() -> int {
+	// NOTE(tetra): The page size never changes, so why do anything complicated
+	// if we don't have to.
+	@static page_size := -1
+	if page_size != -1 {
+		return page_size
+	}
+
+	page_size = int(_unix_getpagesize())
+	return page_size
+}
+
+
+_alloc_command_line_arguments :: proc() -> []string {
+	res := make([]string, len(runtime.args__))
+	for arg, i in runtime.args__ {
+		res[i] = string(arg)
+	}
+	return res
+}
diff --git a/core/os/stat_unix.odin b/core/os/stat_unix.odin
index 08c6f53c4..2aa9fc283 100644
--- a/core/os/stat_unix.odin
+++ b/core/os/stat_unix.odin
@@ -1,4 +1,4 @@
-//+build linux, darwin, freebsd
+//+build linux, darwin, freebsd, openbsd
 package os
 
 import "core:time"
diff --git a/core/path/filepath/path_unix.odin b/core/path/filepath/path_unix.odin
index 3e49c4710..d0eaa3635 100644
--- a/core/path/filepath/path_unix.odin
+++ b/core/path/filepath/path_unix.odin
@@ -1,4 +1,4 @@
-//+build linux, darwin, freebsd
+//+build linux, darwin, freebsd, openbsd
 package filepath
 
 when ODIN_OS == .Darwin {
@@ -59,6 +59,11 @@ when ODIN_OS == .Darwin {
 	foreign libc {
 		@(link_name="__error")          __error :: proc() -> ^i32 ---
 	}
+} else when ODIN_OS == .OpenBSD {
+	@(private)
+	foreign libc {
+		@(link_name="__errno")		__error :: proc() -> ^i32 ---
+	}
 } else {
 	@(private)
 	foreign libc {
diff --git a/core/runtime/entry_unix.odin b/core/runtime/entry_unix.odin
index dd1e06625..1a3def200 100644
--- a/core/runtime/entry_unix.odin
+++ b/core/runtime/entry_unix.odin
@@ -1,5 +1,5 @@
 //+private
-//+build linux, darwin, freebsd
+//+build linux, darwin, freebsd, openbsd
 package runtime
 
 import "core:intrinsics"
diff --git a/core/sync/channel_unix.odin b/core/sync/channel_unix.odin
index d6bac2d71..47aa46004 100644
--- a/core/sync/channel_unix.odin
+++ b/core/sync/channel_unix.odin
@@ -1,4 +1,4 @@
-// +build linux, darwin, freebsd
+// +build linux, darwin, freebsd, openbsd
 package sync
 
 import "core:time"
diff --git a/core/sync/sync2/futex_openbsd.odin b/core/sync/sync2/futex_openbsd.odin
new file mode 100644
index 000000000..dbc80747b
--- /dev/null
+++ b/core/sync/sync2/futex_openbsd.odin
@@ -0,0 +1,78 @@
+//+private
+//+build openbsd
+package sync2
+
+import "core:c"
+import "core:os"
+import "core:time"
+
+FUTEX_WAIT :: 1
+FUTEX_WAKE :: 2
+
+FUTEX_PRIVATE_FLAG :: 128
+
+FUTEX_WAIT_PRIVATE :: (FUTEX_WAIT | FUTEX_PRIVATE_FLAG)
+FUTEX_WAKE_PRIVATE :: (FUTEX_WAKE | FUTEX_PRIVATE_FLAG)
+
+foreign import libc "system:c"
+
+foreign libc {
+	@(link_name="futex")
+	_unix_futex :: proc "c" (f: ^Futex, op: c.int, val: u32, timeout: rawptr) -> c.int ---
+}
+
+_futex_wait :: proc(f: ^Futex, expected: u32) -> bool {
+	res := _unix_futex(f, FUTEX_WAIT_PRIVATE, expected, nil)
+
+	if res != -1 {
+		return true
+	}
+
+	if os.Errno(os.get_last_error()) == os.ETIMEDOUT {
+		return false
+	}
+
+	panic("futex_wait failure")
+}
+
+_futex_wait_with_timeout :: proc(f: ^Futex, expected: u32, duration: time.Duration) -> bool {
+	if duration <= 0 {
+		return false
+	}
+
+	timespec_t :: struct {
+		tv_sec:  c.long,
+		tv_nsec: c.long,
+        }
+
+	res := _unix_futex(f, FUTEX_WAIT_PRIVATE, expected, &timespec_t{
+		tv_sec  = (c.long)(duration/1e9),
+		tv_nsec = (c.long)(duration%1e9),
+	})
+
+	if res != -1 {
+		return true
+	}
+
+	if os.Errno(os.get_last_error()) == os.ETIMEDOUT {
+		return false
+	}
+
+	panic("futex_wait_with_timeout failure")
+}
+
+_futex_signal :: proc(f: ^Futex) {
+	res := _unix_futex(f, FUTEX_WAKE_PRIVATE, 1, nil)
+
+	if res == -1 {
+		panic("futex_wake_single failure")
+	}
+}
+
+_futex_broadcast :: proc(f: ^Futex)  {
+	res := _unix_futex(f, FUTEX_WAKE_PRIVATE, u32(max(i32)), nil)
+
+	if res == -1 {
+		panic("_futex_wake_all failure")
+	}
+}
diff --git a/core/sync/sync2/primitives_openbsd.odin b/core/sync/sync2/primitives_openbsd.odin
new file mode 100644
index 000000000..ef122b02e
--- /dev/null
+++ b/core/sync/sync2/primitives_openbsd.odin
@@ -0,0 +1,9 @@
+//+build openbsd
+//+private
+package sync2
+
+import "core:os"
+
+_current_thread_id :: proc "contextless" () -> int {
+	return os.current_thread_id()
+}
diff --git a/core/sync/sync2/primitives_pthreads.odin b/core/sync/sync2/primitives_pthreads.odin
index 8d2c3986d..28053f9cc 100644
--- a/core/sync/sync2/primitives_pthreads.odin
+++ b/core/sync/sync2/primitives_pthreads.odin
@@ -1,4 +1,4 @@
-//+build linux, freebsd
+//+build linux, freebsd, openbsd
 //+private
 package sync2
 
diff --git a/core/sync/sync_openbsd.odin b/core/sync/sync_openbsd.odin
new file mode 100644
index 000000000..926655f5b
--- /dev/null
+++ b/core/sync/sync_openbsd.odin
@@ -0,0 +1,36 @@
+package sync
+
+import "core:sys/unix"
+import "core:os"
+
+current_thread_id :: proc "contextless" () -> int {
+	return os.current_thread_id()
+}
+
+// The Darwin docs say it best:
+// A semaphore is much like a lock, except that a finite number of threads can hold it simultaneously.
+// Semaphores can be thought of as being much like piles of tokens; multiple threads can take these tokens, 
+// but when there are none left, a thread must wait until another thread returns one.
+Semaphore :: struct #align 16 {
+	handle: unix.sem_t,
+}
+
+semaphore_init :: proc(s: ^Semaphore, initial_count := 0) {
+	assert(unix.sem_init(&s.handle, 0, u32(initial_count)) == 0)
+}
+
+semaphore_destroy :: proc(s: ^Semaphore) {
+	assert(unix.sem_destroy(&s.handle) == 0)
+	s.handle = {}
+}
+
+semaphore_post :: proc(s: ^Semaphore, count := 1) {
+    // NOTE: SPEED: If there's one syscall to do this, we should use it instead of the loop.
+    for in 0..<count {
+	    assert(unix.sem_post(&s.handle) == 0)
+    }
+}
+
+semaphore_wait_for :: proc(s: ^Semaphore) {
+	assert(unix.sem_wait(&s.handle) == 0)
+}
diff --git a/core/sync/sync_unix.odin b/core/sync/sync_unix.odin
index 114625483..b8e9d32cc 100644
--- a/core/sync/sync_unix.odin
+++ b/core/sync/sync_unix.odin
@@ -1,4 +1,4 @@
-// +build linux, darwin, freebsd
+// +build linux, darwin, freebsd, openbsd
 package sync
 
 import "core:sys/unix"
diff --git a/core/sys/unix/pthread_openbsd.odin b/core/sys/unix/pthread_openbsd.odin
new file mode 100644
index 000000000..c855f95c0
--- /dev/null
+++ b/core/sys/unix/pthread_openbsd.odin
@@ -0,0 +1,65 @@
+//+build openbsd
+package unix
+
+import "core:c"
+
+pthread_t             :: distinct rawptr
+pthread_attr_t        :: distinct rawptr
+pthread_mutex_t       :: distinct rawptr
+pthread_mutexattr_t   :: distinct rawptr
+pthread_cond_t        :: distinct rawptr
+pthread_condattr_t    :: distinct rawptr
+pthread_rwlock_t      :: distinct rawptr
+pthread_rwlockattr_t  :: distinct rawptr
+pthread_barrier_t     :: distinct rawptr
+pthread_barrierattr_t :: distinct rawptr
+pthread_spinlock_t    :: distinct rawptr
+
+pthread_key_t  :: distinct c.int
+pthread_once_t :: struct {
+	state: c.int,
+	mutex: pthread_mutex_t,
+}
+
+PTHREAD_MUTEX_ERRORCHECK :: 1
+PTHREAD_MUTEX_RECURSIVE  :: 2
+PTHREAD_MUTEX_NORMAL     :: 3
+PTHREAD_MUTEX_STRICT_NP  :: 4
+
+PTHREAD_DETACHED      :: 0x1
+PTHREAD_SCOPE_SYSTEM  :: 0x2
+PTHREAD_INHERIT_SCHED :: 0x4
+PTHREAD_NOFLOAT       :: 0x8
+
+PTHREAD_CREATE_DETACHED :: PTHREAD_DETACHED
+PTHREAD_CREATE_JOINABLE :: 0
+PTHREAD_SCOPE_PROCESS   :: 0
+PTHREAD_EXPLICIT_SCHED  :: 0
+
+SCHED_FIFO  :: 1
+SCHED_OTHER :: 2
+SCHED_RR    :: 3
+
+sched_param :: struct {
+	sched_priority: c.int,
+}
+
+sem_t :: distinct rawptr
+
+foreign import libc "system:c"
+
+@(default_calling_convention="c")
+foreign libc {
+	sem_open :: proc(name: cstring, flags: c.int) -> ^sem_t ---
+
+	sem_init :: proc(sem: ^sem_t, pshared: c.int, initial_value: c.uint) -> c.int ---
+	sem_destroy :: proc(sem: ^sem_t) -> c.int ---
+	sem_post :: proc(sem: ^sem_t) -> c.int ---
+	sem_wait :: proc(sem: ^sem_t) -> c.int ---
+	sem_trywait :: proc(sem: ^sem_t) -> c.int ---
+	//sem_timedwait :: proc(sem: ^sem_t, timeout: time.TimeSpec) -> c.int ---
+
+	// NOTE: unclear whether pthread_yield is well-supported on Linux systems,
+	// see https://linux.die.net/man/3/pthread_yield
+	pthread_yield :: proc() ---
+}
diff --git a/core/sys/unix/pthread_unix.odin b/core/sys/unix/pthread_unix.odin
index ccd8f7844..62e3701ab 100644
--- a/core/sys/unix/pthread_unix.odin
+++ b/core/sys/unix/pthread_unix.odin
@@ -1,4 +1,4 @@
-//+build linux, darwin, freebsd
+//+build linux, darwin, freebsd, openbsd
 package unix
 
 foreign import "system:pthread"
diff --git a/core/thread/thread_unix.odin b/core/thread/thread_unix.odin
index 6cb91df86..b6679bbc2 100644
--- a/core/thread/thread_unix.odin
+++ b/core/thread/thread_unix.odin
@@ -1,4 +1,4 @@
-// +build linux, darwin, freebsd
+// +build linux, darwin, freebsd, openbsd
 // +private
 package thread
 
diff --git a/core/time/time_unix.odin b/core/time/time_unix.odin
index 9c5c5cc35..37fc1fd3e 100644
--- a/core/time/time_unix.odin
+++ b/core/time/time_unix.odin
@@ -1,4 +1,4 @@
-//+build linux, darwin, freebsd
+//+build linux, darwin, freebsd, openbsd
 package time
 
 IS_SUPPORTED :: true // NOTE: Times on Darwin are UTC.
@@ -22,16 +22,28 @@ TimeSpec :: struct {
 	tv_nsec : i64,  /* nanoseconds */
 }
 
-CLOCK_REALTIME           :: 0 // NOTE(tetra): May jump in time, when user changes the system time.
-CLOCK_MONOTONIC          :: 1 // NOTE(tetra): May stand still while system is asleep.
-CLOCK_PROCESS_CPUTIME_ID :: 2
-CLOCK_THREAD_CPUTIME_ID  :: 3
-CLOCK_MONOTONIC_RAW      :: 4 // NOTE(tetra): "RAW" means: Not adjusted by NTP.
-CLOCK_REALTIME_COARSE    :: 5 // NOTE(tetra): "COARSE" clocks are apparently much faster, but not "fine-grained."
-CLOCK_MONOTONIC_COARSE   :: 6
-CLOCK_BOOTTIME           :: 7 // NOTE(tetra): Same as MONOTONIC, except also including time system was asleep.
-CLOCK_REALTIME_ALARM     :: 8
-CLOCK_BOOTTIME_ALARM     :: 9
+when ODIN_OS == .OpenBSD {
+	CLOCK_REALTIME           :: 0
+	CLOCK_PROCESS_CPUTIME_ID :: 2
+	CLOCK_MONOTONIC          :: 3
+	CLOCK_THREAD_CPUTIME_ID  :: 4
+	CLOCK_UPTIME             :: 5
+	CLOCK_BOOTTIME           :: 6
+
+	// CLOCK_MONOTONIC_RAW doesn't exist, use CLOCK_MONOTONIC
+	CLOCK_MONOTONIC_RAW :: CLOCK_MONOTONIC
+} else {
+	CLOCK_REALTIME           :: 0 // NOTE(tetra): May jump in time, when user changes the system time.
+	CLOCK_MONOTONIC          :: 1 // NOTE(tetra): May stand still while system is asleep.
+	CLOCK_PROCESS_CPUTIME_ID :: 2
+	CLOCK_THREAD_CPUTIME_ID  :: 3
+	CLOCK_MONOTONIC_RAW      :: 4 // NOTE(tetra): "RAW" means: Not adjusted by NTP.
+	CLOCK_REALTIME_COARSE    :: 5 // NOTE(tetra): "COARSE" clocks are apparently much faster, but not "fine-grained."
+	CLOCK_MONOTONIC_COARSE   :: 6
+	CLOCK_BOOTTIME           :: 7 // NOTE(tetra): Same as MONOTONIC, except also including time system was asleep.
+	CLOCK_REALTIME_ALARM     :: 8
+	CLOCK_BOOTTIME_ALARM     :: 9
+}
 
 // TODO(tetra, 2019-11-05): The original implementation of this package for Darwin used this constants.
 // I do not know if Darwin programmers are used to the existance of these constants or not, so
diff --git a/src/bug_report.cpp b/src/bug_report.cpp
index 4dd251f24..7f6b668e8 100644
--- a/src/bug_report.cpp
+++ b/src/bug_report.cpp
@@ -17,6 +17,10 @@
 	#include <sys/sysctl.h>
 #endif
 
+#if defined(GB_SYSTEM_OPENBSD)
+	#include <sys/utsname.h>
+#endif
+
 /*
 	NOTE(Jeroen): This prints the Windows product edition only, to be called from `print_platform_details`.
 */
@@ -643,6 +647,14 @@ void print_bug_report_help() {
 		} else {
 			gb_printf("macOS: Unknown\n");
 		}			
+	#elif defined(GB_SYSTEM_OPENBSD)
+		struct utsname un;
+		
+		if (uname(&un) != -1) {
+			gb_printf("%s %s %s %s\n", un.sysname, un.release, un.version, un.machine);
+		} else {
+			gb_printf("OpenBSD: Unknown\n");    
+		}
 	#else
 		gb_printf("Unknown\n");
 
@@ -657,4 +669,4 @@ void print_bug_report_help() {
 		And RAM info.
 	*/
 	report_ram_info();
-}
\ No newline at end of file
+}
diff --git a/src/build_settings.cpp b/src/build_settings.cpp
index 610e4f847..72a4b35cc 100644
--- a/src/build_settings.cpp
+++ b/src/build_settings.cpp
@@ -16,6 +16,7 @@ enum TargetOsKind {
 	TargetOs_linux,
 	TargetOs_essence,
 	TargetOs_freebsd,
+	TargetOs_openbsd,
 	
 	TargetOs_wasi,
 	TargetOs_js,
@@ -53,6 +54,7 @@ String target_os_names[TargetOs_COUNT] = {
 	str_lit("linux"),
 	str_lit("essence"),
 	str_lit("freebsd"),
+	str_lit("openbsd"),
 	
 	str_lit("wasi"),
 	str_lit("js"),
@@ -354,6 +356,15 @@ gb_global TargetMetrics target_freebsd_amd64 = {
 	str_lit("e-m:w-i64:64-f80:128-n8:16:32:64-S128"),
 };
 
+gb_global TargetMetrics target_openbsd_amd64 = {
+	TargetOs_openbsd,
+	TargetArch_amd64,
+	8,
+	16,
+	str_lit("x86_64-unknown-openbsd-elf"),
+	str_lit("e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"),
+};
+
 gb_global TargetMetrics target_essence_amd64 = {
 	TargetOs_essence,
 	TargetArch_amd64,
@@ -417,6 +428,7 @@ gb_global NamedTargetMetrics named_targets[] = {
 	{ str_lit("windows_amd64"),       &target_windows_amd64  },
 	{ str_lit("freebsd_386"),         &target_freebsd_386    },
 	{ str_lit("freebsd_amd64"),       &target_freebsd_amd64  },
+	{ str_lit("openbsd_amd64"),       &target_openbsd_amd64  },
 	{ str_lit("freestanding_wasm32"), &target_freestanding_wasm32 },
 	{ str_lit("wasi_wasm32"),         &target_wasi_wasm32 },
 	{ str_lit("js_wasm32"),           &target_js_wasm32 },
@@ -723,6 +735,7 @@ String internal_odin_root_dir(void) {
 #elif defined(GB_SYSTEM_DRAGONFLYBSD)
 		len = readlink("/proc/curproc/file", &path_buf[0], path_buf.count);
 #else
+		// XXX OpenBSD
 		len = readlink("/proc/self/exe", &path_buf[0], path_buf.count);
 #endif
 		if(len == 0) {
@@ -922,6 +935,8 @@ void init_build_context(TargetMetrics *cross_target) {
 			#endif
 		#elif defined(GB_SYSTEM_FREEBSD)
 			metrics = &target_freebsd_amd64;
+		#elif defined(GB_SYSTEM_OPENBSD)
+			metrics = &target_openbsd_amd64;
 		#elif defined(GB_CPU_ARM)
 			metrics = &target_linux_arm64;
 		#else
@@ -980,6 +995,9 @@ void init_build_context(TargetMetrics *cross_target) {
 		case TargetOs_freebsd:
 			bc->link_flags = str_lit("-arch x86-64 ");
 			break;
+		case TargetOs_openbsd:
+			bc->link_flags = str_lit("-arch x86-64 ");
+			break;
 		}
 	} else if (bc->metrics.arch == TargetArch_i386) {
 		switch (bc->metrics.os) {
diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp
index eb9d7f293..69cc40de8 100644
--- a/src/check_builtin.cpp
+++ b/src/check_builtin.cpp
@@ -3506,6 +3506,7 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32
 			case TargetOs_linux:
 			case TargetOs_essence:
 			case TargetOs_freebsd:
+			case TargetOs_openbsd:
 				switch (build_context.metrics.arch) {
 				case TargetArch_i386:
 				case TargetArch_amd64:
diff --git a/src/checker.cpp b/src/checker.cpp
index f440b7c9a..5a7ece263 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -906,6 +906,7 @@ void init_universal(void) {
 			{"Linux",        TargetOs_linux},
 			{"Essence",      TargetOs_essence},
 			{"FreeBSD",      TargetOs_freebsd},
+			{"OpenBSD",      TargetOs_openbsd},
 			{"WASI",         TargetOs_wasi},
 			{"JS",           TargetOs_js},
 			{"Freestanding", TargetOs_freestanding},
diff --git a/src/common.cpp b/src/common.cpp
index d3ee95b76..aaacda04b 100644
--- a/src/common.cpp
+++ b/src/common.cpp
@@ -848,7 +848,7 @@ ReadDirectoryError read_directory(String path, Array<FileInfo> *fi) {
 
 	return ReadDirectory_None;
 }
-#elif defined(GB_SYSTEM_LINUX) || defined(GB_SYSTEM_OSX) || defined(GB_SYSTEM_FREEBSD)
+#elif defined(GB_SYSTEM_LINUX) || defined(GB_SYSTEM_OSX) || defined(GB_SYSTEM_FREEBSD) || defined(GB_SYSTEM_OPENBSD)
 
 #include <dirent.h>
 
diff --git a/src/gb/gb.h b/src/gb/gb.h
index a9d6378c9..293e5063a 100644
--- a/src/gb/gb.h
+++ b/src/gb/gb.h
@@ -79,6 +79,10 @@ extern "C" {
 		#ifndef GB_SYSTEM_FREEBSD
 		#define GB_SYSTEM_FREEBSD 1
 		#endif
+	#elif defined(__OpenBSD__)
+		#ifndef GB_SYSTEM_OPENBSD
+		#define GB_SYSTEM_OPENBSD 1
+		#endif
 	#else
 		#error This UNIX operating system is not supported
 	#endif
@@ -199,7 +203,7 @@ extern "C" {
 	#endif
 	#include <stdlib.h> // NOTE(bill): malloc on linux
 	#include <sys/mman.h>
-	#if !defined(GB_SYSTEM_OSX) && !defined(__FreeBSD__)
+	#if !defined(GB_SYSTEM_OSX) && !defined(__FreeBSD__) && !defined(__OpenBSD__)
 		#include <sys/sendfile.h>
 	#endif
 	#include <sys/stat.h>
@@ -235,6 +239,15 @@ extern "C" {
 	#define sendfile(out, in, offset, count) sendfile(out, in, offset, count, NULL, NULL, 0)
 #endif
 
+#if defined(GB_SYSTEM_OPENBSD)
+	#include <stdio.h>
+	#include <pthread_np.h>
+	#define lseek64 lseek
+
+	// XXX OpenBSD
+	#define sendfile(out, in, offset, count) (-1)
+#endif
+    
 #if defined(GB_SYSTEM_UNIX)
 	#include <semaphore.h>
 #endif
@@ -783,6 +796,13 @@ typedef struct gbAffinity {
 	isize thread_count;
 	isize threads_per_core;
 } gbAffinity;
+#elif defined(GB_SYSTEM_OPENBSD)
+typedef struct gbAffinity {
+	b32   is_accurate;
+	isize core_count;
+	isize thread_count;
+	isize threads_per_core;
+} gbAffinity;
 #else
 #error TODO(bill): Unknown system
 #endif
@@ -3678,6 +3698,30 @@ b32 gb_affinity_set(gbAffinity *a, isize core, isize thread_index) {
 	return true;
 }
 
+isize gb_affinity_thread_count_for_core(gbAffinity *a, isize core) {
+	GB_ASSERT(0 <= core && core < a->core_count);
+	return a->threads_per_core;
+}
+
+#elif defined(GB_SYSTEM_OPENBSD)
+#include <unistd.h>
+
+void gb_affinity_init(gbAffinity *a) {
+	a->core_count       = sysconf(_SC_NPROCESSORS_ONLN);
+	a->threads_per_core = 1;
+	a->is_accurate      = a->core_count > 0;
+	a->core_count       = a->is_accurate ? a->core_count : 1;
+	a->thread_count     = a->core_count;
+}
+
+void gb_affinity_destroy(gbAffinity *a) {
+	gb_unused(a);
+}
+
+b32 gb_affinity_set(gbAffinity *a, isize core, isize thread_index) {
+	return true;
+}
+
 isize gb_affinity_thread_count_for_core(gbAffinity *a, isize core) {
 	GB_ASSERT(0 <= core && core < a->core_count);
 	return a->threads_per_core;
diff --git a/src/threading.cpp b/src/threading.cpp
index 50d0dfed1..63e3415b2 100644
--- a/src/threading.cpp
+++ b/src/threading.cpp
@@ -486,7 +486,7 @@ void thread_set_name(Thread *t, char const *name) {
 #elif defined(GB_SYSTEM_OSX)
 	// TODO(bill): Test if this works
 	pthread_setname_np(name);
-#elif defined(GB_SYSTEM_FREEBSD)
+#elif defined(GB_SYSTEM_FREEBSD) || defined(GB_SYSTEM_OPENBSD)
 	pthread_set_name_np(t->posix_handle, name);
 #else
 	// TODO(bill): Test if this works
-- 
cgit v1.2.3


From 37bba4c0a6b98f38a3160c9508bc55a6cb8ea7f1 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 28 Feb 2022 12:45:19 +0000
Subject: Reorganize error check procedures

---
 core/runtime/error_checks.odin | 317 ++++++++++++++++++++---------------------
 1 file changed, 157 insertions(+), 160 deletions(-)

(limited to 'core/runtime')

diff --git a/core/runtime/error_checks.odin b/core/runtime/error_checks.odin
index ad6902e2d..e4dd96d32 100644
--- a/core/runtime/error_checks.odin
+++ b/core/runtime/error_checks.odin
@@ -17,6 +17,23 @@ type_assertion_trap :: proc "contextless" () -> ! {
 }
 
 
+bounds_check_error_loc :: #force_inline proc "contextless" (using loc := #caller_location, index, count: int) {
+	bounds_check_error(file_path, line, column, index, count)
+}
+
+slice_expr_error_hi_loc :: #force_inline proc "contextless" (using loc := #caller_location, hi: int, len: int) {
+	slice_expr_error_hi(file_path, line, column, hi, len)
+}
+
+slice_expr_error_lo_hi_loc :: #force_inline proc "contextless" (using loc := #caller_location, lo, hi: int, len: int) {
+	slice_expr_error_lo_hi(file_path, line, column, lo, hi, len)
+}
+
+dynamic_array_expr_error_loc :: #force_inline proc "contextless" (using loc := #caller_location, low, high, max: int) {
+	dynamic_array_expr_error(file_path, line, column, low, high, max)
+}
+
+
 when ODIN_FOREIGN_ERROR_PROCEDURES {
 	foreign {
 		bounds_check_error               :: proc "contextless" (file: string, line, column: i32, index, count: int) ---
@@ -29,182 +46,182 @@ when ODIN_FOREIGN_ERROR_PROCEDURES {
 		matrix_bounds_check_error        :: proc "contextless" (file: string, line, column: i32, row_index, column_index, row_count, column_count: int) ---
 		type_assertion_check             :: proc "contextless" (ok: bool, file: string, line, column: i32, from, to: typeid) ---
 		type_assertion_check2            :: proc "contextless" (ok: bool, file: string, line, column: i32, from, to: typeid, from_data: rawptr) ---
-		make_slice_error_loc             :: proc "contextless" (loc := #caller_location, len: int) ---
-		make_dynamic_array_error_loc     :: proc "contextless" (using loc := #caller_location, len, cap: int) ---
-		make_map_expr_error_loc          :: proc "contextless" (loc := #caller_location, cap: int) ---
 	}
 } else {
-
-bounds_check_error :: proc "contextless" (file: string, line, column: i32, index, count: int) {
-	if 0 <= index && index < count {
-		return
+	bounds_check_error :: proc "contextless" (file: string, line, column: i32, index, count: int) {
+		if 0 <= index && index < count {
+			return
+		}
+		handle_error :: proc "contextless" (file: string, line, column: i32, index, count: int) {
+			print_caller_location(Source_Code_Location{file, line, column, ""})
+			print_string(" Index ")
+			print_i64(i64(index))
+			print_string(" is out of range 0..<")
+			print_i64(i64(count))
+			print_byte('\n')
+			bounds_trap()
+		}
+		handle_error(file, line, column, index, count)
 	}
-	handle_error :: proc "contextless" (file: string, line, column: i32, index, count: int) {
+
+	slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int, len: int) -> ! {
 		print_caller_location(Source_Code_Location{file, line, column, ""})
-		print_string(" Index ")
-		print_i64(i64(index))
+		print_string(" Invalid slice indices ")
+		print_i64(i64(lo))
+		print_string(":")
+		print_i64(i64(hi))
 		print_string(" is out of range 0..<")
-		print_i64(i64(count))
+		print_i64(i64(len))
 		print_byte('\n')
 		bounds_trap()
 	}
-	handle_error(file, line, column, index, count)
-}
-
-slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int, len: int) -> ! {
-	print_caller_location(Source_Code_Location{file, line, column, ""})
-	print_string(" Invalid slice indices ")
-	print_i64(i64(lo))
-	print_string(":")
-	print_i64(i64(hi))
-	print_string(" is out of range 0..<")
-	print_i64(i64(len))
-	print_byte('\n')
-	bounds_trap()
-}
-
-multi_pointer_slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int) -> ! {
-	print_caller_location(Source_Code_Location{file, line, column, ""})
-	print_string(" Invalid slice indices ")
-	print_i64(i64(lo))
-	print_string(":")
-	print_i64(i64(hi))
-	print_byte('\n')
-	bounds_trap()
-}
-
-
-multi_pointer_slice_expr_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int) {
-	if lo <= hi {
-		return
-	}
-	multi_pointer_slice_handle_error(file, line, column, lo, hi)
-}
-
-slice_expr_error_hi :: proc "contextless" (file: string, line, column: i32, hi: int, len: int) {
-	if 0 <= hi && hi <= len {
-		return
-	}
-	slice_handle_error(file, line, column, 0, hi, len)
-}
 
-slice_expr_error_lo_hi :: proc "contextless" (file: string, line, column: i32, lo, hi: int, len: int) {
-	if 0 <= lo && lo <= len && lo <= hi && hi <= len {
-		return
-	}
-	slice_handle_error(file, line, column, lo, hi, len)
-}
-
-dynamic_array_expr_error :: proc "contextless" (file: string, line, column: i32, low, high, max: int) {
-	if 0 <= low && low <= high && high <= max {
-		return
-	}
-	handle_error :: proc "contextless" (file: string, line, column: i32, low, high, max: int) {
+	multi_pointer_slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int) -> ! {
 		print_caller_location(Source_Code_Location{file, line, column, ""})
-		print_string(" Invalid dynamic array indices ")
-		print_i64(i64(low))
+		print_string(" Invalid slice indices ")
+		print_i64(i64(lo))
 		print_string(":")
-		print_i64(i64(high))
-		print_string(" is out of range 0..<")
-		print_i64(i64(max))
+		print_i64(i64(hi))
 		print_byte('\n')
 		bounds_trap()
 	}
-	handle_error(file, line, column, low, high, max)
-}
 
 
-matrix_bounds_check_error :: proc "contextless" (file: string, line, column: i32, row_index, column_index, row_count, column_count: int) {
-	if 0 <= row_index && row_index < row_count && 
-	   0 <= column_index && column_index < column_count {
-		return
+	multi_pointer_slice_expr_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int) {
+		if lo <= hi {
+			return
+		}
+		multi_pointer_slice_handle_error(file, line, column, lo, hi)
 	}
-	handle_error :: proc "contextless" (file: string, line, column: i32, row_index, column_index, row_count, column_count: int) {
-		print_caller_location(Source_Code_Location{file, line, column, ""})
-		print_string(" Matrix indices [")
-		print_i64(i64(row_index))
-		print_string(", ")
-		print_i64(i64(column_index))
-		print_string(" is out of range [0..<")
-		print_i64(i64(row_count))
-		print_string(", 0..<")
-		print_i64(i64(column_count))
-		print_string("]")
-		print_byte('\n')
-		bounds_trap()
+
+	slice_expr_error_hi :: proc "contextless" (file: string, line, column: i32, hi: int, len: int) {
+		if 0 <= hi && hi <= len {
+			return
+		}
+		slice_handle_error(file, line, column, 0, hi, len)
 	}
-	handle_error(file, line, column, row_index, column_index, row_count, column_count)
-}
 
+	slice_expr_error_lo_hi :: proc "contextless" (file: string, line, column: i32, lo, hi: int, len: int) {
+		if 0 <= lo && lo <= len && lo <= hi && hi <= len {
+			return
+		}
+		slice_handle_error(file, line, column, lo, hi, len)
+	}
 
-type_assertion_check :: proc "contextless" (ok: bool, file: string, line, column: i32, from, to: typeid) {
-	if ok {
-		return
+	dynamic_array_expr_error :: proc "contextless" (file: string, line, column: i32, low, high, max: int) {
+		if 0 <= low && low <= high && high <= max {
+			return
+		}
+		handle_error :: proc "contextless" (file: string, line, column: i32, low, high, max: int) {
+			print_caller_location(Source_Code_Location{file, line, column, ""})
+			print_string(" Invalid dynamic array indices ")
+			print_i64(i64(low))
+			print_string(":")
+			print_i64(i64(high))
+			print_string(" is out of range 0..<")
+			print_i64(i64(max))
+			print_byte('\n')
+			bounds_trap()
+		}
+		handle_error(file, line, column, low, high, max)
 	}
-	handle_error :: proc "contextless" (file: string, line, column: i32, from, to: typeid) {
-		print_caller_location(Source_Code_Location{file, line, column, ""})
-		print_string(" Invalid type assertion from ")
-		print_typeid(from)
-		print_string(" to ")
-		print_typeid(to)
-		print_byte('\n')
-		type_assertion_trap()
+
+
+	matrix_bounds_check_error :: proc "contextless" (file: string, line, column: i32, row_index, column_index, row_count, column_count: int) {
+		if 0 <= row_index && row_index < row_count &&
+		   0 <= column_index && column_index < column_count {
+			return
+		}
+		handle_error :: proc "contextless" (file: string, line, column: i32, row_index, column_index, row_count, column_count: int) {
+			print_caller_location(Source_Code_Location{file, line, column, ""})
+			print_string(" Matrix indices [")
+			print_i64(i64(row_index))
+			print_string(", ")
+			print_i64(i64(column_index))
+			print_string(" is out of range [0..<")
+			print_i64(i64(row_count))
+			print_string(", 0..<")
+			print_i64(i64(column_count))
+			print_string("]")
+			print_byte('\n')
+			bounds_trap()
+		}
+		handle_error(file, line, column, row_index, column_index, row_count, column_count)
 	}
-	handle_error(file, line, column, from, to)
-}
 
-type_assertion_check2 :: proc "contextless" (ok: bool, file: string, line, column: i32, from, to: typeid, from_data: rawptr) {
-	if ok {
-		return
+
+	type_assertion_check :: proc "contextless" (ok: bool, file: string, line, column: i32, from, to: typeid) {
+		if ok {
+			return
+		}
+		handle_error :: proc "contextless" (file: string, line, column: i32, from, to: typeid) {
+			print_caller_location(Source_Code_Location{file, line, column, ""})
+			print_string(" Invalid type assertion from ")
+			print_typeid(from)
+			print_string(" to ")
+			print_typeid(to)
+			print_byte('\n')
+			type_assertion_trap()
+		}
+		handle_error(file, line, column, from, to)
 	}
 
-	variant_type :: proc "contextless" (id: typeid, data: rawptr) -> typeid {
-		if id == nil || data == nil {
-			return id
+	type_assertion_check2 :: proc "contextless" (ok: bool, file: string, line, column: i32, from, to: typeid, from_data: rawptr) {
+		if ok {
+			return
 		}
-		ti := type_info_base(type_info_of(id))
-		#partial switch v in ti.variant {
-		case Type_Info_Any:
-			return (^any)(data).id
-		case Type_Info_Union:
-			tag_ptr := uintptr(data) + v.tag_offset
-			idx := 0
-			switch v.tag_type.size {
-			case 1:  idx = int((^u8)(tag_ptr)^)   - 1
-			case 2:  idx = int((^u16)(tag_ptr)^)  - 1
-			case 4:  idx = int((^u32)(tag_ptr)^)  - 1
-			case 8:  idx = int((^u64)(tag_ptr)^)  - 1
-			case 16: idx = int((^u128)(tag_ptr)^) - 1
+
+		variant_type :: proc "contextless" (id: typeid, data: rawptr) -> typeid {
+			if id == nil || data == nil {
+				return id
 			}
-			if idx < 0 {
-				return nil
-			} else if idx < len(v.variants) {
-				return v.variants[idx].id
+			ti := type_info_base(type_info_of(id))
+			#partial switch v in ti.variant {
+			case Type_Info_Any:
+				return (^any)(data).id
+			case Type_Info_Union:
+				tag_ptr := uintptr(data) + v.tag_offset
+				idx := 0
+				switch v.tag_type.size {
+				case 1:  idx = int((^u8)(tag_ptr)^)   - 1
+				case 2:  idx = int((^u16)(tag_ptr)^)  - 1
+				case 4:  idx = int((^u32)(tag_ptr)^)  - 1
+				case 8:  idx = int((^u64)(tag_ptr)^)  - 1
+				case 16: idx = int((^u128)(tag_ptr)^) - 1
+				}
+				if idx < 0 {
+					return nil
+				} else if idx < len(v.variants) {
+					return v.variants[idx].id
+				}
 			}
+			return id
 		}
-		return id
-	}
 
-	handle_error :: proc "contextless" (file: string, line, column: i32, from, to: typeid, from_data: rawptr) {
+		handle_error :: proc "contextless" (file: string, line, column: i32, from, to: typeid, from_data: rawptr) {
 
-		actual := variant_type(from, from_data)
+			actual := variant_type(from, from_data)
 
-		print_caller_location(Source_Code_Location{file, line, column, ""})
-		print_string(" Invalid type assertion from ")
-		print_typeid(from)
-		print_string(" to ")
-		print_typeid(to)
-		if actual != from {
-			print_string(", actual type: ")
-			print_typeid(actual)
+			print_caller_location(Source_Code_Location{file, line, column, ""})
+			print_string(" Invalid type assertion from ")
+			print_typeid(from)
+			print_string(" to ")
+			print_typeid(to)
+			if actual != from {
+				print_string(", actual type: ")
+				print_typeid(actual)
+			}
+			print_byte('\n')
+			type_assertion_trap()
 		}
-		print_byte('\n')
-		type_assertion_trap()
+		handle_error(file, line, column, from, to, from_data)
 	}
-	handle_error(file, line, column, from, to, from_data)
 }
 
 
+// `make` related procedures below
+
+
 make_slice_error_loc :: #force_inline proc "contextless" (loc := #caller_location, len: int) {
 	if 0 <= len {
 		return
@@ -219,7 +236,7 @@ make_slice_error_loc :: #force_inline proc "contextless" (loc := #caller_locatio
 	handle_error(loc, len)
 }
 
-make_dynamic_array_error_loc :: #force_inline proc "contextless" (using loc := #caller_location, len, cap: int) {
+make_dynamic_array_error_loc :: #force_inline proc "contextless" (loc := #caller_location, len, cap: int) {
 	if 0 <= len && len <= cap {
 		return
 	}
@@ -248,23 +265,3 @@ make_map_expr_error_loc :: #force_inline proc "contextless" (loc := #caller_loca
 	}
 	handle_error(loc, cap)
 }
-
-}
-
-
-
-bounds_check_error_loc :: #force_inline proc "contextless" (using loc := #caller_location, index, count: int) {
-	bounds_check_error(file_path, line, column, index, count)
-}
-
-slice_expr_error_hi_loc :: #force_inline proc "contextless" (using loc := #caller_location, hi: int, len: int) {
-	slice_expr_error_hi(file_path, line, column, hi, len)
-}
-
-slice_expr_error_lo_hi_loc :: #force_inline proc "contextless" (using loc := #caller_location, lo, hi: int, len: int) {
-	slice_expr_error_lo_hi(file_path, line, column, lo, hi, len)
-}
-
-dynamic_array_expr_error_loc :: #force_inline proc "contextless" (using loc := #caller_location, low, high, max: int) {
-	dynamic_array_expr_error(file_path, line, column, low, high, max)
-}
-- 
cgit v1.2.3


From 3c72cb67d3f031a71152aadc480f5838d1833228 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 28 Feb 2022 13:00:32 +0000
Subject: Remove `context.user_data`

---
 core/runtime/core.odin | 1 -
 1 file changed, 1 deletion(-)

(limited to 'core/runtime')

diff --git a/core/runtime/core.odin b/core/runtime/core.odin
index 229d70417..8d315a238 100644
--- a/core/runtime/core.odin
+++ b/core/runtime/core.odin
@@ -351,7 +351,6 @@ Context :: struct {
 	assertion_failure_proc: Assertion_Failure_Proc,
 	logger:                 Logger,
 
-	user_data:  any,
 	user_ptr:   rawptr,
 	user_index: int,
 
-- 
cgit v1.2.3


From 01162e08b55406578a2972d74c472de8a14f12b8 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 28 Feb 2022 13:35:29 +0000
Subject: Add `-disallow-rtti`

---
 core/runtime/core.odin         |  20 ++--
 core/runtime/error_checks.odin | 225 ++++++++++++++++++++++-------------------
 core/runtime/print.odin        |  16 ++-
 3 files changed, 146 insertions(+), 115 deletions(-)

(limited to 'core/runtime')

diff --git a/core/runtime/core.odin b/core/runtime/core.odin
index 8d315a238..83a5418ed 100644
--- a/core/runtime/core.odin
+++ b/core/runtime/core.odin
@@ -508,16 +508,18 @@ __type_info_of :: proc "contextless" (id: typeid) -> ^Type_Info #no_bounds_check
 	return &type_table[n]
 }
 
-typeid_base :: proc "contextless" (id: typeid) -> typeid {
-	ti := type_info_of(id)
-	ti = type_info_base(ti)
-	return ti.id
-}
-typeid_core :: proc "contextless" (id: typeid) -> typeid {
-	ti := type_info_core(type_info_of(id))
-	return ti.id
+when !ODIN_DISALLOW_RTTI {
+	typeid_base :: proc "contextless" (id: typeid) -> typeid {
+		ti := type_info_of(id)
+		ti = type_info_base(ti)
+		return ti.id
+	}
+	typeid_core :: proc "contextless" (id: typeid) -> typeid {
+		ti := type_info_core(type_info_of(id))
+		return ti.id
+	}
+	typeid_base_without_enum :: typeid_core
 }
-typeid_base_without_enum :: typeid_core
 
 
 
diff --git a/core/runtime/error_checks.odin b/core/runtime/error_checks.odin
index e4dd96d32..0d0b39072 100644
--- a/core/runtime/error_checks.odin
+++ b/core/runtime/error_checks.odin
@@ -17,143 +17,143 @@ type_assertion_trap :: proc "contextless" () -> ! {
 }
 
 
-bounds_check_error_loc :: #force_inline proc "contextless" (using loc := #caller_location, index, count: int) {
-	bounds_check_error(file_path, line, column, index, count)
+bounds_check_error :: proc "contextless" (file: string, line, column: i32, index, count: int) {
+	if 0 <= index && index < count {
+		return
+	}
+	@(cold)
+	handle_error :: proc "contextless" (file: string, line, column: i32, index, count: int) {
+		print_caller_location(Source_Code_Location{file, line, column, ""})
+		print_string(" Index ")
+		print_i64(i64(index))
+		print_string(" is out of range 0..<")
+		print_i64(i64(count))
+		print_byte('\n')
+		bounds_trap()
+	}
+	handle_error(file, line, column, index, count)
 }
 
-slice_expr_error_hi_loc :: #force_inline proc "contextless" (using loc := #caller_location, hi: int, len: int) {
-	slice_expr_error_hi(file_path, line, column, hi, len)
+slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int, len: int) -> ! {
+	print_caller_location(Source_Code_Location{file, line, column, ""})
+	print_string(" Invalid slice indices ")
+	print_i64(i64(lo))
+	print_string(":")
+	print_i64(i64(hi))
+	print_string(" is out of range 0..<")
+	print_i64(i64(len))
+	print_byte('\n')
+	bounds_trap()
 }
 
-slice_expr_error_lo_hi_loc :: #force_inline proc "contextless" (using loc := #caller_location, lo, hi: int, len: int) {
-	slice_expr_error_lo_hi(file_path, line, column, lo, hi, len)
+multi_pointer_slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int) -> ! {
+	print_caller_location(Source_Code_Location{file, line, column, ""})
+	print_string(" Invalid slice indices ")
+	print_i64(i64(lo))
+	print_string(":")
+	print_i64(i64(hi))
+	print_byte('\n')
+	bounds_trap()
 }
 
-dynamic_array_expr_error_loc :: #force_inline proc "contextless" (using loc := #caller_location, low, high, max: int) {
-	dynamic_array_expr_error(file_path, line, column, low, high, max)
-}
 
+multi_pointer_slice_expr_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int) {
+	if lo <= hi {
+		return
+	}
+	multi_pointer_slice_handle_error(file, line, column, lo, hi)
+}
 
-when ODIN_FOREIGN_ERROR_PROCEDURES {
-	foreign {
-		bounds_check_error               :: proc "contextless" (file: string, line, column: i32, index, count: int) ---
-		slice_handle_error               :: proc "contextless" (file: string, line, column: i32, lo, hi: int, len: int) -> ! ---
-		multi_pointer_slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int) -> ! ---
-		multi_pointer_slice_expr_error   :: proc "contextless" (file: string, line, column: i32, lo, hi: int) ---
-		slice_expr_error_hi              :: proc "contextless" (file: string, line, column: i32, hi: int, len: int) ---
-		slice_expr_error_lo_hi           :: proc "contextless" (file: string, line, column: i32, lo, hi: int, len: int) ---
-		dynamic_array_expr_error         :: proc "contextless" (file: string, line, column: i32, low, high, max: int) ---
-		matrix_bounds_check_error        :: proc "contextless" (file: string, line, column: i32, row_index, column_index, row_count, column_count: int) ---
-		type_assertion_check             :: proc "contextless" (ok: bool, file: string, line, column: i32, from, to: typeid) ---
-		type_assertion_check2            :: proc "contextless" (ok: bool, file: string, line, column: i32, from, to: typeid, from_data: rawptr) ---
+slice_expr_error_hi :: proc "contextless" (file: string, line, column: i32, hi: int, len: int) {
+	if 0 <= hi && hi <= len {
+		return
 	}
-} else {
-	bounds_check_error :: proc "contextless" (file: string, line, column: i32, index, count: int) {
-		if 0 <= index && index < count {
-			return
-		}
-		handle_error :: proc "contextless" (file: string, line, column: i32, index, count: int) {
-			print_caller_location(Source_Code_Location{file, line, column, ""})
-			print_string(" Index ")
-			print_i64(i64(index))
-			print_string(" is out of range 0..<")
-			print_i64(i64(count))
-			print_byte('\n')
-			bounds_trap()
-		}
-		handle_error(file, line, column, index, count)
+	slice_handle_error(file, line, column, 0, hi, len)
+}
+
+slice_expr_error_lo_hi :: proc "contextless" (file: string, line, column: i32, lo, hi: int, len: int) {
+	if 0 <= lo && lo <= len && lo <= hi && hi <= len {
+		return
 	}
+	slice_handle_error(file, line, column, lo, hi, len)
+}
 
-	slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int, len: int) -> ! {
+dynamic_array_expr_error :: proc "contextless" (file: string, line, column: i32, low, high, max: int) {
+	if 0 <= low && low <= high && high <= max {
+		return
+	}
+	@(cold)
+	handle_error :: proc "contextless" (file: string, line, column: i32, low, high, max: int) {
 		print_caller_location(Source_Code_Location{file, line, column, ""})
-		print_string(" Invalid slice indices ")
-		print_i64(i64(lo))
+		print_string(" Invalid dynamic array indices ")
+		print_i64(i64(low))
 		print_string(":")
-		print_i64(i64(hi))
+		print_i64(i64(high))
 		print_string(" is out of range 0..<")
-		print_i64(i64(len))
+		print_i64(i64(max))
 		print_byte('\n')
 		bounds_trap()
 	}
+	handle_error(file, line, column, low, high, max)
+}
+
 
-	multi_pointer_slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int) -> ! {
+matrix_bounds_check_error :: proc "contextless" (file: string, line, column: i32, row_index, column_index, row_count, column_count: int) {
+	if 0 <= row_index && row_index < row_count &&
+	   0 <= column_index && column_index < column_count {
+		return
+	}
+	@(cold)
+	handle_error :: proc "contextless" (file: string, line, column: i32, row_index, column_index, row_count, column_count: int) {
 		print_caller_location(Source_Code_Location{file, line, column, ""})
-		print_string(" Invalid slice indices ")
-		print_i64(i64(lo))
-		print_string(":")
-		print_i64(i64(hi))
+		print_string(" Matrix indices [")
+		print_i64(i64(row_index))
+		print_string(", ")
+		print_i64(i64(column_index))
+		print_string(" is out of range [0..<")
+		print_i64(i64(row_count))
+		print_string(", 0..<")
+		print_i64(i64(column_count))
+		print_string("]")
 		print_byte('\n')
 		bounds_trap()
 	}
+	handle_error(file, line, column, row_index, column_index, row_count, column_count)
+}
 
 
-	multi_pointer_slice_expr_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int) {
-		if lo <= hi {
-			return
-		}
-		multi_pointer_slice_handle_error(file, line, column, lo, hi)
-	}
-
-	slice_expr_error_hi :: proc "contextless" (file: string, line, column: i32, hi: int, len: int) {
-		if 0 <= hi && hi <= len {
-			return
-		}
-		slice_handle_error(file, line, column, 0, hi, len)
-	}
-
-	slice_expr_error_lo_hi :: proc "contextless" (file: string, line, column: i32, lo, hi: int, len: int) {
-		if 0 <= lo && lo <= len && lo <= hi && hi <= len {
-			return
-		}
-		slice_handle_error(file, line, column, lo, hi, len)
-	}
-
-	dynamic_array_expr_error :: proc "contextless" (file: string, line, column: i32, low, high, max: int) {
-		if 0 <= low && low <= high && high <= max {
+when ODIN_DISALLOW_RTTI {
+	type_assertion_check :: proc "contextless" (ok: bool, file: string, line, column: i32) {
+		if ok {
 			return
 		}
-		handle_error :: proc "contextless" (file: string, line, column: i32, low, high, max: int) {
+		@(cold)
+		handle_error :: proc "contextless" (file: string, line, column: i32) {
 			print_caller_location(Source_Code_Location{file, line, column, ""})
-			print_string(" Invalid dynamic array indices ")
-			print_i64(i64(low))
-			print_string(":")
-			print_i64(i64(high))
-			print_string(" is out of range 0..<")
-			print_i64(i64(max))
-			print_byte('\n')
-			bounds_trap()
+			print_string(" Invalid type assertion\n")
+			type_assertion_trap()
 		}
-		handle_error(file, line, column, low, high, max)
+		handle_error(file, line, column)
 	}
 
-
-	matrix_bounds_check_error :: proc "contextless" (file: string, line, column: i32, row_index, column_index, row_count, column_count: int) {
-		if 0 <= row_index && row_index < row_count &&
-		   0 <= column_index && column_index < column_count {
+	type_assertion_check2 :: proc "contextless" (ok: bool, file: string, line, column: i32) {
+		if ok {
 			return
 		}
-		handle_error :: proc "contextless" (file: string, line, column: i32, row_index, column_index, row_count, column_count: int) {
+		@(cold)
+		handle_error :: proc "contextless" (file: string, line, column: i32) {
 			print_caller_location(Source_Code_Location{file, line, column, ""})
-			print_string(" Matrix indices [")
-			print_i64(i64(row_index))
-			print_string(", ")
-			print_i64(i64(column_index))
-			print_string(" is out of range [0..<")
-			print_i64(i64(row_count))
-			print_string(", 0..<")
-			print_i64(i64(column_count))
-			print_string("]")
-			print_byte('\n')
-			bounds_trap()
+			print_string(" Invalid type assertion\n")
+			type_assertion_trap()
 		}
-		handle_error(file, line, column, row_index, column_index, row_count, column_count)
+		handle_error(file, line, column)
 	}
-
-
+} else {
 	type_assertion_check :: proc "contextless" (ok: bool, file: string, line, column: i32, from, to: typeid) {
 		if ok {
 			return
 		}
+		@(cold)
 		handle_error :: proc "contextless" (file: string, line, column: i32, from, to: typeid) {
 			print_caller_location(Source_Code_Location{file, line, column, ""})
 			print_string(" Invalid type assertion from ")
@@ -198,6 +198,7 @@ when ODIN_FOREIGN_ERROR_PROCEDURES {
 			return id
 		}
 
+		@(cold)
 		handle_error :: proc "contextless" (file: string, line, column: i32, from, to: typeid, from_data: rawptr) {
 
 			actual := variant_type(from, from_data)
@@ -219,13 +220,11 @@ when ODIN_FOREIGN_ERROR_PROCEDURES {
 }
 
 
-// `make` related procedures below
-
-
 make_slice_error_loc :: #force_inline proc "contextless" (loc := #caller_location, len: int) {
 	if 0 <= len {
 		return
 	}
+	@(cold)
 	handle_error :: proc "contextless" (loc: Source_Code_Location, len: int) {
 		print_caller_location(loc)
 		print_string(" Invalid slice length for make: ")
@@ -236,10 +235,11 @@ make_slice_error_loc :: #force_inline proc "contextless" (loc := #caller_locatio
 	handle_error(loc, len)
 }
 
-make_dynamic_array_error_loc :: #force_inline proc "contextless" (loc := #caller_location, len, cap: int) {
+make_dynamic_array_error_loc :: #force_inline proc "contextless" (using loc := #caller_location, len, cap: int) {
 	if 0 <= len && len <= cap {
 		return
 	}
+	@(cold)
 	handle_error :: proc "contextless" (loc: Source_Code_Location, len, cap: int) {
 		print_caller_location(loc)
 		print_string(" Invalid dynamic array parameters for make: ")
@@ -256,6 +256,7 @@ make_map_expr_error_loc :: #force_inline proc "contextless" (loc := #caller_loca
 	if 0 <= cap {
 		return
 	}
+	@(cold)
 	handle_error :: proc "contextless" (loc: Source_Code_Location, cap: int) {
 		print_caller_location(loc)
 		print_string(" Invalid map capacity for make: ")
@@ -265,3 +266,23 @@ make_map_expr_error_loc :: #force_inline proc "contextless" (loc := #caller_loca
 	}
 	handle_error(loc, cap)
 }
+
+
+
+
+
+bounds_check_error_loc :: #force_inline proc "contextless" (using loc := #caller_location, index, count: int) {
+	bounds_check_error(file_path, line, column, index, count)
+}
+
+slice_expr_error_hi_loc :: #force_inline proc "contextless" (using loc := #caller_location, hi: int, len: int) {
+	slice_expr_error_hi(file_path, line, column, hi, len)
+}
+
+slice_expr_error_lo_hi_loc :: #force_inline proc "contextless" (using loc := #caller_location, lo, hi: int, len: int) {
+	slice_expr_error_lo_hi(file_path, line, column, lo, hi, len)
+}
+
+dynamic_array_expr_error_loc :: #force_inline proc "contextless" (using loc := #caller_location, low, high, max: int) {
+	dynamic_array_expr_error(file_path, line, column, low, high, max)
+}
diff --git a/core/runtime/print.odin b/core/runtime/print.odin
index 06740bc75..89c196fc2 100644
--- a/core/runtime/print.odin
+++ b/core/runtime/print.odin
@@ -160,11 +160,19 @@ print_caller_location :: proc "contextless" (using loc: Source_Code_Location) {
 	}
 }
 print_typeid :: proc "contextless" (id: typeid) {
-	if id == nil {
-		print_string("nil")
+	when ODIN_DISALLOW_RTTI {
+		if id == nil {
+			print_string("nil")
+		} else {
+			print_string("<unknown type>")
+		}
 	} else {
-		ti := type_info_of(id)
-		print_type(ti)
+		if id == nil {
+			print_string("nil")
+		} else {
+			ti := type_info_of(id)
+			print_type(ti)
+		}
 	}
 }
 print_type :: proc "contextless" (ti: ^Type_Info) {
-- 
cgit v1.2.3


From fc4eb4152cd9e95ee1e020d60f89a2e245e8febe Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 28 Feb 2022 15:35:10 +0000
Subject: Correct calling convention for `_startup_runtime`

---
 core/runtime/core.odin | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'core/runtime')

diff --git a/core/runtime/core.odin b/core/runtime/core.odin
index 83a5418ed..3f6b03107 100644
--- a/core/runtime/core.odin
+++ b/core/runtime/core.odin
@@ -451,7 +451,7 @@ Odin_Endian_Type :: type_of(ODIN_ENDIAN)
 // This is probably only useful for freestanding targets
 foreign {
 	@(link_name="__$startup_runtime")
-	_startup_runtime :: proc() ---
+	_startup_runtime :: proc "odin" () ---
 }
 
 @(link_name="__$cleanup_runtime")
-- 
cgit v1.2.3


From 17eebf338c7c2428db99470f8e1dd6c8d2f7ac0f Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Wed, 9 Mar 2022 15:05:51 +0000
Subject: Fix #1606 (Call `runtime._cleanup_runtime_contextless()` for
 `os.exit`)

---
 core/os/os_darwin.odin  | 1 +
 core/os/os_freebsd.odin | 1 +
 core/os/os_linux.odin   | 1 +
 core/os/os_openbsd.odin | 2 ++
 core/os/os_wasi.odin    | 2 ++
 core/os/os_windows.odin | 2 ++
 core/runtime/core.odin  | 5 +++++
 7 files changed, 14 insertions(+)

(limited to 'core/runtime')

diff --git a/core/os/os_darwin.odin b/core/os/os_darwin.odin
index 4365842b0..ace622582 100644
--- a/core/os/os_darwin.odin
+++ b/core/os/os_darwin.odin
@@ -680,6 +680,7 @@ make_directory :: proc(path: string, mode: u32 = 0o775) -> Errno {
 }
 
 exit :: proc "contextless" (code: int) -> ! {
+	runtime._cleanup_runtime_contextless()
 	_unix_exit(i32(code))
 }
 
diff --git a/core/os/os_freebsd.odin b/core/os/os_freebsd.odin
index e31eb31bb..7fb9dd26f 100644
--- a/core/os/os_freebsd.odin
+++ b/core/os/os_freebsd.odin
@@ -419,6 +419,7 @@ set_current_directory :: proc(path: string) -> (err: Errno) {
 }
 
 exit :: proc "contextless" (code: int) -> ! {
+	runtime._cleanup_runtime_contextless()
 	_unix_exit(c.int(code))
 }
 
diff --git a/core/os/os_linux.odin b/core/os/os_linux.odin
index 200d6d68d..9716e2925 100644
--- a/core/os/os_linux.odin
+++ b/core/os/os_linux.odin
@@ -802,6 +802,7 @@ set_current_directory :: proc(path: string) -> (err: Errno) {
 }
 
 exit :: proc "contextless" (code: int) -> ! {
+	runtime._cleanup_runtime_contextless()
 	_unix_exit(c.int(code))
 }
 
diff --git a/core/os/os_openbsd.odin b/core/os/os_openbsd.odin
index 3862851a1..bca93880a 100644
--- a/core/os/os_openbsd.odin
+++ b/core/os/os_openbsd.odin
@@ -5,6 +5,7 @@ foreign import libc "system:c"
 import "core:runtime"
 import "core:strings"
 import "core:c"
+import "core:runtime"
 
 Handle    :: distinct i32
 Pid       :: distinct i32
@@ -658,6 +659,7 @@ set_current_directory :: proc(path: string) -> (err: Errno) {
 }
 
 exit :: proc "contextless" (code: int) -> ! {
+	runtime._cleanup_runtime_contextless()
 	_unix_exit(c.int(code))
 }
 
diff --git a/core/os/os_wasi.odin b/core/os/os_wasi.odin
index d2ba166bd..7bab1b949 100644
--- a/core/os/os_wasi.odin
+++ b/core/os/os_wasi.odin
@@ -1,6 +1,7 @@
 package os
 
 import "core:sys/wasm/wasi"
+import "core:runtime"
 
 Handle :: distinct i32
 Errno :: distinct i32
@@ -93,5 +94,6 @@ heap_free :: proc(ptr: rawptr) {
 
 
 exit :: proc "contextless" (code: int) -> ! {
+	runtime._cleanup_runtime_contextless()
 	wasi.proc_exit(wasi.exitcode_t(code))
 }
\ No newline at end of file
diff --git a/core/os/os_windows.odin b/core/os/os_windows.odin
index e6efb89df..fe9496e4c 100644
--- a/core/os/os_windows.odin
+++ b/core/os/os_windows.odin
@@ -2,6 +2,7 @@
 package os
 
 import win32 "core:sys/windows"
+import "core:runtime"
 
 Handle    :: distinct uintptr
 File_Time :: distinct u64
@@ -128,6 +129,7 @@ get_page_size :: proc() -> int {
 
 
 exit :: proc "contextless" (code: int) -> ! {
+	runtime._cleanup_runtime_contextless()
 	win32.ExitProcess(win32.DWORD(code))
 }
 
diff --git a/core/runtime/core.odin b/core/runtime/core.odin
index 8d315a238..08ca4c049 100644
--- a/core/runtime/core.odin
+++ b/core/runtime/core.odin
@@ -459,6 +459,11 @@ _cleanup_runtime :: proc() {
 	default_temp_allocator_destroy(&global_default_temp_allocator_data)
 }
 
+_cleanup_runtime_contextless :: proc "contextless" () {
+	context = default_context()
+	_cleanup_runtime()
+}
+
 
 /////////////////////////////
 /////////////////////////////
-- 
cgit v1.2.3


From a932168f505201d528dcd2d43355c3708e68e26a Mon Sep 17 00:00:00 2001
From: Jeroen van Rijn <Kelimion@users.noreply.github.com>
Date: Tue, 15 Mar 2022 19:35:00 +0100
Subject: [runtime] fix `insert_at` procedure group.

---
 core/runtime/core_builtin.odin | 33 ++++++++++++++++++---------------
 1 file changed, 18 insertions(+), 15 deletions(-)

(limited to 'core/runtime')

diff --git a/core/runtime/core_builtin.odin b/core/runtime/core_builtin.odin
index 3bafc0b1d..dd4960147 100644
--- a/core/runtime/core_builtin.odin
+++ b/core/runtime/core_builtin.odin
@@ -386,12 +386,13 @@ insert_at_elem :: proc(array: ^$T/[dynamic]$E, index: int, arg: E, loc := #calle
 	if array == nil {
 		return
 	}
-	n := len(array)
+	n := max(len(array), index)
 	m :: 1
-	resize(array, n+m, loc)
-	if n+m <= len(array) {
+	new_size := n + m
+
+	if resize(array, new_size, loc) {
 		when size_of(E) != 0 {
-			copy(array[index+m:], array[index:])
+			copy(array[index + m:], array[index:])
 			array[index] = arg
 		}
 		ok = true
@@ -409,12 +410,13 @@ insert_at_elems :: proc(array: ^$T/[dynamic]$E, index: int, args: ..E, loc := #c
 		return
 	}
 
-	n := len(array)
+	n := max(len(array), index)
 	m := len(args)
-	resize(array, n+m, loc)
-	if n+m <= len(array) {
+	new_size := n + m
+
+	if resize(array, new_size, loc) {
 		when size_of(E) != 0 {
-			copy(array[index+m:], array[index:])
+			copy(array[index + m:], array[index:])
 			copy(array[index:], args)
 		}
 		ok = true
@@ -423,21 +425,22 @@ insert_at_elems :: proc(array: ^$T/[dynamic]$E, index: int, args: ..E, loc := #c
 }
 
 @builtin
-insert_at_elem_string :: proc(array: ^$T/[dynamic]$E/u8, index: int, arg: string, loc := #caller_location) -> (ok: bool) #no_bounds_check {
+insert_at_elem_string :: proc(array: ^$T/[dynamic]$E/u8, index: int, arg: string, loc := #caller_location) -> (ok: bool) {
 	if array == nil {
 		return
 	}
-	if len(args) == 0 {
+	if len(arg) == 0 {
 		ok = true
 		return
 	}
 
-	n := len(array)
-	m := len(args)
-	resize(array, n+m, loc)
-	if n+m <= len(array) {
+	n := max(len(array), index)
+	m := len(arg)
+	new_size := n + m
+
+	if resize(array, new_size, loc) {
 		copy(array[index+m:], array[index:])
-		copy(array[index:], args)
+		copy(array[index:], arg)
 		ok = true
 	}
 	return
-- 
cgit v1.2.3


From 19dc84e300386b3f3262c78371c085a005045566 Mon Sep 17 00:00:00 2001
From: Jeroen van Rijn <Kelimion@users.noreply.github.com>
Date: Tue, 15 Mar 2022 19:37:04 +0100
Subject: Reinstate NBC.

---
 core/runtime/core_builtin.odin | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'core/runtime')

diff --git a/core/runtime/core_builtin.odin b/core/runtime/core_builtin.odin
index dd4960147..67b1bd37b 100644
--- a/core/runtime/core_builtin.odin
+++ b/core/runtime/core_builtin.odin
@@ -425,7 +425,7 @@ insert_at_elems :: proc(array: ^$T/[dynamic]$E, index: int, args: ..E, loc := #c
 }
 
 @builtin
-insert_at_elem_string :: proc(array: ^$T/[dynamic]$E/u8, index: int, arg: string, loc := #caller_location) -> (ok: bool) {
+insert_at_elem_string :: proc(array: ^$T/[dynamic]$E/u8, index: int, arg: string, loc := #caller_location) -> (ok: bool) #no_bounds_check {
 	if array == nil {
 		return
 	}
-- 
cgit v1.2.3


From 3f935bea2505b3ee7e169a29b7aed50c0e5614b7 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Thu, 24 Mar 2022 11:55:03 +0000
Subject: `union #shared_nil`

This adds a feature to `union` which requires all the variants to have a `nil` value and on assign to the union, checks whether that value is `nil` or not. If the value is `nil`, the union will be `nil` (thus sharing the `nil` value)
---
 core/runtime/core.odin       |  1 +
 src/check_expr.cpp           |  7 +++++--
 src/check_type.cpp           | 19 ++++++++++++++-----
 src/docs_format.cpp          |  1 +
 src/docs_writer.cpp          |  8 +++++---
 src/llvm_backend_general.cpp | 31 ++++++++++++++++++++++++++++---
 src/llvm_backend_type.cpp    |  7 ++++---
 src/parser.cpp               | 30 ++++++++++++++++++++++++++----
 src/parser.hpp               | 10 ++++++++--
 src/types.cpp                | 22 ++++++++++++----------
 10 files changed, 104 insertions(+), 32 deletions(-)

(limited to 'core/runtime')

diff --git a/core/runtime/core.odin b/core/runtime/core.odin
index 8c95a234f..a5a190a9c 100644
--- a/core/runtime/core.odin
+++ b/core/runtime/core.odin
@@ -136,6 +136,7 @@ Type_Info_Union :: struct {
 	custom_align: bool,
 	no_nil:       bool,
 	maybe:        bool,
+	shared_nil:   bool,
 }
 Type_Info_Enum :: struct {
 	base:      ^Type_Info,
diff --git a/src/check_expr.cpp b/src/check_expr.cpp
index 66bf8bbd7..dcf17af39 100644
--- a/src/check_expr.cpp
+++ b/src/check_expr.cpp
@@ -10047,8 +10047,11 @@ gbString write_expr_to_string(gbString str, Ast *node, bool shorthand) {
 			str = write_expr_to_string(str, st->polymorphic_params, shorthand);
 			str = gb_string_appendc(str, ") ");
 		}
-		if (st->no_nil) str = gb_string_appendc(str, "#no_nil ");
-		if (st->maybe)  str = gb_string_appendc(str, "#maybe ");
+		switch (st->kind) {
+		case UnionType_maybe:      str = gb_string_appendc(str, "#maybe ");      break;
+		case UnionType_no_nil:     str = gb_string_appendc(str, "#no_nil ");     break;
+		case UnionType_shared_nil: str = gb_string_appendc(str, "#shared_nil "); break;
+		}
 		if (st->align) {
 			str = gb_string_appendc(str, "#align ");
 			str = write_expr_to_string(str, st->align, shorthand);
diff --git a/src/check_type.cpp b/src/check_type.cpp
index 3c7f33a46..51f472961 100644
--- a/src/check_type.cpp
+++ b/src/check_type.cpp
@@ -675,22 +675,31 @@ void check_union_type(CheckerContext *ctx, Type *union_type, Ast *node, Array<Op
 			}
 			if (ok) {
 				array_add(&variants, t);
+
+				if (ut->kind == UnionType_shared_nil) {
+					if (!type_has_nil(t)) {
+						gbString s = type_to_string(t);
+						error(node, "Each variant of a union with #shared_nil must have a 'nil' value, got %s", s);
+						gb_string_free(s);
+					}
+				}
 			}
 		}
 	}
 
 	union_type->Union.variants = slice_from_array(variants);
-	union_type->Union.no_nil = ut->no_nil;
-	union_type->Union.maybe = ut->maybe;
-	if (union_type->Union.no_nil) {
+	union_type->Union.kind = ut->kind;
+	switch (ut->kind) {
+	case UnionType_no_nil:
 		if (variants.count < 2) {
 			error(ut->align, "A union with #no_nil must have at least 2 variants");
 		}
-	}
-	if (union_type->Union.maybe) {
+		break;
+	case UnionType_maybe:
 		if (variants.count != 1) {
 			error(ut->align, "A union with #maybe must have at 1 variant, got %lld", cast(long long)variants.count);
 		}
+		break;
 	}
 
 	if (ut->align != nullptr) {
diff --git a/src/docs_format.cpp b/src/docs_format.cpp
index 7ce93d2bf..ee32d0e05 100644
--- a/src/docs_format.cpp
+++ b/src/docs_format.cpp
@@ -99,6 +99,7 @@ enum OdinDocTypeFlag_Union : u32 {
 	OdinDocTypeFlag_Union_polymorphic = 1<<0,
 	OdinDocTypeFlag_Union_no_nil      = 1<<1,
 	OdinDocTypeFlag_Union_maybe       = 1<<2,
+	OdinDocTypeFlag_Union_shared_nil  = 1<<3,
 };
 
 enum OdinDocTypeFlag_Proc : u32 {
diff --git a/src/docs_writer.cpp b/src/docs_writer.cpp
index 2c5186c39..0ad10ac49 100644
--- a/src/docs_writer.cpp
+++ b/src/docs_writer.cpp
@@ -619,9 +619,11 @@ OdinDocTypeIndex odin_doc_type(OdinDocWriter *w, Type *type) {
 	case Type_Union:
 		doc_type.kind = OdinDocType_Union;
 		if (type->Union.is_polymorphic) { doc_type.flags |= OdinDocTypeFlag_Union_polymorphic; }
-		if (type->Union.no_nil)         { doc_type.flags |= OdinDocTypeFlag_Union_no_nil; }
-		if (type->Union.maybe)          { doc_type.flags |= OdinDocTypeFlag_Union_maybe; }
-
+		switch (type->Union.kind) {
+		case UnionType_maybe:      doc_type.flags |= OdinDocTypeFlag_Union_maybe;      break;
+		case UnionType_no_nil:     doc_type.flags |= OdinDocTypeFlag_Union_no_nil;     break;
+		case UnionType_shared_nil: doc_type.flags |= OdinDocTypeFlag_Union_shared_nil; break;
+		}
 		{
 			auto variants = array_make<OdinDocTypeIndex>(heap_allocator(), type->Union.variants.count);
 			defer (array_free(&variants));
diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index dd1555193..f6dd97966 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -1176,10 +1176,35 @@ void lb_emit_store_union_variant_tag(lbProcedure *p, lbValue parent, Type *varia
 }
 
 void lb_emit_store_union_variant(lbProcedure *p, lbValue parent, lbValue variant, Type *variant_type) {
-	lbValue underlying = lb_emit_conv(p, parent, alloc_type_pointer(variant_type));
+	Type *pt = base_type(type_deref(parent.type));
+	GB_ASSERT(pt->kind == Type_Union);
+	if (pt->Union.kind == UnionType_shared_nil) {
+		lbBlock *if_nil     = lb_create_block(p, "shared_nil.if_nil");
+		lbBlock *if_not_nil = lb_create_block(p, "shared_nil.if_not_nil");
+		lbBlock *done       = lb_create_block(p, "shared_nil.done");
+
+		lbValue cond_is_nil = lb_emit_comp_against_nil(p, Token_CmpEq, variant);
+		lb_emit_if(p, cond_is_nil, if_nil, if_not_nil);
+
+		lb_start_block(p, if_nil);
+		lb_emit_store(p, parent, lb_const_nil(p->module, type_deref(parent.type)));
+		lb_emit_jump(p, done);
+
+		lb_start_block(p, if_not_nil);
+		lbValue underlying = lb_emit_conv(p, parent, alloc_type_pointer(variant_type));
+		lb_emit_store(p, underlying, variant);
+		lb_emit_store_union_variant_tag(p, parent, variant_type);
+		lb_emit_jump(p, done);
+
+		lb_start_block(p, done);
 
-	lb_emit_store(p, underlying, variant);
-	lb_emit_store_union_variant_tag(p, parent, variant_type);
+
+	} else {
+		lbValue underlying = lb_emit_conv(p, parent, alloc_type_pointer(variant_type));
+
+		lb_emit_store(p, underlying, variant);
+		lb_emit_store_union_variant_tag(p, parent, variant_type);
+	}
 }
 
 
diff --git a/src/llvm_backend_type.cpp b/src/llvm_backend_type.cpp
index e245a8b40..7d73956e8 100644
--- a/src/llvm_backend_type.cpp
+++ b/src/llvm_backend_type.cpp
@@ -641,7 +641,7 @@ void lb_setup_type_info_data(lbProcedure *p) { // NOTE(bill): Setup type_info da
 			tag = lb_const_ptr_cast(m, variant_ptr, t_type_info_union_ptr);
 
 			{
-				LLVMValueRef vals[7] = {};
+				LLVMValueRef vals[8] = {};
 
 				isize variant_count = gb_max(0, t->Union.variants.count);
 				lbValue memory_types = lb_type_info_member_types_offset(p, variant_count);
@@ -675,8 +675,9 @@ void lb_setup_type_info_data(lbProcedure *p) { // NOTE(bill): Setup type_info da
 				}
 
 				vals[4] = lb_const_bool(m, t_bool, t->Union.custom_align != 0).value;
-				vals[5] = lb_const_bool(m, t_bool, t->Union.no_nil).value;
-				vals[6] = lb_const_bool(m, t_bool, t->Union.maybe).value;
+				vals[5] = lb_const_bool(m, t_bool, t->Union.kind == UnionType_no_nil).value;
+				vals[6] = lb_const_bool(m, t_bool, t->Union.kind == UnionType_maybe).value;
+				vals[7] = lb_const_bool(m, t_bool, t->Union.kind == UnionType_shared_nil).value;
 
 				for (isize i = 0; i < gb_count_of(vals); i++) {
 					if (vals[i] == nullptr) {
diff --git a/src/parser.cpp b/src/parser.cpp
index a435d1317..767119aa8 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -1071,15 +1071,14 @@ Ast *ast_struct_type(AstFile *f, Token token, Slice<Ast *> fields, isize field_c
 }
 
 
-Ast *ast_union_type(AstFile *f, Token token, Array<Ast *> const &variants, Ast *polymorphic_params, Ast *align, bool no_nil, bool maybe,
+Ast *ast_union_type(AstFile *f, Token token, Array<Ast *> const &variants, Ast *polymorphic_params, Ast *align, UnionTypeKind kind,
                     Token where_token, Array<Ast *> const &where_clauses) {
 	Ast *result = alloc_ast_node(f, Ast_UnionType);
 	result->UnionType.token              = token;
 	result->UnionType.variants           = slice_from_array(variants);
 	result->UnionType.polymorphic_params = polymorphic_params;
 	result->UnionType.align              = align;
-	result->UnionType.no_nil             = no_nil;
-	result->UnionType.maybe              = maybe;
+	result->UnionType.kind               = kind;
 	result->UnionType.where_token        = where_token;
 	result->UnionType.where_clauses      = slice_from_array(where_clauses);
 	return result;
@@ -2475,6 +2474,9 @@ Ast *parse_operand(AstFile *f, bool lhs) {
 		Ast *align = nullptr;
 		bool no_nil = false;
 		bool maybe = false;
+		bool shared_nil = false;
+
+		UnionTypeKind union_kind = UnionType_Normal;
 
 		Token start_token = f->curr_token;
 
@@ -2501,6 +2503,11 @@ Ast *parse_operand(AstFile *f, bool lhs) {
 					syntax_error(tag, "Duplicate union tag '#%.*s'", LIT(tag.string));
 				}
 				no_nil = true;
+			} else if (tag.string == "shared_nil") {
+				if (shared_nil) {
+					syntax_error(tag, "Duplicate union tag '#%.*s'", LIT(tag.string));
+				}
+				shared_nil = true;
 			} else if (tag.string == "maybe") {
 				if (maybe) {
 					syntax_error(tag, "Duplicate union tag '#%.*s'", LIT(tag.string));
@@ -2513,6 +2520,21 @@ Ast *parse_operand(AstFile *f, bool lhs) {
 		if (no_nil && maybe) {
 			syntax_error(f->curr_token, "#maybe and #no_nil cannot be applied together");
 		}
+		if (no_nil && shared_nil) {
+			syntax_error(f->curr_token, "#shared_nil and #no_nil cannot be applied together");
+		}
+		if (shared_nil && maybe) {
+			syntax_error(f->curr_token, "#maybe and #shared_nil cannot be applied together");
+		}
+
+
+		if (maybe) {
+			union_kind = UnionType_maybe;
+		} else if (no_nil) {
+			union_kind = UnionType_no_nil;
+		} else if (shared_nil) {
+			union_kind = UnionType_shared_nil;
+		}
 
 		skip_possible_newline_for_literal(f);
 
@@ -2544,7 +2566,7 @@ Ast *parse_operand(AstFile *f, bool lhs) {
 
 		Token close = expect_closing_brace_of_field_list(f);
 
-		return ast_union_type(f, token, variants, polymorphic_params, align, no_nil, maybe, where_token, where_clauses);
+		return ast_union_type(f, token, variants, polymorphic_params, align, union_kind, where_token, where_clauses);
 	} break;
 
 	case Token_enum: {
diff --git a/src/parser.hpp b/src/parser.hpp
index c33d1520b..c7b4fd0d8 100644
--- a/src/parser.hpp
+++ b/src/parser.hpp
@@ -330,6 +330,13 @@ char const *inline_asm_dialect_strings[InlineAsmDialect_COUNT] = {
 	"intel",
 };
 
+enum UnionTypeKind : u8 {
+	UnionType_Normal     = 0,
+	UnionType_maybe      = 1,
+	UnionType_no_nil     = 2,
+	UnionType_shared_nil = 3,
+};
+
 #define AST_KINDS \
 	AST_KIND(Ident,          "identifier",      struct { \
 		Token   token;  \
@@ -678,8 +685,7 @@ AST_KIND(_TypeBegin, "", bool) \
 		Slice<Ast *> variants;      \
 		Ast *polymorphic_params;    \
 		Ast *        align;         \
-		bool         maybe;         \
-		bool         no_nil;        \
+		UnionTypeKind kind;       \
 		Token where_token;          \
 		Slice<Ast *> where_clauses; \
 	}) \
diff --git a/src/types.cpp b/src/types.cpp
index ef770c846..b231218a2 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -165,9 +165,8 @@ struct TypeUnion {
 
 	i16           tag_size;
 	bool          is_polymorphic;
-	bool          is_poly_specialized : 1;
-	bool          no_nil              : 1;
-	bool          maybe               : 1;
+	bool          is_poly_specialized;
+	UnionTypeKind kind;
 };
 
 struct TypeProc {
@@ -1664,7 +1663,7 @@ bool is_type_map(Type *t) {
 
 bool is_type_union_maybe_pointer(Type *t) {
 	t = base_type(t);
-	if (t->kind == Type_Union && t->Union.maybe) {
+	if (t->kind == Type_Union && t->Union.kind == UnionType_maybe) {
 		if (t->Union.variants.count == 1) {
 			Type *v = t->Union.variants[0];
 			return is_type_pointer(v) || is_type_multi_pointer(v);
@@ -1676,7 +1675,7 @@ bool is_type_union_maybe_pointer(Type *t) {
 
 bool is_type_union_maybe_pointer_original_alignment(Type *t) {
 	t = base_type(t);
-	if (t->kind == Type_Union && t->Union.maybe) {
+	if (t->kind == Type_Union && t->Union.kind == UnionType_maybe) {
 		if (t->Union.variants.count == 1) {
 			Type *v = t->Union.variants[0];
 			if (is_type_pointer(v) || is_type_multi_pointer(v)) {
@@ -2168,7 +2167,7 @@ bool type_has_nil(Type *t) {
 	case Type_Map:
 		return true;
 	case Type_Union:
-		return !t->Union.no_nil;
+		return t->Union.kind != UnionType_no_nil;
 	case Type_Struct:
 		if (is_type_soa_struct(t)) {
 			switch (t->Struct.soa_kind) {
@@ -2454,7 +2453,7 @@ bool are_types_identical_internal(Type *x, Type *y, bool check_tuple_names) {
 		if (y->kind == Type_Union) {
 			if (x->Union.variants.count == y->Union.variants.count &&
 			    x->Union.custom_align == y->Union.custom_align &&
-			    x->Union.no_nil == y->Union.no_nil) {
+			    x->Union.kind == y->Union.kind) {
 				// NOTE(bill): zeroth variant is nullptr
 				for_array(i, x->Union.variants) {
 					if (!are_types_identical(x->Union.variants[i], y->Union.variants[i])) {
@@ -2598,7 +2597,7 @@ i64 union_variant_index(Type *u, Type *v) {
 	for_array(i, u->Union.variants) {
 		Type *vt = u->Union.variants[i];
 		if (are_types_identical(v, vt)) {
-			if (u->Union.no_nil) {
+			if (u->Union.kind == UnionType_no_nil) {
 				return cast(i64)(i+0);
 			} else {
 				return cast(i64)(i+1);
@@ -4021,8 +4020,11 @@ gbString write_type_to_string(gbString str, Type *type, bool shorthand=false) {
 
 	case Type_Union:
 		str = gb_string_appendc(str, "union");
-		if (type->Union.no_nil != 0) str = gb_string_appendc(str, " #no_nil");
-		if (type->Union.maybe != 0)  str = gb_string_appendc(str, " #maybe");
+		switch (type->Union.kind) {
+		case UnionType_maybe:      str = gb_string_appendc(str, " #maybe");      break;
+		case UnionType_no_nil:     str = gb_string_appendc(str, " #no_nil");     break;
+		case UnionType_shared_nil: str = gb_string_appendc(str, " #shared_nil"); break;
+		}
 		if (type->Union.custom_align != 0) str = gb_string_append_fmt(str, " #align %d", cast(int)type->Union.custom_align);
 		str = gb_string_appendc(str, " {");
 		for_array(i, type->Union.variants) {
-- 
cgit v1.2.3


From a632db361849f80b888faf282b1b95c43ec37432 Mon Sep 17 00:00:00 2001
From: Colin Davidson <colrdavidson@gmail.com>
Date: Wed, 30 Mar 2022 04:45:22 -0700
Subject: Make no crt work on Linux

---
 core/runtime/entry_unix.odin | 2 +-
 src/main.cpp                 | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

(limited to 'core/runtime')

diff --git a/core/runtime/entry_unix.odin b/core/runtime/entry_unix.odin
index 1a3def200..9f7d219c3 100644
--- a/core/runtime/entry_unix.odin
+++ b/core/runtime/entry_unix.odin
@@ -30,4 +30,4 @@ when ODIN_BUILD_MODE == .Dynamic {
 		#force_no_inline _cleanup_runtime()
 		return 0
 	}
-}
\ No newline at end of file
+}
diff --git a/src/main.cpp b/src/main.cpp
index 63b2c8386..383997719 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -433,6 +433,10 @@ i32 linker_stage(lbGenerator *gen) {
 		String output_ext = {};
 		gbString link_settings = gb_string_make_reserve(heap_allocator(), 32);
 
+		if (build_context.no_crt) {
+			link_settings = gb_string_append_fmt(link_settings, "-nostdlib ");
+		}
+
 		// NOTE(dweiler): We use clang as a frontend for the linker as there are
 		// other runtime and compiler support libraries that need to be linked in
 		// very specific orders such as libgcc_s, ld-linux-so, unwind, etc.
-- 
cgit v1.2.3


From ad90f416a59be22dbf8fca89890a70407dc5826c Mon Sep 17 00:00:00 2001
From: hikari <ftphikari@gmail.com>
Date: Thu, 7 Apr 2022 12:24:53 +0300
Subject: runtime: fix typo

---
 core/runtime/core.odin | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'core/runtime')

diff --git a/core/runtime/core.odin b/core/runtime/core.odin
index a5a190a9c..4ab21d8cf 100644
--- a/core/runtime/core.odin
+++ b/core/runtime/core.odin
@@ -565,7 +565,7 @@ __init_context :: proc "contextless" (c: ^Context) {
 		return
 	}
 
-	// NOTE(bill): Do not initialize these procedures with a call as they are not defined with the "contexless" calling convention
+	// NOTE(bill): Do not initialize these procedures with a call as they are not defined with the "contextless" calling convention
 	c.allocator.procedure = default_allocator_proc
 	c.allocator.data = nil
 
-- 
cgit v1.2.3


From b9dc81d808af3cd4db69bca8cffc0f3bbb48ef8a Mon Sep 17 00:00:00 2001
From: hikari <ftphikari@gmail.com>
Date: Sat, 16 Apr 2022 13:46:36 +0300
Subject: runtime: update comment description

---
 core/runtime/core.odin | 1 +
 1 file changed, 1 insertion(+)

(limited to 'core/runtime')

diff --git a/core/runtime/core.odin b/core/runtime/core.odin
index 4ab21d8cf..4269450de 100644
--- a/core/runtime/core.odin
+++ b/core/runtime/core.odin
@@ -401,6 +401,7 @@ Raw_Cstring :: struct {
 		Linux,
 		Essence,
 		FreeBSD,
+		OpenBSD,
 		WASI,
 		JS,
 		Freestanding,
-- 
cgit v1.2.3


From 9349dfba8fec53f52f77a0c8928e115ec93ff447 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 27 Apr 2022 12:39:45 +0100
Subject: Add new builtin `container_of`

---
 core/runtime/core_builtin.odin | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'core/runtime')

diff --git a/core/runtime/core_builtin.odin b/core/runtime/core_builtin.odin
index 67b1bd37b..13e464a76 100644
--- a/core/runtime/core_builtin.odin
+++ b/core/runtime/core_builtin.odin
@@ -5,6 +5,16 @@ import "core:intrinsics"
 @builtin
 Maybe :: union($T: typeid) #maybe {T}
 
+
+@builtin
+container_of :: #force_inline proc "contextless" (ptr: $P/^$Field_Type, $T: typeid, $field_name: string) -> ^T
+	where intrinsics.type_has_field(T, field_name),
+	      intrinsics.type_field_type(T, field_name) == Field_Type {
+	offset :: offset_of_by_string(T, field_name)
+	return (^T)(uintptr(ptr) - offset) if ptr != nil else nil
+}
+
+
 @thread_local global_default_temp_allocator_data: Default_Temp_Allocator
 
 @builtin
-- 
cgit v1.2.3