From fa6e07d976871a9f1639bfadae708948fdb76a61 Mon Sep 17 00:00:00 2001
From: Feoramund <161657516+Feoramund@users.noreply.github.com>
Date: Tue, 28 May 2024 01:32:20 -0400
Subject: Make `ODIN_OS`, `ODIN_BUILD_MODE` comments congruent to underlying
 data

Sourced from `src/checker.cpp`.
---
 base/runtime/core.odin | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'base/runtime')

diff --git a/base/runtime/core.odin b/base/runtime/core.odin
index 66099e787..4b6a1949e 100644
--- a/base/runtime/core.odin
+++ b/base/runtime/core.odin
@@ -481,7 +481,9 @@ Raw_Soa_Pointer :: struct {
 		Linux,
 		Essence,
 		FreeBSD,
+		Haiku,
 		OpenBSD,
+		NetBSD,
 		WASI,
 		JS,
 		Freestanding,
@@ -508,6 +510,7 @@ Odin_Arch_Type :: type_of(ODIN_ARCH)
 	Odin_Build_Mode_Type :: enum int {
 		Executable,
 		Dynamic,
+		Static,
 		Object,
 		Assembly,
 		LLVM_IR,
-- 
cgit v1.2.3


From 3a0ec3d6a88efcd8cf7466eb54a76dc6e0d027f5 Mon Sep 17 00:00:00 2001
From: Laytan Laats <laytanlaats@hotmail.com>
Date: Fri, 31 May 2024 16:32:27 +0200
Subject: wasm: fix target wasm64p32 runtime procs

LLVM generates calls with `i32` regardless of target, so if a call to
any of these procs was generated this failed to compile.

I opted to fix by changing from `int` to `i32` on wasm64p32 and adding
`#any_int` so existing code keeps working.
---
 base/runtime/procs.odin | 24 +++++++++++++++---------
 1 file changed, 15 insertions(+), 9 deletions(-)

(limited to 'base/runtime')

diff --git a/base/runtime/procs.odin b/base/runtime/procs.odin
index 454574c35..c9347463b 100644
--- a/base/runtime/procs.odin
+++ b/base/runtime/procs.odin
@@ -26,12 +26,18 @@ when ODIN_NO_CRT && ODIN_OS == .Windows {
 		return dst
 	}
 } else when ODIN_NO_CRT || (ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32) {
+	// NOTE: on wasm, calls to these procs are generated (by LLVM) with type `i32` instead of `int`.
+	//
+	// NOTE: `#any_int` is also needed, because calls that we generate (and package code)
+	//       will be using `int` and need to be converted.
+	int_t :: i32 when ODIN_ARCH == .wasm64p32 else int
+
 	@(link_name="memset", linkage="strong", require)
-	memset :: proc "c" (ptr: rawptr, val: i32, len: int) -> rawptr {
+	memset :: proc "c" (ptr: rawptr, val: i32, #any_int len: int_t) -> rawptr {
 		if ptr != nil && len != 0 {
 			b := byte(val)
 			p := ([^]byte)(ptr)
-			for i := 0; i < len; i += 1 {
+			for i := int_t(0); i < len; i += 1 {
 				p[i] = b
 			}
 		}
@@ -39,10 +45,10 @@ when ODIN_NO_CRT && ODIN_OS == .Windows {
 	}
 
 	@(link_name="bzero", linkage="strong", require)
-	bzero :: proc "c" (ptr: rawptr, len: int) -> rawptr {
+	bzero :: proc "c" (ptr: rawptr, #any_int len: int_t) -> rawptr {
 		if ptr != nil && len != 0 {
 			p := ([^]byte)(ptr)
-			for i := 0; i < len; i += 1 {
+			for i := int_t(0); i < len; i += 1 {
 				p[i] = 0
 			}
 		}
@@ -50,7 +56,7 @@ when ODIN_NO_CRT && ODIN_OS == .Windows {
 	}
 
 	@(link_name="memmove", linkage="strong", require)
-	memmove :: proc "c" (dst, src: rawptr, len: int) -> rawptr {
+	memmove :: proc "c" (dst, src: rawptr, #any_int len: int_t) -> rawptr {
 		d, s := ([^]byte)(dst), ([^]byte)(src)
 		if d == s || len == 0 {
 			return dst
@@ -63,7 +69,7 @@ when ODIN_NO_CRT && ODIN_OS == .Windows {
 		}
 
 		if s > d && uintptr(s)-uintptr(d) < uintptr(len) {
-			for i := 0; i < len; i += 1 {
+			for i := int_t(0); i < len; i += 1 {
 				d[i] = s[i]
 			}
 			return dst
@@ -71,10 +77,10 @@ when ODIN_NO_CRT && ODIN_OS == .Windows {
 		return memcpy(dst, src, len)
 	}
 	@(link_name="memcpy", linkage="strong", require)
-	memcpy :: proc "c" (dst, src: rawptr, len: int) -> rawptr {
+	memcpy :: proc "c" (dst, src: rawptr, #any_int len: int_t) -> rawptr {
 		d, s := ([^]byte)(dst), ([^]byte)(src)
 		if d != s {
-			for i := 0; i < len; i += 1 {
+			for i := int_t(0); i < len; i += 1 {
 				d[i] = s[i]
 			}
 		}
@@ -92,4 +98,4 @@ when ODIN_NO_CRT && ODIN_OS == .Windows {
 		}
 		return ptr
 	}
-}
\ No newline at end of file
+}
-- 
cgit v1.2.3


From 4e1dd4ced270ec374c9f45edec03dbc2e2e0b050 Mon Sep 17 00:00:00 2001
From: Feoramund <161657516+Feoramund@users.noreply.github.com>
Date: Mon, 3 Jun 2024 15:40:28 -0400
Subject: Move `Raw_Complex/Quaternion` types to `base:runtime`

---
 base/runtime/core.odin | 6 ++++++
 core/mem/raw.odin      | 7 -------
 2 files changed, 6 insertions(+), 7 deletions(-)

(limited to 'base/runtime')

diff --git a/base/runtime/core.odin b/base/runtime/core.odin
index 4b6a1949e..9b7a3f613 100644
--- a/base/runtime/core.odin
+++ b/base/runtime/core.odin
@@ -470,6 +470,12 @@ Raw_Soa_Pointer :: struct {
 	index: int,
 }
 
+Raw_Complex64     :: struct {real, imag: f32}
+Raw_Complex128    :: struct {real, imag: f64}
+Raw_Quaternion128 :: struct {imag, jmag, kmag: f32, real: f32}
+Raw_Quaternion256 :: struct {imag, jmag, kmag: f64, real: f64}
+Raw_Quaternion128_Vector_Scalar :: struct {vector: [3]f32, scalar: f32}
+Raw_Quaternion256_Vector_Scalar :: struct {vector: [3]f64, scalar: f64}
 
 
 /*
diff --git a/core/mem/raw.odin b/core/mem/raw.odin
index 56790e959..4f37ce5ab 100644
--- a/core/mem/raw.odin
+++ b/core/mem/raw.odin
@@ -11,13 +11,6 @@ Raw_Dynamic_Array :: runtime.Raw_Dynamic_Array
 Raw_Map           :: runtime.Raw_Map
 Raw_Soa_Pointer   :: runtime.Raw_Soa_Pointer
 
-Raw_Complex64     :: struct {real, imag: f32}
-Raw_Complex128    :: struct {real, imag: f64}
-Raw_Quaternion128 :: struct {imag, jmag, kmag: f32, real: f32}
-Raw_Quaternion256 :: struct {imag, jmag, kmag: f64, real: f64}
-Raw_Quaternion128_Vector_Scalar :: struct {vector: [3]f32, scalar: f32}
-Raw_Quaternion256_Vector_Scalar :: struct {vector: [3]f64, scalar: f64}
-
 make_any :: proc "contextless" (data: rawptr, id: typeid) -> any {
 	return transmute(any)Raw_Any{data, id}
 }
-- 
cgit v1.2.3


From 97f1d12e042b1400a4af84447959ef17e1b57f4a Mon Sep 17 00:00:00 2001
From: Feoramund <161657516+Feoramund@users.noreply.github.com>
Date: Mon, 3 Jun 2024 15:41:14 -0400
Subject: Add missing `Raw_*` types for complex and quaternion

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

(limited to 'base/runtime')

diff --git a/base/runtime/core.odin b/base/runtime/core.odin
index 9b7a3f613..47b9a690c 100644
--- a/base/runtime/core.odin
+++ b/base/runtime/core.odin
@@ -470,10 +470,13 @@ Raw_Soa_Pointer :: struct {
 	index: int,
 }
 
+Raw_Complex32     :: struct {real, imag: f16}
 Raw_Complex64     :: struct {real, imag: f32}
 Raw_Complex128    :: struct {real, imag: f64}
+Raw_Quaternion64  :: struct {imag, jmag, kmag: f16, real: f16}
 Raw_Quaternion128 :: struct {imag, jmag, kmag: f32, real: f32}
 Raw_Quaternion256 :: struct {imag, jmag, kmag: f64, real: f64}
+Raw_Quaternion64_Vector_Scalar  :: struct {vector: [3]f16, scalar: f16}
 Raw_Quaternion128_Vector_Scalar :: struct {vector: [3]f32, scalar: f32}
 Raw_Quaternion256_Vector_Scalar :: struct {vector: [3]f64, scalar: f64}
 
-- 
cgit v1.2.3


From b2f9f0af689ff6ffdd9db149c04a99cd6b2a46b4 Mon Sep 17 00:00:00 2001
From: Feoramund <161657516+Feoramund@users.noreply.github.com>
Date: Tue, 4 Jun 2024 19:01:30 -0400
Subject: Fix some typos

---
 base/runtime/docs.odin |   2 +-
 core/odin/ast/ast.odin |   2 +-
 core/time/iso8061.odin | 113 -------------------------------------------------
 core/time/iso8601.odin | 113 +++++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 115 insertions(+), 115 deletions(-)
 delete mode 100644 core/time/iso8061.odin
 create mode 100644 core/time/iso8601.odin

(limited to 'base/runtime')

diff --git a/base/runtime/docs.odin b/base/runtime/docs.odin
index 865eeb9ef..f6b439aa0 100644
--- a/base/runtime/docs.odin
+++ b/base/runtime/docs.odin
@@ -157,7 +157,7 @@ __dynamic_map_get // dynamic map calls
 __dynamic_map_set // dynamic map calls
 
 
-## Dynamic literals ([dymamic]T and map[K]V) (can be disabled with -no-dynamic-literals)
+## Dynamic literals ([dynamic]T and map[K]V) (can be disabled with -no-dynamic-literals)
 
 __dynamic_array_reserve
 __dynamic_array_append
diff --git a/core/odin/ast/ast.odin b/core/odin/ast/ast.odin
index 7891fb12d..229f03d3d 100644
--- a/core/odin/ast/ast.odin
+++ b/core/odin/ast/ast.odin
@@ -753,7 +753,7 @@ Array_Type :: struct {
 	using node: Expr,
 	open:  tokenizer.Pos,
 	tag:   ^Expr,
-	len:   ^Expr, // Ellipsis node for [?]T arrray types, nil for slice types
+	len:   ^Expr, // Ellipsis node for [?]T array types, nil for slice types
 	close: tokenizer.Pos,
 	elem:  ^Expr,
 }
diff --git a/core/time/iso8061.odin b/core/time/iso8061.odin
deleted file mode 100644
index 528e0b00a..000000000
--- a/core/time/iso8061.odin
+++ /dev/null
@@ -1,113 +0,0 @@
-package time
-// Parsing ISO 8601 date/time strings into time.Time.
-
-import dt "core:time/datetime"
-
-// Parses an ISO 8601 string and returns Time in UTC, with any UTC offset applied to it.
-// Only 4-digit years are accepted.
-// Optional pointer to boolean `is_leap` will return `true` if the moment was a leap second.
-// Leap seconds are smeared into 23:59:59.
-iso8601_to_time_utc :: proc(iso_datetime: string, is_leap: ^bool = nil) -> (res: Time, consumed: int) {
-	offset: int
-
-	res, offset, consumed = iso8601_to_time_and_offset(iso_datetime, is_leap)
-	res._nsec += (i64(-offset) * i64(Minute))
-	return res, consumed
-}
-
-// Parses an ISO 8601 string and returns Time and a UTC offset in minutes.
-// e.g. 1985-04-12T23:20:50.52Z
-// Note: Only 4-digit years are accepted.
-// Optional pointer to boolean `is_leap` will return `true` if the moment was a leap second.
-// Leap seconds are smeared into 23:59:59.
-iso8601_to_time_and_offset :: proc(iso_datetime: string, is_leap: ^bool = nil) -> (res: Time, utc_offset: int, consumed: int) {
-	moment, offset, leap_second, count := iso8601_to_components(iso_datetime)
-	if count == 0 {
-		return
-	}
-
-	if is_leap != nil {
-		is_leap^ = leap_second
-	}
-
-	if _res, ok := datetime_to_time(moment.year, moment.month, moment.day, moment.hour, moment.minute, moment.second, moment.nano); !ok {
-		return {}, 0, 0
-	} else {
-		return _res, offset, count
-	}
-}
-
-// Parses an ISO 8601 string and returns Time and a UTC offset in minutes.
-// e.g. 1985-04-12T23:20:50.52Z
-// Performs no validation on whether components are valid, e.g. it'll return hour = 25 if that's what it's given
-iso8601_to_components :: proc(iso_datetime: string) -> (res: dt.DateTime, utc_offset: int, is_leap: bool, consumed: int) {
-	moment, offset, count, leap_second, ok := _iso8601_to_components(iso_datetime)
-	if !ok {
-		return
-	}
-	return moment, offset, leap_second, count
-}
-
-// Parses an ISO 8601 string and returns datetime.DateTime.
-// Performs no validation on whether components are valid, e.g. it'll return hour = 25 if that's what it's given
-@(private)
-_iso8601_to_components :: proc(iso_datetime: string) -> (res: dt.DateTime, utc_offset: int, consumed: int, is_leap: bool, ok: bool) {
-	// A compliant date is at minimum 20 characters long, e.g. YYYY-MM-DDThh:mm:ssZ
-	(len(iso_datetime) >= 20) or_return
-
-	// Scan and eat YYYY-MM-DD[Tt], then scan and eat HH:MM:SS, leave separator
-	year   := scan_digits(iso_datetime[0:], "-",   4) or_return
-	month  := scan_digits(iso_datetime[5:], "-",   2) or_return
-	day    := scan_digits(iso_datetime[8:], "Tt ", 2) or_return
-	hour   := scan_digits(iso_datetime[11:], ":",  2) or_return
-	minute := scan_digits(iso_datetime[14:], ":",  2) or_return
-	second := scan_digits(iso_datetime[17:], "",   2) or_return
-	nanos  := 0
-	count  := 19
-
-	// Scan fractional seconds
-	if iso_datetime[count] == '.' {
-		count += 1 // consume '.'
-		multiplier := 100_000_000
-		for digit in iso_datetime[count:] {
-			if multiplier >= 1 && int(digit) >= '0' && int(digit) <= '9' {
-				nanos += int(digit - '0') * multiplier
-				multiplier /= 10
-				count += 1
-			} else {
-				break
-			}
-		}
-	}
-
-	// Leap second handling
-	if minute == 59 && second == 60 {
-		second = 59
-		is_leap = true
-	}
-
-	err: dt.Error
-	if res, err = dt.components_to_datetime(year, month, day, hour, minute, second, nanos); err != .None {
-		return {}, 0, 0, false, false
-	}
-
-	if len(iso_datetime[count:]) == 0 {
-		return res, utc_offset, count, is_leap, true
-	}
-
-	// Scan UTC offset
-	switch iso_datetime[count] {
-	case 'Z', 'z':
-		utc_offset = 0
-		count += 1
-	case '+', '-':
-		(len(iso_datetime[count:]) >= 6) or_return
-		offset_hour   := scan_digits(iso_datetime[count+1:], ":", 2) or_return
-		offset_minute := scan_digits(iso_datetime[count+4:], "",  2) or_return
-
-		utc_offset = 60 * offset_hour + offset_minute
-		utc_offset *= -1 if iso_datetime[count] == '-' else 1
-		count += 6
-	}
-	return res, utc_offset, count, is_leap, true
-}
\ No newline at end of file
diff --git a/core/time/iso8601.odin b/core/time/iso8601.odin
new file mode 100644
index 000000000..528e0b00a
--- /dev/null
+++ b/core/time/iso8601.odin
@@ -0,0 +1,113 @@
+package time
+// Parsing ISO 8601 date/time strings into time.Time.
+
+import dt "core:time/datetime"
+
+// Parses an ISO 8601 string and returns Time in UTC, with any UTC offset applied to it.
+// Only 4-digit years are accepted.
+// Optional pointer to boolean `is_leap` will return `true` if the moment was a leap second.
+// Leap seconds are smeared into 23:59:59.
+iso8601_to_time_utc :: proc(iso_datetime: string, is_leap: ^bool = nil) -> (res: Time, consumed: int) {
+	offset: int
+
+	res, offset, consumed = iso8601_to_time_and_offset(iso_datetime, is_leap)
+	res._nsec += (i64(-offset) * i64(Minute))
+	return res, consumed
+}
+
+// Parses an ISO 8601 string and returns Time and a UTC offset in minutes.
+// e.g. 1985-04-12T23:20:50.52Z
+// Note: Only 4-digit years are accepted.
+// Optional pointer to boolean `is_leap` will return `true` if the moment was a leap second.
+// Leap seconds are smeared into 23:59:59.
+iso8601_to_time_and_offset :: proc(iso_datetime: string, is_leap: ^bool = nil) -> (res: Time, utc_offset: int, consumed: int) {
+	moment, offset, leap_second, count := iso8601_to_components(iso_datetime)
+	if count == 0 {
+		return
+	}
+
+	if is_leap != nil {
+		is_leap^ = leap_second
+	}
+
+	if _res, ok := datetime_to_time(moment.year, moment.month, moment.day, moment.hour, moment.minute, moment.second, moment.nano); !ok {
+		return {}, 0, 0
+	} else {
+		return _res, offset, count
+	}
+}
+
+// Parses an ISO 8601 string and returns Time and a UTC offset in minutes.
+// e.g. 1985-04-12T23:20:50.52Z
+// Performs no validation on whether components are valid, e.g. it'll return hour = 25 if that's what it's given
+iso8601_to_components :: proc(iso_datetime: string) -> (res: dt.DateTime, utc_offset: int, is_leap: bool, consumed: int) {
+	moment, offset, count, leap_second, ok := _iso8601_to_components(iso_datetime)
+	if !ok {
+		return
+	}
+	return moment, offset, leap_second, count
+}
+
+// Parses an ISO 8601 string and returns datetime.DateTime.
+// Performs no validation on whether components are valid, e.g. it'll return hour = 25 if that's what it's given
+@(private)
+_iso8601_to_components :: proc(iso_datetime: string) -> (res: dt.DateTime, utc_offset: int, consumed: int, is_leap: bool, ok: bool) {
+	// A compliant date is at minimum 20 characters long, e.g. YYYY-MM-DDThh:mm:ssZ
+	(len(iso_datetime) >= 20) or_return
+
+	// Scan and eat YYYY-MM-DD[Tt], then scan and eat HH:MM:SS, leave separator
+	year   := scan_digits(iso_datetime[0:], "-",   4) or_return
+	month  := scan_digits(iso_datetime[5:], "-",   2) or_return
+	day    := scan_digits(iso_datetime[8:], "Tt ", 2) or_return
+	hour   := scan_digits(iso_datetime[11:], ":",  2) or_return
+	minute := scan_digits(iso_datetime[14:], ":",  2) or_return
+	second := scan_digits(iso_datetime[17:], "",   2) or_return
+	nanos  := 0
+	count  := 19
+
+	// Scan fractional seconds
+	if iso_datetime[count] == '.' {
+		count += 1 // consume '.'
+		multiplier := 100_000_000
+		for digit in iso_datetime[count:] {
+			if multiplier >= 1 && int(digit) >= '0' && int(digit) <= '9' {
+				nanos += int(digit - '0') * multiplier
+				multiplier /= 10
+				count += 1
+			} else {
+				break
+			}
+		}
+	}
+
+	// Leap second handling
+	if minute == 59 && second == 60 {
+		second = 59
+		is_leap = true
+	}
+
+	err: dt.Error
+	if res, err = dt.components_to_datetime(year, month, day, hour, minute, second, nanos); err != .None {
+		return {}, 0, 0, false, false
+	}
+
+	if len(iso_datetime[count:]) == 0 {
+		return res, utc_offset, count, is_leap, true
+	}
+
+	// Scan UTC offset
+	switch iso_datetime[count] {
+	case 'Z', 'z':
+		utc_offset = 0
+		count += 1
+	case '+', '-':
+		(len(iso_datetime[count:]) >= 6) or_return
+		offset_hour   := scan_digits(iso_datetime[count+1:], ":", 2) or_return
+		offset_minute := scan_digits(iso_datetime[count+4:], "",  2) or_return
+
+		utc_offset = 60 * offset_hour + offset_minute
+		utc_offset *= -1 if iso_datetime[count] == '-' else 1
+		count += 6
+	}
+	return res, utc_offset, count, is_leap, true
+}
\ No newline at end of file
-- 
cgit v1.2.3


From 8455e159f5f6c6b1a3553d82ea891232fd56d336 Mon Sep 17 00:00:00 2001
From: Laytan Laats <laytanlaats@hotmail.com>
Date: Wed, 5 Jun 2024 20:57:39 +0200
Subject: improve orca target

---
 base/runtime/core.odin                       | 15 ++++++++--
 base/runtime/default_allocators_general.odin |  2 +-
 base/runtime/entry_wasm.odin                 | 36 ++++++++++++++++-------
 base/runtime/error_checks.odin               |  4 +++
 base/runtime/heap_allocator_orca.odin        | 29 +++++++++++++++++++
 base/runtime/heap_allocator_other.odin       |  2 +-
 base/runtime/os_specific_orca.odin           | 43 ++++++++++++++++++++++++++++
 base/runtime/procs.odin                      |  2 +-
 core/fmt/fmt_os.odin                         |  1 +
 core/time/time_orca.odin                     | 24 ++++++++++++++++
 src/build_settings.cpp                       |  9 +++---
 src/linker.cpp                               | 36 ++++++++++++++++-------
 src/main.cpp                                 | 28 ++++++++++++++++++
 13 files changed, 200 insertions(+), 31 deletions(-)
 create mode 100644 base/runtime/heap_allocator_orca.odin
 create mode 100644 base/runtime/os_specific_orca.odin
 create mode 100644 core/time/time_orca.odin

(limited to 'base/runtime')

diff --git a/base/runtime/core.odin b/base/runtime/core.odin
index 47b9a690c..3e24060af 100644
--- a/base/runtime/core.odin
+++ b/base/runtime/core.odin
@@ -701,7 +701,7 @@ default_assertion_failure_proc :: proc(prefix, message: string, loc: Source_Code
 	when ODIN_OS == .Freestanding {
 		// Do nothing
 	} else {
-		when !ODIN_DISABLE_ASSERT {
+		when ODIN_OS != .Orca && !ODIN_DISABLE_ASSERT {
 			print_caller_location(loc)
 			print_string(" ")
 		}
@@ -710,7 +710,18 @@ default_assertion_failure_proc :: proc(prefix, message: string, loc: Source_Code
 			print_string(": ")
 			print_string(message)
 		}
-		print_byte('\n')
+
+		when ODIN_OS == .Orca {
+			assert_fail(
+				cstring(raw_data(loc.file_path)),
+				cstring(raw_data(loc.procedure)),
+				loc.line,
+				"",
+				cstring(raw_data(orca_stderr_buffer[:orca_stderr_buffer_idx])),
+			)
+		} else {
+			print_byte('\n')
+		}
 	}
 	trap()
 }
diff --git a/base/runtime/default_allocators_general.odin b/base/runtime/default_allocators_general.odin
index ab4dd1db8..64af6c904 100644
--- a/base/runtime/default_allocators_general.odin
+++ b/base/runtime/default_allocators_general.odin
@@ -6,7 +6,7 @@ when ODIN_DEFAULT_TO_NIL_ALLOCATOR {
 } else when ODIN_DEFAULT_TO_PANIC_ALLOCATOR {
 	default_allocator_proc :: panic_allocator_proc
 	default_allocator :: panic_allocator
-} else when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 {
+} else when ODIN_OS != .Orca && (ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32) {
 	default_allocator :: default_wasm_allocator
 	default_allocator_proc :: wasm_allocator_proc
 } else {
diff --git a/base/runtime/entry_wasm.odin b/base/runtime/entry_wasm.odin
index c608942ba..a24c6f4b7 100644
--- a/base/runtime/entry_wasm.odin
+++ b/base/runtime/entry_wasm.odin
@@ -6,15 +6,29 @@ package runtime
 import "base: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()
+	when ODIN_OS == .Orca {
+		@(linkage="strong", require, export)
+		oc_on_init :: proc "c" () {
+			context = default_context()
+			#force_no_inline _startup_runtime()
+			intrinsics.__entry_point()
+		}
+		@(linkage="strong", require, export)
+		oc_on_terminate :: proc "c" () {
+			context = default_context()
+			#force_no_inline _cleanup_runtime()
+		}
+	} else {
+		@(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()
+		}
 	}
-	@(link_name="_end", linkage="strong", require, export)
-	_end :: proc "c" () {
-		context = default_context()
-		#force_no_inline _cleanup_runtime()
-	}
-}
\ No newline at end of file
+}
diff --git a/base/runtime/error_checks.odin b/base/runtime/error_checks.odin
index 742e06a71..32a895c3f 100644
--- a/base/runtime/error_checks.odin
+++ b/base/runtime/error_checks.odin
@@ -4,6 +4,8 @@ package runtime
 bounds_trap :: proc "contextless" () -> ! {
 	when ODIN_OS == .Windows {
 		windows_trap_array_bounds()
+	} else when ODIN_OS == .Orca {
+		abort_ext("", "", 0, "bounds trap")
 	} else {
 		trap()
 	}
@@ -13,6 +15,8 @@ bounds_trap :: proc "contextless" () -> ! {
 type_assertion_trap :: proc "contextless" () -> ! {
 	when ODIN_OS == .Windows {
 		windows_trap_type_assertion()
+	} else when ODIN_OS == .Orca {
+		abort_ext("", "", 0, "type assertion trap")
 	} else {
 		trap()
 	}
diff --git a/base/runtime/heap_allocator_orca.odin b/base/runtime/heap_allocator_orca.odin
new file mode 100644
index 000000000..c22a67ca1
--- /dev/null
+++ b/base/runtime/heap_allocator_orca.odin
@@ -0,0 +1,29 @@
+//+build orca
+//+private
+package runtime
+
+foreign {
+	@(link_name="malloc")   _orca_malloc   :: proc "c" (size: int) -> rawptr ---
+	@(link_name="calloc")   _orca_calloc   :: proc "c" (num, size: int) -> rawptr ---
+	@(link_name="free")     _orca_free     :: proc "c" (ptr: rawptr) ---
+	@(link_name="realloc")  _orca_realloc  :: proc "c" (ptr: rawptr, size: int) -> rawptr ---
+}
+
+_heap_alloc :: proc(size: int, zero_memory := true) -> rawptr {
+	if size <= 0 {
+		return nil
+	}
+	if zero_memory {
+		return _orca_calloc(1, size)
+	} else {
+		return _orca_malloc(size)
+	}
+}
+
+_heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
+	return _orca_realloc(ptr, new_size)
+}
+
+_heap_free :: proc(ptr: rawptr) {
+	_orca_free(ptr)
+}
diff --git a/base/runtime/heap_allocator_other.odin b/base/runtime/heap_allocator_other.odin
index 45049c7e9..74536ada9 100644
--- a/base/runtime/heap_allocator_other.odin
+++ b/base/runtime/heap_allocator_other.odin
@@ -12,4 +12,4 @@ _heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
 
 _heap_free :: proc(ptr: rawptr) {
 	unimplemented("base:runtime 'heap_free' procedure is not supported on this platform")
-}
\ No newline at end of file
+}
diff --git a/base/runtime/os_specific_orca.odin b/base/runtime/os_specific_orca.odin
new file mode 100644
index 000000000..b6f5930ab
--- /dev/null
+++ b/base/runtime/os_specific_orca.odin
@@ -0,0 +1,43 @@
+//+build orca
+//+private
+package runtime
+
+import "base:intrinsics"
+
+// Constants allowing to specify the level of logging verbosity.
+log_level :: enum u32 {
+	// Only errors are logged.
+	ERROR = 0,
+	// Only warnings and errors are logged.
+	WARNING = 1,
+	// All messages are logged.
+	INFO = 2,
+	COUNT = 3,
+}
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+	abort_ext   :: proc(file: cstring, function: cstring, line: i32, fmt: cstring, #c_vararg args: ..any) -> ! ---
+	assert_fail :: proc(file: cstring, function: cstring, line: i32, src: cstring, fmt: cstring, #c_vararg args: ..any) -> ! ---
+	log_ext     :: proc(level: log_level, function: cstring, file: cstring, line: i32, fmt: cstring, #c_vararg args: ..any) ---
+}
+
+// NOTE: This is all pretty gross, don't look.
+
+// WASM is single threaded so this should be fine.
+orca_stderr_buffer:     [4096]byte
+orca_stderr_buffer_idx: int
+
+_stderr_write :: proc "contextless" (data: []byte) -> (int, _OS_Errno) {
+	for b in data {
+		orca_stderr_buffer[orca_stderr_buffer_idx] = b
+		orca_stderr_buffer_idx += 1
+
+		if b == '\n' || orca_stderr_buffer_idx == len(orca_stderr_buffer)-1 {
+			log_ext(.ERROR, "", "", 0, cstring(raw_data(orca_stderr_buffer[:orca_stderr_buffer_idx])))
+			orca_stderr_buffer_idx = 0
+		}
+	}
+
+	return len(data), 0
+}
diff --git a/base/runtime/procs.odin b/base/runtime/procs.odin
index c9347463b..002a6501f 100644
--- a/base/runtime/procs.odin
+++ b/base/runtime/procs.odin
@@ -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 == .wasm64p32) {
+} else when ODIN_NO_CRT || (ODIN_OS != .Orca && (ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32)) {
 	// NOTE: on wasm, calls to these procs are generated (by LLVM) with type `i32` instead of `int`.
 	//
 	// NOTE: `#any_int` is also needed, because calls that we generate (and package code)
diff --git a/core/fmt/fmt_os.odin b/core/fmt/fmt_os.odin
index a403dcd65..9de0d43be 100644
--- a/core/fmt/fmt_os.odin
+++ b/core/fmt/fmt_os.odin
@@ -1,5 +1,6 @@
 //+build !freestanding
 //+build !js
+//+build !orca
 package fmt
 
 import "base:runtime"
diff --git a/core/time/time_orca.odin b/core/time/time_orca.odin
new file mode 100644
index 000000000..d222c8247
--- /dev/null
+++ b/core/time/time_orca.odin
@@ -0,0 +1,24 @@
+//+private
+//+build orca
+package time
+
+_IS_SUPPORTED :: false
+
+_now :: proc "contextless" () -> Time {
+	return {}
+}
+
+_sleep :: proc "contextless" (d: Duration) {
+}
+
+_tick_now :: proc "contextless" () -> Tick {
+	// mul_div_u64 :: proc "contextless" (val, num, den: i64) -> i64 {
+	// 	q := val / den
+	// 	r := val % den
+	// 	return q * num + r * num / den
+	// }
+	return {}
+}
+
+_yield :: proc "contextless" () {
+}
diff --git a/src/build_settings.cpp b/src/build_settings.cpp
index 3c7ff3f1e..8a08c2b34 100644
--- a/src/build_settings.cpp
+++ b/src/build_settings.cpp
@@ -1080,8 +1080,7 @@ gb_global TargetMetrics target_orca_wasm32 = {
 	TargetOs_orca,
 	TargetArch_wasm32,
 	4, 4, 8, 16,
-	str_lit("wasm32-wasi-js"),
-	// str_lit("e-m:e-p:32:32-i64:64-n32:64-S128"),
+	str_lit("wasm32-freestanding-js"),
 };
 
 
@@ -1161,6 +1160,7 @@ gb_global NamedTargetMetrics named_targets[] = {
 	{ str_lit("freestanding_wasm32"), &target_freestanding_wasm32 },
 	{ str_lit("wasi_wasm32"),         &target_wasi_wasm32 },
 	{ str_lit("js_wasm32"),           &target_js_wasm32 },
+	{ str_lit("orca_wasm32"),         &target_orca_wasm32 },
 
 	{ str_lit("freestanding_wasm64p32"), &target_freestanding_wasm64p32 },
 	{ str_lit("js_wasm64p32"),           &target_js_wasm64p32 },
@@ -2032,11 +2032,10 @@ gb_internal void init_build_context(TargetMetrics *cross_target, Subtarget subta
 		// }
 		if (bc->no_entry_point || bc->metrics.os == TargetOs_orca) {
 			link_flags = gb_string_appendc(link_flags, "--no-entry ");
-			bc->no_entry_point = true; // just in case for the "orca" target
 		}
-		
+
 		bc->link_flags = make_string_c(link_flags);
-		
+
 		// Disallow on wasm
 		bc->use_separate_modules = false;
 	} else {
diff --git a/src/linker.cpp b/src/linker.cpp
index b699c0dfb..91055a604 100644
--- a/src/linker.cpp
+++ b/src/linker.cpp
@@ -13,6 +13,7 @@ struct LinkerData {
 };
 
 gb_internal i32 system_exec_command_line_app(char const *name, char const *fmt, ...);
+gb_internal bool system_exec_command_line_app_output(char const *command, gbString *output);
 
 #if defined(GB_SYSTEM_OSX)
 gb_internal void linker_enable_system_library_linking(LinkerData *ld) {
@@ -69,27 +70,42 @@ gb_internal i32 linker_stage(LinkerData *gen) {
 	if (is_arch_wasm()) {
 		timings_start_section(timings, str_lit("wasm-ld"));
 
-		String extra_orca_flags = {};
+		gbString extra_orca_flags = gb_string_make(temporary_allocator(), "");
+
+		gbString inputs = gb_string_make(temporary_allocator(), "");		
+		inputs = gb_string_append_fmt(inputs, "\"%.*s.o\"", LIT(output_filename));
 
-	#if defined(GB_SYSTEM_WINDOWS)
 		if (build_context.metrics.os == TargetOs_orca) {
-			extra_orca_flags = str_lit(" W:/orca/installation/dev-afb9591/bin/liborca_wasm.a --export-dynamic");
+			// TODO: Orca windows.
+
+			gbString orca_sdk_path = gb_string_make(temporary_allocator(), "");
+			if (!system_exec_command_line_app_output("orca sdk-path", &orca_sdk_path)) {
+				gb_printf_err("executing `orca sdk-path` failed, make sure Orca is installed and added to your path\n");
+				return 1;
+			}
+			if (gb_string_length(orca_sdk_path) == 0) {
+				gb_printf_err("executing `orca sdk-path` did not produce output\n");
+				return 1;
+			}
+			inputs = gb_string_append_fmt(inputs, " \"%s/orca-libc/lib/crt1.o\" \"%s/orca-libc/lib/libc.o\"", orca_sdk_path, orca_sdk_path);
+
+			extra_orca_flags = gb_string_append_fmt(extra_orca_flags, " -L \"%s/bin\" -lorca_wasm --export-dynamic", orca_sdk_path);
 		}
 
+
+	#if defined(GB_SYSTEM_WINDOWS)
 		result = system_exec_command_line_app("wasm-ld",
 			"\"%.*s\\bin\\wasm-ld\" \"%.*s.o\" -o \"%.*s\" %.*s %.*s %.*s",
 			LIT(build_context.ODIN_ROOT),
 			LIT(output_filename), LIT(output_filename), LIT(build_context.link_flags), LIT(build_context.extra_linker_flags),
 			LIT(extra_orca_flags));
 	#else
-		if (build_context.metrics.os == TargetOs_orca) {
-					extra_orca_flags = str_lit(" -L . -lorca --export-dynamic");
-				}
-
 		result = system_exec_command_line_app("wasm-ld",
-			"wasm-ld \"%.*s.o\" -o \"%.*s\" %.*s %.*s %.*s",
-			LIT(output_filename), LIT(output_filename), LIT(build_context.link_flags), LIT(build_context.extra_linker_flags),
-			LIT(extra_orca_flags));
+			"wasm-ld %s -o \"%.*s\" %.*s %.*s %s",
+			inputs, LIT(output_filename),
+			LIT(build_context.link_flags),
+			LIT(build_context.extra_linker_flags),
+			extra_orca_flags);
 	#endif
 		return result;
 	}
diff --git a/src/main.cpp b/src/main.cpp
index 3ca024ed9..a30cad059 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -155,6 +155,34 @@ gb_internal i32 system_exec_command_line_app(char const *name, char const *fmt,
 	return exit_code;
 }
 
+// TODO: windows.
+gb_internal bool system_exec_command_line_app_output(char const *command, gbString *output) {
+	GB_ASSERT(output);
+
+	u8 buffer[256];
+	FILE *stream;
+	stream = popen(command, "r");
+	if (!stream) {
+		return false;
+	}
+	defer (pclose(stream));
+
+	while (!feof(stream)) {
+		size_t n = fread(buffer, 1, 255, stream);
+		*output = gb_string_append_length(*output, buffer, n);
+
+		if (ferror(stream)) {
+			return false;
+		}
+	}
+
+	if (build_context.show_system_calls) {
+		gb_printf_err("[SYSTEM CALL OUTPUT] %s -> %s\n", command, *output);
+	}
+
+	return true;
+}
+
 gb_internal Array<String> setup_args(int argc, char const **argv) {
 	gbAllocator a = heap_allocator();
 
-- 
cgit v1.2.3


From 3a9b86628a484aa03b594599653c1cab4b916c8e Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Thu, 6 Jun 2024 15:23:52 +0100
Subject: Add `@(rodata)` and `@(static, rodata)` where appropriate

---
 base/runtime/internal.odin      |  4 ++--
 core/math/cmplx/cmplx_trig.odin |  2 +-
 core/math/math.odin             | 18 +++++++++---------
 core/math/math_gamma.odin       |  6 +++---
 core/math/math_lgamma.odin      | 14 +++++++-------
 core/math/math_sincos.odin      |  2 +-
 core/math/rand/exp.odin         |  6 +++---
 core/math/rand/normal.odin      |  6 +++---
 core/os/os2/internal_util.odin  |  2 +-
 core/strconv/generic_float.odin |  2 +-
 core/strconv/strconv.odin       |  2 +-
 core/time/time.odin             |  1 +
 core/unicode/tables.odin        | 10 ++++++++++
 13 files changed, 43 insertions(+), 32 deletions(-)

(limited to 'base/runtime')

diff --git a/base/runtime/internal.odin b/base/runtime/internal.odin
index 8e1b3d633..378eea256 100644
--- a/base/runtime/internal.odin
+++ b/base/runtime/internal.odin
@@ -483,7 +483,7 @@ quaternion256_ne :: #force_inline proc "contextless" (a, b: quaternion256) -> bo
 string_decode_rune :: #force_inline proc "contextless" (s: string) -> (rune, int) {
 	// NOTE(bill): Duplicated here to remove dependency on package unicode/utf8
 
-	@static accept_sizes := [256]u8{
+	@(static, rodata) accept_sizes := [256]u8{
 		0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x00-0x0f
 		0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x10-0x1f
 		0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x20-0x2f
@@ -504,7 +504,7 @@ string_decode_rune :: #force_inline proc "contextless" (s: string) -> (rune, int
 	}
 	Accept_Range :: struct {lo, hi: u8}
 
-	@static accept_ranges := [5]Accept_Range{
+	@(static, rodata) accept_ranges := [5]Accept_Range{
 		{0x80, 0xbf},
 		{0xa0, 0xbf},
 		{0x80, 0x9f},
diff --git a/core/math/cmplx/cmplx_trig.odin b/core/math/cmplx/cmplx_trig.odin
index 7ca404fab..15e757506 100644
--- a/core/math/cmplx/cmplx_trig.odin
+++ b/core/math/cmplx/cmplx_trig.odin
@@ -350,7 +350,7 @@ _reduce_pi_f64 :: proc "contextless" (x: f64) -> f64 #no_bounds_check {
 	// that is, 1/PI = SUM bdpi[i]*2^(-64*i).
 	// 19 64-bit digits give 1216 bits of precision
 	// to handle the largest possible f64 exponent.
-	@static bdpi := [?]u64{
+	@(static, rodata) bdpi := [?]u64{
 		0x0000000000000000,
 		0x517cc1b727220a94,
 		0xfe13abe8fa9a6ee0,
diff --git a/core/math/math.odin b/core/math/math.odin
index 8d85c2381..3d0ab3c4e 100644
--- a/core/math/math.odin
+++ b/core/math/math.odin
@@ -130,10 +130,10 @@ pow10 :: proc{
 
 @(require_results)
 pow10_f16 :: proc "contextless" (n: f16) -> f16 {
-	@static pow10_pos_tab := [?]f16{
+	@(static, rodata) pow10_pos_tab := [?]f16{
 		1e00, 1e01, 1e02, 1e03, 1e04,
 	}
-	@static pow10_neg_tab := [?]f16{
+	@(static, rodata) pow10_neg_tab := [?]f16{
 		1e-00, 1e-01, 1e-02, 1e-03, 1e-04, 1e-05, 1e-06, 1e-07,
 	}
 
@@ -151,13 +151,13 @@ pow10_f16 :: proc "contextless" (n: f16) -> f16 {
 
 @(require_results)
 pow10_f32 :: proc "contextless" (n: f32) -> f32 {
-	@static pow10_pos_tab := [?]f32{
+	@(static, rodata) pow10_pos_tab := [?]f32{
 		1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,
 		1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
 		1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29,
 		1e30, 1e31, 1e32, 1e33, 1e34, 1e35, 1e36, 1e37, 1e38,
 	}
-	@static pow10_neg_tab := [?]f32{
+	@(static, rodata) pow10_neg_tab := [?]f32{
 		1e-00, 1e-01, 1e-02, 1e-03, 1e-04, 1e-05, 1e-06, 1e-07, 1e-08, 1e-09,
 		1e-10, 1e-11, 1e-12, 1e-13, 1e-14, 1e-15, 1e-16, 1e-17, 1e-18, 1e-19,
 		1e-20, 1e-21, 1e-22, 1e-23, 1e-24, 1e-25, 1e-26, 1e-27, 1e-28, 1e-29,
@@ -179,16 +179,16 @@ pow10_f32 :: proc "contextless" (n: f32) -> f32 {
 
 @(require_results)
 pow10_f64 :: proc "contextless" (n: f64) -> f64 {
-	@static pow10_tab := [?]f64{
+	@(static, rodata) pow10_tab := [?]f64{
 		1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,
 		1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
 		1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29,
 		1e30, 1e31,
 	}
-	@static pow10_pos_tab32 := [?]f64{
+	@(static, rodata) pow10_pos_tab32 := [?]f64{
 		1e00, 1e32, 1e64, 1e96, 1e128, 1e160, 1e192, 1e224, 1e256, 1e288,
 	}
-	@static pow10_neg_tab32 := [?]f64{
+	@(static, rodata) pow10_neg_tab32 := [?]f64{
 		1e-00, 1e-32, 1e-64, 1e-96, 1e-128, 1e-160, 1e-192, 1e-224, 1e-256, 1e-288, 1e-320,
 	}
 
@@ -1274,7 +1274,7 @@ binomial :: proc "contextless" (n, k: int) -> int {
 @(require_results)
 factorial :: proc "contextless" (n: int) -> int {
 	when size_of(int) == size_of(i64) {
-		@static table := [21]int{
+		@(static, rodata) table := [21]int{
 			1,
 			1,
 			2,
@@ -1298,7 +1298,7 @@ factorial :: proc "contextless" (n: int) -> int {
 			2_432_902_008_176_640_000,
 		}
 	} else {
-		@static table := [13]int{
+		@(static, rodata) table := [13]int{
 			1,
 			1,
 			2,
diff --git a/core/math/math_gamma.odin b/core/math/math_gamma.odin
index 00d4b7316..9f5a364d3 100644
--- a/core/math/math_gamma.odin
+++ b/core/math/math_gamma.odin
@@ -67,7 +67,7 @@ package math
 // masks any imprecision in the polynomial.
 @(private="file", require_results)
 stirling :: proc "contextless" (x: f64) -> (f64, f64) {
-	@(static) gamS := [?]f64{
+	@(static, rodata) gamS := [?]f64{
 		+7.87311395793093628397e-04,
 		-2.29549961613378126380e-04,
 		-2.68132617805781232825e-03,
@@ -103,7 +103,7 @@ gamma_f64 :: proc "contextless" (x: f64) -> f64 {
 		return false
 	}
 	
-	@(static) gamP := [?]f64{
+	@(static, rodata) gamP := [?]f64{
 		1.60119522476751861407e-04,
 		1.19135147006586384913e-03,
 		1.04213797561761569935e-02,
@@ -112,7 +112,7 @@ gamma_f64 :: proc "contextless" (x: f64) -> f64 {
 		4.94214826801497100753e-01,
 		9.99999999999999996796e-01,
 	}
-	@(static) gamQ := [?]f64{
+	@(static, rodata) gamQ := [?]f64{
 		-2.31581873324120129819e-05,
 		+5.39605580493303397842e-04,
 		-4.45641913851797240494e-03,
diff --git a/core/math/math_lgamma.odin b/core/math/math_lgamma.odin
index 0705d8564..828f17178 100644
--- a/core/math/math_lgamma.odin
+++ b/core/math/math_lgamma.odin
@@ -123,7 +123,7 @@ lgamma_f64 :: proc "contextless" (x: f64) -> (lgamma: f64, sign: int) {
 		return -x
 	}
 	
-	@static lgamA := [?]f64{
+	@(static, rodata) lgamA := [?]f64{
 		0h3FB3C467E37DB0C8,
 		0h3FD4A34CC4A60FAD,
 		0h3FB13E001A5562A7,
@@ -137,7 +137,7 @@ lgamma_f64 :: proc "contextless" (x: f64) -> (lgamma: f64, sign: int) {
 		0h3EFA7074428CFA52,
 		0h3F07858E90A45837,
 	}
-	@static lgamR := [?]f64{
+	@(static, rodata) lgamR := [?]f64{
 		1.0,
 		0h3FF645A762C4AB74,
 		0h3FE71A1893D3DCDC,
@@ -146,7 +146,7 @@ lgamma_f64 :: proc "contextless" (x: f64) -> (lgamma: f64, sign: int) {
 		0h3F497DDACA41A95B,
 		0h3EDEBAF7A5B38140,
 	}
-	@static lgamS := [?]f64{
+	@(static, rodata) lgamS := [?]f64{
 		0hBFB3C467E37DB0C8,
 		0h3FCB848B36E20878,
 		0h3FD4D98F4F139F59,
@@ -155,7 +155,7 @@ lgamma_f64 :: proc "contextless" (x: f64) -> (lgamma: f64, sign: int) {
 		0h3F5E26B67368F239,
 		0h3F00BFECDD17E945,
 	}
-	@static lgamT := [?]f64{
+	@(static, rodata) lgamT := [?]f64{
 		0h3FDEF72BC8EE38A2,
 		0hBFC2E4278DC6C509,
 		0h3FB08B4294D5419B,
@@ -172,7 +172,7 @@ lgamma_f64 :: proc "contextless" (x: f64) -> (lgamma: f64, sign: int) {
 		0hBF347F24ECC38C38,
 		0h3F35FD3EE8C2D3F4,
 	}
-	@static lgamU := [?]f64{
+	@(static, rodata) lgamU := [?]f64{
 		0hBFB3C467E37DB0C8,
 		0h3FE4401E8B005DFF,
 		0h3FF7475CD119BD6F,
@@ -180,7 +180,7 @@ lgamma_f64 :: proc "contextless" (x: f64) -> (lgamma: f64, sign: int) {
 		0h3FCD4EAEF6010924,
 		0h3F8B678BBF2BAB09,
 	}
-	@static lgamV := [?]f64{
+	@(static, rodata) lgamV := [?]f64{
 		1.0,
 		0h4003A5D7C2BD619C,
 		0h40010725A42B18F5,
@@ -188,7 +188,7 @@ lgamma_f64 :: proc "contextless" (x: f64) -> (lgamma: f64, sign: int) {
 		0h3FBAAE55D6537C88,
 		0h3F6A5ABB57D0CF61,
 	}
-	@static lgamW := [?]f64{
+	@(static, rodata) lgamW := [?]f64{
 		0h3FDACFE390C97D69,
 		0h3FB555555555553B,
 		0hBF66C16C16B02E5C,
diff --git a/core/math/math_sincos.odin b/core/math/math_sincos.odin
index 578876ac5..b616f410d 100644
--- a/core/math/math_sincos.odin
+++ b/core/math/math_sincos.odin
@@ -234,7 +234,7 @@ _trig_reduce_f64 :: proc "contextless" (x: f64) -> (j: u64, z: f64) #no_bounds_c
 	// that is, 4/pi = Sum bd_pi4[i]*2^(-64*i)
 	// 19 64-bit digits and the leading one bit give 1217 bits
 	// of precision to handle the largest possible f64 exponent.
-	@static bd_pi4 := [?]u64{
+	@(static, rodata) bd_pi4 := [?]u64{
 		0x0000000000000001,
 		0x45f306dc9c882a53,
 		0xf84eafa3ea69bb81,
diff --git a/core/math/rand/exp.odin b/core/math/rand/exp.odin
index 719debe75..ebc849b2f 100644
--- a/core/math/rand/exp.odin
+++ b/core/math/rand/exp.odin
@@ -19,7 +19,7 @@ import "core:math"
 exp_float64 :: proc(r: ^Rand = nil) -> f64 {
 	re :: 7.69711747013104972
 
-	@(static)
+	@(static, rodata)
 	ke := [256]u32{
 		0xe290a139, 0x0, 0x9beadebc, 0xc377ac71, 0xd4ddb990,
 		0xde893fb8, 0xe4a8e87c, 0xe8dff16a, 0xebf2deab, 0xee49a6e8,
@@ -74,7 +74,7 @@ exp_float64 :: proc(r: ^Rand = nil) -> f64 {
 		0xf7b577d2, 0xf69c650c, 0xf51530f0, 0xf2cb0e3c, 0xeeefb15d,
 		0xe6da6ecf,
 	}
-	@(static)
+	@(static, rodata)
 	we := [256]f32{
 		2.0249555e-09, 1.486674e-11, 2.4409617e-11, 3.1968806e-11,
 		3.844677e-11, 4.4228204e-11, 4.9516443e-11, 5.443359e-11,
@@ -141,7 +141,7 @@ exp_float64 :: proc(r: ^Rand = nil) -> f64 {
 		1.2393786e-09, 1.276585e-09, 1.3193139e-09, 1.3695435e-09,
 		1.4305498e-09, 1.508365e-09, 1.6160854e-09, 1.7921248e-09,
 	}
-	@(static)
+	@(static, rodata)
 	fe := [256]f32{
 		1, 0.9381437, 0.90046996, 0.87170434, 0.8477855, 0.8269933,
 		0.8084217, 0.7915276, 0.77595687, 0.7614634, 0.7478686,
diff --git a/core/math/rand/normal.odin b/core/math/rand/normal.odin
index f96163fe9..c8681db80 100644
--- a/core/math/rand/normal.odin
+++ b/core/math/rand/normal.odin
@@ -21,7 +21,7 @@ import "core:math"
 norm_float64 :: proc(r: ^Rand = nil) -> f64 {
 	rn :: 3.442619855899
 
-	@(static)
+	@(static, rodata)
 	kn := [128]u32{
 		0x76ad2212, 0x00000000, 0x600f1b53, 0x6ce447a6, 0x725b46a2,
 		0x7560051d, 0x774921eb, 0x789a25bd, 0x799045c3, 0x7a4bce5d,
@@ -50,7 +50,7 @@ norm_float64 :: proc(r: ^Rand = nil) -> f64 {
 		0x7da61a1e, 0x7d72a0fb, 0x7d30e097, 0x7cd9b4ab, 0x7c600f1a,
 		0x7ba90bdc, 0x7a722176, 0x77d664e5,
 	}
-	@(static)
+	@(static, rodata)
 	wn := [128]f32{
 		1.7290405e-09, 1.2680929e-10, 1.6897518e-10, 1.9862688e-10,
 		2.2232431e-10, 2.4244937e-10, 2.601613e-10,  2.7611988e-10,
@@ -85,7 +85,7 @@ norm_float64 :: proc(r: ^Rand = nil) -> f64 {
 		1.2601323e-09, 1.2857697e-09, 1.3146202e-09, 1.347784e-09,
 		1.3870636e-09, 1.4357403e-09, 1.5008659e-09, 1.6030948e-09,
 	}
-	@(static)
+	@(static, rodata)
 	fn := [128]f32{
 		1.00000000,  0.9635997,   0.9362827,   0.9130436,   0.89228165,
 		0.87324303,  0.8555006,   0.8387836,   0.8229072,   0.8077383,
diff --git a/core/os/os2/internal_util.odin b/core/os/os2/internal_util.odin
index 59d845350..e26cf7439 100644
--- a/core/os/os2/internal_util.odin
+++ b/core/os/os2/internal_util.odin
@@ -111,7 +111,7 @@ next_random :: proc(r: ^[2]u64) -> u64 {
 
 @(require_results)
 random_string :: proc(buf: []byte) -> string {
-	@static digits := "0123456789"
+	@(static, rodata) digits := "0123456789"
 
 	u := next_random(&random_string_seed)
 
diff --git a/core/strconv/generic_float.odin b/core/strconv/generic_float.odin
index 6dc11c0be..b049f0fe1 100644
--- a/core/strconv/generic_float.odin
+++ b/core/strconv/generic_float.odin
@@ -375,7 +375,7 @@ decimal_to_float_bits :: proc(d: ^decimal.Decimal, info: ^Float_Info) -> (b: u64
 		return
 	}
 
-	@static power_table := [?]int{1, 3, 6, 9, 13, 16, 19, 23, 26}
+	@(static, rodata) power_table := [?]int{1, 3, 6, 9, 13, 16, 19, 23, 26}
 
 	exp = 0
 	for d.decimal_point > 0 {
diff --git a/core/strconv/strconv.odin b/core/strconv/strconv.odin
index 11590fa1b..902f1cdc5 100644
--- a/core/strconv/strconv.odin
+++ b/core/strconv/strconv.odin
@@ -1095,7 +1095,7 @@ parse_f64_prefix :: proc(str: string) -> (value: f64, nr: int, ok: bool) {
 	}
 
 	trunc_block: if !trunc {
-		@static pow10 := [?]f64{
+		@(static, rodata) pow10 := [?]f64{
 			1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,
 			1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
 			1e20, 1e21, 1e22,
diff --git a/core/time/time.odin b/core/time/time.odin
index 4807af840..4575b36f7 100644
--- a/core/time/time.odin
+++ b/core/time/time.odin
@@ -389,6 +389,7 @@ is_leap_year :: proc "contextless" (year: int) -> (leap: bool) {
 	return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)
 }
 
+@(rodata)
 days_before := [?]i32{
 	0,
 	31,
diff --git a/core/unicode/tables.odin b/core/unicode/tables.odin
index f43827413..dfa5caaa2 100644
--- a/core/unicode/tables.odin
+++ b/core/unicode/tables.odin
@@ -12,6 +12,7 @@ package unicode
 @(private) pLo    :: pLl | pLu // a letter that is neither upper nor lower case.
 @(private) pLmask :: pLo
 
+@(rodata)
 char_properties := [MAX_LATIN1+1]u8{
 	0x00 = pC,       // '\x00'
 	0x01 = pC,       // '\x01'
@@ -272,6 +273,7 @@ char_properties := [MAX_LATIN1+1]u8{
 }
 
 
+@(rodata)
 alpha_ranges := [?]i32{
 	0x00d8,  0x00f6,
 	0x00f8,  0x01f5,
@@ -427,6 +429,7 @@ alpha_ranges := [?]i32{
 	0xffda,  0xffdc,
 }
 
+@(rodata)
 alpha_singlets := [?]i32{
 	0x00aa,
 	0x00b5,
@@ -462,6 +465,7 @@ alpha_singlets := [?]i32{
 	0xfe74,
 }
 
+@(rodata)
 space_ranges := [?]i32{
 	0x0009,  0x000d, // tab and newline
 	0x0020,  0x0020, // space
@@ -477,6 +481,7 @@ space_ranges := [?]i32{
 	0xfeff,  0xfeff,
 }
 
+@(rodata)
 unicode_spaces := [?]i32{
 	0x0009, // tab
 	0x000a, // LF
@@ -494,6 +499,7 @@ unicode_spaces := [?]i32{
 	0xfeff, // unknown
 }
 
+@(rodata)
 to_upper_ranges := [?]i32{
 	0x0061,  0x007a, 468, // a-z A-Z
 	0x00e0,  0x00f6, 468,
@@ -532,6 +538,7 @@ to_upper_ranges := [?]i32{
 	0xff41,  0xff5a, 468,
 }
 
+@(rodata)
 to_upper_singlets := [?]i32{
 	0x00ff, 621,
 	0x0101, 499,
@@ -875,6 +882,7 @@ to_upper_singlets := [?]i32{
 	0x1ff3, 509,
 }
 
+@(rodata)
 to_lower_ranges := [?]i32{
 	0x0041,  0x005a, 532, // A-Z a-z
 	0x00c0,  0x00d6, 532, // - -
@@ -914,6 +922,7 @@ to_lower_ranges := [?]i32{
 	0xff21,  0xff3a, 532, // - -
 }
 
+@(rodata)
 to_lower_singlets := [?]i32{
 	0x0100, 501,
 	0x0102, 501,
@@ -1250,6 +1259,7 @@ to_lower_singlets := [?]i32{
 	0x1ffc, 491,
 }
 
+@(rodata)
 to_title_singlets := [?]i32{
 	0x01c4, 501,
 	0x01c6, 499,
-- 
cgit v1.2.3


From 828870004bb84d3a23c4ebe6c33acad086036a9c Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sun, 9 Jun 2024 17:15:08 +0100
Subject: Change indentation

---
 base/runtime/wasm_allocator.odin | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

(limited to 'base/runtime')

diff --git a/base/runtime/wasm_allocator.odin b/base/runtime/wasm_allocator.odin
index acfc80b0a..6bca0b3d6 100644
--- a/base/runtime/wasm_allocator.odin
+++ b/base/runtime/wasm_allocator.odin
@@ -7,20 +7,20 @@ import "base:intrinsics"
 Port of emmalloc, modified for use in Odin.
 
 Invariants:
- - Per-allocation header overhead is 8 bytes, smallest allocated payload
-   amount is 8 bytes, and a multiple of 4 bytes.
- - Acquired memory blocks are subdivided into disjoint regions that lie
-   next to each other.
- - A region is either in used or free.
-   Used regions may be adjacent, and a used and unused region
-   may be adjacent, but not two unused ones - they would be
-   merged.
- - Memory allocation takes constant time, unless the alloc needs to wasm_memory_grow()
-   or memory is very close to being exhausted.
- - Free and used regions are managed inside "root regions", which are slabs
-   of memory acquired via wasm_memory_grow().
- - Memory retrieved using wasm_memory_grow() can not be given back to the OS.
-   Therefore, frees are internal to the allocator.
+	- Per-allocation header overhead is 8 bytes, smallest allocated payload
+	  amount is 8 bytes, and a multiple of 4 bytes.
+	- Acquired memory blocks are subdivided into disjoint regions that lie
+	  next to each other.
+	- A region is either in used or free.
+	  Used regions may be adjacent, and a used and unused region
+	  may be adjacent, but not two unused ones - they would be
+	  merged.
+	- Memory allocation takes constant time, unless the alloc needs to wasm_memory_grow()
+	  or memory is very close to being exhausted.
+	- Free and used regions are managed inside "root regions", which are slabs
+	  of memory acquired via wasm_memory_grow().
+	- Memory retrieved using wasm_memory_grow() can not be given back to the OS.
+	  Therefore, frees are internal to the allocator.
 
 Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file.
 
-- 
cgit v1.2.3


From ff7fcb6d380d1e45402de2b2e0d2b577ad9f6d59 Mon Sep 17 00:00:00 2001
From: Feoramund <161657516+Feoramund@users.noreply.github.com>
Date: Mon, 10 Jun 2024 03:47:20 -0400
Subject: Add compilation-related constants

`ODIN_VERSION_HASH` is the `git` SHA hash of the commit the Odin
compiler was built with.

`ODIN_MICROARCH_STRING` is the string passed to `-microarch` when
the program was built.

`ODIN_OPTIMIZATION_MODE` is an enum value of which optimization mode was
used to build the program.
---
 base/runtime/core.odin | 13 +++++++++++++
 src/checker.cpp        | 25 +++++++++++++++++++++++++
 2 files changed, 38 insertions(+)

(limited to 'base/runtime')

diff --git a/base/runtime/core.odin b/base/runtime/core.odin
index 3e24060af..8671920f5 100644
--- a/base/runtime/core.odin
+++ b/base/runtime/core.odin
@@ -560,6 +560,19 @@ Odin_Platform_Subtarget_Type :: type_of(ODIN_PLATFORM_SUBTARGET)
 */
 Odin_Sanitizer_Flags :: type_of(ODIN_SANITIZER_FLAGS)
 
+/*
+	// Defined internally by the compiler
+	Odin_Optimization_Mode :: enum int {
+		None       = -1,
+		Minimal    =  0,
+		Size       =  1,
+		Speed      =  2,
+		Aggressive =  3,
+	}
+
+	ODIN_OPTIMIZATION_MODE // is a constant
+*/
+Odin_Optimization_Mode :: type_of(ODIN_OPTIMIZATION_MODE)
 
 /////////////////////////////
 // Init Startup Procedures //
diff --git a/src/checker.cpp b/src/checker.cpp
index 8a58bb425..08a03ac62 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -1040,6 +1040,8 @@ gb_internal void init_universal(void) {
 		add_global_enum_constant(fields, "ODIN_ARCH", bc->metrics.arch);
 		add_global_string_constant("ODIN_ARCH_STRING", target_arch_names[bc->metrics.arch]);
 	}
+
+	add_global_string_constant("ODIN_MICROARCH_STRING", bc->microarch);
 	
 	{
 		GlobalEnumValue values[BuildMode_COUNT] = {
@@ -1130,6 +1132,17 @@ gb_internal void init_universal(void) {
 
 	add_global_constant("ODIN_COMPILE_TIMESTAMP", t_untyped_integer, exact_value_i64(odin_compile_timestamp()));
 
+	{
+		String version = {};
+
+		#ifdef GIT_SHA
+		version.text = cast(u8 *)GIT_SHA;
+		version.len = gb_strlen(GIT_SHA);
+		#endif
+
+		add_global_string_constant("ODIN_VERSION_HASH", version);
+	}
+
 	{
 		bool f16_supported = lb_use_new_pass_system();
 		if (is_arch_wasm()) {
@@ -1167,6 +1180,18 @@ gb_internal void init_universal(void) {
 		add_global_constant("ODIN_SANITIZER_FLAGS", named_type, exact_value_u64(bc->sanitizer_flags));
 	}
 
+	{
+		GlobalEnumValue values[5] = {
+			{"None",      -1},
+			{"Minimal",    0},
+			{"Size",       1},
+			{"Speed",      2},
+			{"Aggressive", 3},
+		};
+
+		auto fields = add_global_enum_type(str_lit("Odin_Optimization_Mode"), values, gb_count_of(values));
+		add_global_enum_constant(fields, "ODIN_OPTIMIZATION_MODE", bc->optimization_level);
+	}
 
 
 // Builtin Procedures
-- 
cgit v1.2.3


From 50464bdce374e688313961a37f12197b505a6391 Mon Sep 17 00:00:00 2001
From: Feoramund <161657516+Feoramund@users.noreply.github.com>
Date: Mon, 10 Jun 2024 20:51:58 -0400
Subject: Use `#any_int` for `reserve_*` and `resize_*` procs

Resolves #3088
---
 base/runtime/core_builtin.odin | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'base/runtime')

diff --git a/base/runtime/core_builtin.odin b/base/runtime/core_builtin.odin
index 00c30d3fd..a9566c831 100644
--- a/base/runtime/core_builtin.odin
+++ b/base/runtime/core_builtin.odin
@@ -383,7 +383,7 @@ clear_map :: proc "contextless" (m: ^$T/map[$K]$V) {
 //
 // Note: Prefer the procedure group `reserve`
 @builtin
-reserve_map :: proc(m: ^$T/map[$K]$V, capacity: int, loc := #caller_location) -> Allocator_Error {
+reserve_map :: proc(m: ^$T/map[$K]$V, #any_int capacity: int, loc := #caller_location) -> Allocator_Error {
 	return __dynamic_map_reserve((^Raw_Map)(m), map_info(T), uint(capacity), loc) if m != nil else nil
 }
 
@@ -721,12 +721,12 @@ _reserve_dynamic_array :: #force_inline proc(array: ^$T/[dynamic]$E, capacity: i
 }
 
 @builtin
-reserve_dynamic_array :: proc(array: ^$T/[dynamic]$E, capacity: int, loc := #caller_location) -> Allocator_Error {
+reserve_dynamic_array :: proc(array: ^$T/[dynamic]$E, #any_int capacity: int, loc := #caller_location) -> Allocator_Error {
 	return _reserve_dynamic_array(array, capacity, true, loc)
 }
 
 @builtin
-non_zero_reserve_dynamic_array :: proc(array: ^$T/[dynamic]$E, capacity: int, loc := #caller_location) -> Allocator_Error {
+non_zero_reserve_dynamic_array :: proc(array: ^$T/[dynamic]$E, #any_int capacity: int, loc := #caller_location) -> Allocator_Error {
 	return _reserve_dynamic_array(array, capacity, false, loc)
 }
 
@@ -773,12 +773,12 @@ _resize_dynamic_array :: #force_inline proc(array: ^$T/[dynamic]$E, length: int,
 }
 
 @builtin
-resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, length: int, loc := #caller_location) -> Allocator_Error {
+resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, #any_int length: int, loc := #caller_location) -> Allocator_Error {
 	return _resize_dynamic_array(array, length, true, loc=loc)
 }
 
 @builtin
-non_zero_resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, length: int, loc := #caller_location) -> Allocator_Error {
+non_zero_resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, #any_int length: int, loc := #caller_location) -> Allocator_Error {
 	return _resize_dynamic_array(array, length, false, loc=loc)
 }
 
-- 
cgit v1.2.3