From 231ce2da59cd93b4e8d8a90daca2d2111fc3ecf8 Mon Sep 17 00:00:00 2001
From: Jon Lipstate <jon@lipstate.com>
Date: Fri, 29 Aug 2025 12:41:38 -0700
Subject: windows i386 support

---
 src/llvm_backend.cpp | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

(limited to 'src/llvm_backend.cpp')

diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index ff17e9c10..f2d09f400 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -2686,8 +2686,15 @@ gb_internal lbProcedure *lb_create_main_procedure(lbModule *m, lbProcedure *star
 		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_i386 || build_context.no_crt)) {
+	} else if (build_context.metrics.os == TargetOs_windows && build_context.no_crt) {
 		name = str_lit("mainCRTStartup");
+	} else if (build_context.metrics.os == TargetOs_windows && build_context.metrics.arch == TargetArch_i386 && !build_context.no_crt) {
+		// Windows i386 with CRT: libcmt expects _main (main with underscore prefix)
+		name = str_lit("main");
+		has_args = true;
+		slice_init(&params->Tuple.variables, permanent_allocator(), 2);
+		params->Tuple.variables[0] = alloc_entity_param(nullptr, make_token_ident("argc"), t_i32, false, true);
+		params->Tuple.variables[1] = alloc_entity_param(nullptr, make_token_ident("argv"), t_ptr_cstring, false, true);
 	} else if (is_arch_wasm()) {
 		name = str_lit("_start");
 		call_cleanup = false;
@@ -3162,6 +3169,7 @@ gb_internal bool lb_generate_code(lbGenerator *gen) {
 				String link_name = e->Procedure.link_name;
 				if (e->pkg->kind == Package_Runtime) {
 					if (link_name == "main"           ||
+					    link_name == "_main"          ||
 					    link_name == "DllMain"        ||
 					    link_name == "WinMain"        ||
 					    link_name == "wWinMain"       ||
-- 
cgit v1.2.3


From 738a72943bdb9d0998b11d38efb5300cd02d8190 Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Thu, 18 Sep 2025 15:04:16 +0100
Subject: Try moving parapoly procs into a separate module when doing weak
 monomorphization

---
 src/build_settings.cpp       |  1 +
 src/llvm_backend.cpp         |  2 +-
 src/llvm_backend.hpp         |  2 ++
 src/llvm_backend_debug.cpp   |  2 +-
 src/llvm_backend_general.cpp | 63 ++++++++++++++++++++++++++++++++++++++------
 src/llvm_backend_proc.cpp    |  2 +-
 src/main.cpp                 |  5 ++++
 7 files changed, 66 insertions(+), 11 deletions(-)

(limited to 'src/llvm_backend.cpp')

diff --git a/src/build_settings.cpp b/src/build_settings.cpp
index 077660f10..867c80ac1 100644
--- a/src/build_settings.cpp
+++ b/src/build_settings.cpp
@@ -554,6 +554,7 @@ struct BuildContext {
 
 	bool internal_no_inline;
 	bool internal_by_value;
+	bool internal_weak_monomorphization;
 
 	bool   no_threaded_checker;
 
diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index 11b979774..2bc18872e 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -2145,7 +2145,7 @@ gb_internal void lb_create_global_procedures_and_types(lbGenerator *gen, Checker
 
 		lbModule *m = &gen->default_module;
 		if (USE_SEPARATE_MODULES) {
-			m = lb_module_of_entity(gen, e);
+			m = lb_module_of_entity(gen, e, m);
 		}
 		GB_ASSERT(m != nullptr);
 
diff --git a/src/llvm_backend.hpp b/src/llvm_backend.hpp
index cc3dcaa4a..e4b8c07fa 100644
--- a/src/llvm_backend.hpp
+++ b/src/llvm_backend.hpp
@@ -150,6 +150,8 @@ struct lbModule {
 	struct lbGenerator *gen;
 	LLVMTargetMachineRef target_machine;
 
+	lbModule *polymorphic_module;
+
 	CheckerInfo *info;
 	AstPackage *pkg; // possibly associated
 	AstFile *file;   // possibly associated
diff --git a/src/llvm_backend_debug.cpp b/src/llvm_backend_debug.cpp
index 182920fc7..3372165f2 100644
--- a/src/llvm_backend_debug.cpp
+++ b/src/llvm_backend_debug.cpp
@@ -1327,7 +1327,7 @@ gb_internal void lb_add_debug_info_for_global_constant_from_entity(lbGenerator *
 	}
 	lbModule *m = &gen->default_module;
 	if (USE_SEPARATE_MODULES) {
-		m = lb_module_of_entity(gen, e);
+		m = lb_module_of_entity(gen, e, m);
 	}
 	GB_ASSERT(m != nullptr);
 
diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index 49a04641c..4907e114d 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -46,6 +46,12 @@ gb_internal void lb_init_module(lbModule *m, Checker *c) {
 		}
 		module_name = gb_string_appendc(module_name, "builtin");
 	}
+	if (m->polymorphic_module == m) {
+		if (gb_string_length(module_name)) {
+			module_name = gb_string_appendc(module_name, "-");
+		}
+		module_name = gb_string_appendc(module_name, "$parapoly");
+	}
 
 	m->module_name = module_name;
 	m->ctx = LLVMContextCreate();
@@ -147,17 +153,42 @@ gb_internal bool lb_init_generator(lbGenerator *gen, Checker *c) {
 			m->gen = gen;
 			map_set(&gen->modules, cast(void *)pkg, m);
 			lb_init_module(m, c);
+
+			if (build_context.internal_weak_monomorphization) {
+				auto pm = gb_alloc_item(permanent_allocator(), lbModule);
+				pm->pkg = pkg;
+				pm->gen = gen;
+				m->polymorphic_module = pm;
+				pm->polymorphic_module = pm;
+
+				map_set(&gen->modules, cast(void *)pm, pm); // point to itself just add it to the list
+
+				lb_init_module(pm, c);
+			}
+
 			if (!module_per_file) {
 				continue;
 			}
 			// NOTE(bill): Probably per file is not a good idea, so leave this for later
 			for (AstFile *file : pkg->files) {
-				auto m = gb_alloc_item(permanent_allocator(), lbModule);
+				auto m  = gb_alloc_item(permanent_allocator(), lbModule);
 				m->file = file;
-				m->pkg = pkg;
-				m->gen = gen;
+				m->pkg  = pkg;
+				m->gen  = gen;
 				map_set(&gen->modules, cast(void *)file, m);
 				lb_init_module(m, c);
+
+
+				if (build_context.internal_weak_monomorphization) {
+					auto pm  = gb_alloc_item(permanent_allocator(), lbModule);
+					pm->file = file;
+					pm->gen  = gen;
+					pm->polymorphic_module = pm;
+
+					map_set(&gen->modules, cast(void *)pm, pm); // point to itself just add it to the list
+
+					lb_init_module(pm, c);
+				}
 			}
 		}
 	}
@@ -403,9 +434,9 @@ gb_internal lbModule *lb_module_of_expr(lbGenerator *gen, Ast *expr) {
 	return &gen->default_module;
 }
 
-gb_internal lbModule *lb_module_of_entity(lbGenerator *gen, Entity *e) {
-	GB_ASSERT(e != nullptr);
+gb_internal lbModule *lb_module_of_entity_internal(lbGenerator *gen, Entity *e, lbModule *curr_module) {
 	lbModule **found = nullptr;
+
 	if (e->kind == Entity_Procedure &&
 	    e->decl_info &&
 	    e->decl_info->code_gen_module) {
@@ -428,6 +459,22 @@ gb_internal lbModule *lb_module_of_entity(lbGenerator *gen, Entity *e) {
 	return &gen->default_module;
 }
 
+
+gb_internal lbModule *lb_module_of_entity(lbGenerator *gen, Entity *e, lbModule *curr_module) {
+	GB_ASSERT(e != nullptr);
+	GB_ASSERT(curr_module != nullptr);
+	lbModule *m = lb_module_of_entity_internal(gen, e, curr_module);
+
+	if (USE_SEPARATE_MODULES && build_context.internal_weak_monomorphization) {
+		if (e->kind == Entity_Procedure && e->Procedure.generated_from_polymorphic) {
+			if (m->polymorphic_module) {
+				return m->polymorphic_module;
+			}
+		}
+	}
+	return m;
+}
+
 gb_internal lbAddr lb_addr(lbValue addr) {
 	lbAddr v = {lbAddr_Default, addr};
 	return v;
@@ -2914,7 +2961,7 @@ gb_internal lbValue lb_find_ident(lbProcedure *p, lbModule *m, Entity *e, Ast *e
 		return lb_find_procedure_value_from_entity(m, e);
 	}
 	if (USE_SEPARATE_MODULES) {
-		lbModule *other_module = lb_module_of_entity(m->gen, e);
+		lbModule *other_module = lb_module_of_entity(m->gen, e, m);
 		if (other_module != m) {
 			String name = lb_get_entity_name(other_module, e);
 
@@ -2962,7 +3009,7 @@ gb_internal lbValue lb_find_procedure_value_from_entity(lbModule *m, Entity *e)
 
 	lbModule *other_module = m;
 	if (USE_SEPARATE_MODULES) {
-		other_module = lb_module_of_entity(gen, e);
+		other_module = lb_module_of_entity(gen, e, m);
 	}
 	if (other_module == m) {
 		debugf("Missing Procedure (lb_find_procedure_value_from_entity): %.*s module %p\n", LIT(e->token.string), m);
@@ -3145,7 +3192,7 @@ gb_internal lbValue lb_find_value_from_entity(lbModule *m, Entity *e) {
 	}
 
 	if (USE_SEPARATE_MODULES) {
-		lbModule *other_module = lb_module_of_entity(m->gen, e);
+		lbModule *other_module = lb_module_of_entity(m->gen, e, m);
 
 		bool is_external = other_module != m;
 		if (!is_external) {
diff --git a/src/llvm_backend_proc.cpp b/src/llvm_backend_proc.cpp
index 06829efab..20d627fa2 100644
--- a/src/llvm_backend_proc.cpp
+++ b/src/llvm_backend_proc.cpp
@@ -84,7 +84,7 @@ gb_internal lbProcedure *lb_create_procedure(lbModule *m, Entity *entity, bool i
 	String link_name = {};
 
 	if (ignore_body) {
-		lbModule *other_module = lb_module_of_entity(m->gen, entity);
+		lbModule *other_module = lb_module_of_entity(m->gen, entity, m);
 		link_name = lb_get_entity_name(other_module, entity);
 	} else {
 		link_name = lb_get_entity_name(m, entity);
diff --git a/src/main.cpp b/src/main.cpp
index 184b1eaac..130c3f31d 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -403,6 +403,7 @@ enum BuildFlagKind {
 	BuildFlag_InternalCached,
 	BuildFlag_InternalNoInline,
 	BuildFlag_InternalByValue,
+	BuildFlag_InternalWeakMonomorphization,
 
 	BuildFlag_Tilde,
 
@@ -626,6 +627,7 @@ gb_internal bool parse_build_flags(Array<String> args) {
 	add_flag(&build_flags, BuildFlag_InternalCached,          str_lit("internal-cached"),           BuildFlagParam_None,    Command_all);
 	add_flag(&build_flags, BuildFlag_InternalNoInline,        str_lit("internal-no-inline"),        BuildFlagParam_None,    Command_all);
 	add_flag(&build_flags, BuildFlag_InternalByValue,         str_lit("internal-by-value"),         BuildFlagParam_None,    Command_all);
+	add_flag(&build_flags, BuildFlag_InternalWeakMonomorphization, str_lit("internal-weak-monomorphization"), BuildFlagParam_None, Command_all);
 
 #if ALLOW_TILDE
 	add_flag(&build_flags, BuildFlag_Tilde,                   str_lit("tilde"),                     BuildFlagParam_None,    Command__does_build);
@@ -1584,6 +1586,9 @@ gb_internal bool parse_build_flags(Array<String> args) {
 						case BuildFlag_InternalByValue:
 							build_context.internal_by_value = true;
 							break;
+						case BuildFlag_InternalWeakMonomorphization:
+							build_context.internal_weak_monomorphization = true;
+							break;
 
 						case BuildFlag_Tilde:
 							build_context.tilde_backend = true;
-- 
cgit v1.2.3


From 0f307fbc5d27a9b0fa880dda7a2754d2d1ca7bfd Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Thu, 18 Sep 2025 15:34:19 +0100
Subject: Use multiple modules per file in package runtime

---
 src/llvm_backend.cpp         | 50 +++++++++++++-------------------------------
 src/llvm_backend.hpp         |  2 ++
 src/llvm_backend_general.cpp |  8 +++++--
 3 files changed, 23 insertions(+), 37 deletions(-)

(limited to 'src/llvm_backend.cpp')

diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index 2bc18872e..c6a372ac2 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -2303,6 +2303,7 @@ gb_internal WORKER_TASK_PROC(lb_llvm_function_pass_per_module) {
 struct lbLLVMModulePassWorkerData {
 	lbModule *m;
 	LLVMTargetMachineRef target_machine;
+	bool do_threading;
 };
 
 gb_internal WORKER_TASK_PROC(lb_llvm_module_pass_worker_proc) {
@@ -2386,6 +2387,13 @@ gb_internal WORKER_TASK_PROC(lb_llvm_module_pass_worker_proc) {
 		return 1;
 	}
 #endif
+
+	if (wd->do_threading) {
+		thread_pool_add_task(lb_llvm_module_verification_worker_proc, wd->m);
+	} else {
+		lb_llvm_module_verification_worker_proc(wd->m);
+	}
+
 	return 0;
 }
 
@@ -2468,19 +2476,16 @@ gb_internal void lb_llvm_function_passes(lbGenerator *gen, bool do_threading) {
 }
 
 
-gb_internal void lb_llvm_module_passes(lbGenerator *gen, bool do_threading) {
+gb_internal void lb_llvm_module_passes_and_verification(lbGenerator *gen, bool do_threading) {
 	if (do_threading) {
 		for (auto const &entry : gen->modules) {
 			lbModule *m = entry.value;
 			auto wd = gb_alloc_item(permanent_allocator(), lbLLVMModulePassWorkerData);
 			wd->m = m;
 			wd->target_machine = m->target_machine;
+			wd->do_threading = true;
 
-			if (do_threading) {
-				thread_pool_add_task(lb_llvm_module_pass_worker_proc, wd);
-			} else {
-				lb_llvm_module_pass_worker_proc(wd);
-			}
+			thread_pool_add_task(lb_llvm_module_pass_worker_proc, wd);
 		}
 		thread_pool_wait();
 	} else {
@@ -2489,6 +2494,7 @@ gb_internal void lb_llvm_module_passes(lbGenerator *gen, bool do_threading) {
 			auto wd = gb_alloc_item(permanent_allocator(), lbLLVMModulePassWorkerData);
 			wd->m = m;
 			wd->target_machine = m->target_machine;
+			wd->do_threading = false;
 			lb_llvm_module_pass_worker_proc(wd);
 		}
 	}
@@ -2569,31 +2575,6 @@ gb_internal String lb_filepath_obj_for_module(lbModule *m) {
 
 }
 
-
-gb_internal bool lb_llvm_module_verification(lbGenerator *gen, bool do_threading) {
-	if (LLVM_IGNORE_VERIFICATION) {
-		return true;
-	}
-
-	if (do_threading) {
-		for (auto const &entry : gen->modules) {
-			lbModule *m = entry.value;
-			thread_pool_add_task(lb_llvm_module_verification_worker_proc, m);
-		}
-		thread_pool_wait();
-
-	} else {
-		for (auto const &entry : gen->modules) {
-			lbModule *m = entry.value;
-			if (lb_llvm_module_verification_worker_proc(m)) {
-				return false;
-			}
-		}
-	}
-
-	return true;
-}
-
 gb_internal void lb_add_foreign_library_paths(lbGenerator *gen) {
 	for (auto const &entry : gen->modules) {
 		lbModule *m = entry.value;
@@ -3479,11 +3460,10 @@ gb_internal bool lb_generate_code(lbGenerator *gen) {
 	TIME_SECTION("LLVM Function Pass");
 	lb_llvm_function_passes(gen, do_threading && !build_context.ODIN_DEBUG);
 
-	TIME_SECTION("LLVM Module Pass");
-	lb_llvm_module_passes(gen, do_threading);
+	TIME_SECTION("LLVM Module Pass and Verification");
+	lb_llvm_module_passes_and_verification(gen, do_threading);
 
-	TIME_SECTION("LLVM Module Verification");
-	if (!lb_llvm_module_verification(gen, do_threading)) {
+	if (gen->module_verification_failed.load(std::memory_order_relaxed)) {
 		return false;
 	}
 
diff --git a/src/llvm_backend.hpp b/src/llvm_backend.hpp
index e4b8c07fa..b031aeb8c 100644
--- a/src/llvm_backend.hpp
+++ b/src/llvm_backend.hpp
@@ -239,6 +239,8 @@ struct lbGenerator : LinkerData {
 
 	isize used_module_count;
 
+	std::atomic<bool> module_verification_failed;
+
 	lbProcedure *startup_runtime;
 	lbProcedure *cleanup_runtime;
 	lbProcedure *objc_names;
diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index 4907e114d..9561f86dd 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -158,7 +158,7 @@ gb_internal bool lb_init_generator(lbGenerator *gen, Checker *c) {
 				auto pm = gb_alloc_item(permanent_allocator(), lbModule);
 				pm->pkg = pkg;
 				pm->gen = gen;
-				m->polymorphic_module = pm;
+				m->polymorphic_module  = pm;
 				pm->polymorphic_module = pm;
 
 				map_set(&gen->modules, cast(void *)pm, pm); // point to itself just add it to the list
@@ -166,7 +166,9 @@ gb_internal bool lb_init_generator(lbGenerator *gen, Checker *c) {
 				lb_init_module(pm, c);
 			}
 
-			if (!module_per_file) {
+			if (pkg->kind == Package_Runtime) {
+				// allow this to be per file
+			} else if (!module_per_file) {
 				continue;
 			}
 			// NOTE(bill): Probably per file is not a good idea, so leave this for later
@@ -182,7 +184,9 @@ gb_internal bool lb_init_generator(lbGenerator *gen, Checker *c) {
 				if (build_context.internal_weak_monomorphization) {
 					auto pm  = gb_alloc_item(permanent_allocator(), lbModule);
 					pm->file = file;
+					pm->pkg  = pkg;
 					pm->gen  = gen;
+					m->polymorphic_module  = pm;
 					pm->polymorphic_module = pm;
 
 					map_set(&gen->modules, cast(void *)pm, pm); // point to itself just add it to the list
-- 
cgit v1.2.3


From 5559916d5c2bc571ad5f6f9b1429191cdcd3213e Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Thu, 18 Sep 2025 16:35:04 +0100
Subject: Mulithread startup procedure body generation

---
 src/llvm_backend.cpp | 65 ++++++++++++++++++++++++++--------------------------
 src/llvm_backend.hpp | 12 ++++++++++
 2 files changed, 45 insertions(+), 32 deletions(-)

(limited to 'src/llvm_backend.cpp')

diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index c6a372ac2..1524f6c25 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -1153,15 +1153,6 @@ gb_internal lbValue lb_dynamic_map_reserve(lbProcedure *p, lbValue const &map_pt
 	return lb_emit_runtime_call(p, "__dynamic_map_reserve", args);
 }
 
-
-struct lbGlobalVariable {
-	lbValue var;
-	lbValue init;
-	DeclInfo *decl;
-	bool is_initialized;
-};
-
-
 gb_internal lbProcedure *lb_create_objc_names(lbModule *main_module) {
 	if (build_context.metrics.os != TargetOs_darwin) {
 		return nullptr;
@@ -1922,33 +1913,21 @@ gb_internal WORKER_TASK_PROC(lb_llvm_module_verification_worker_proc) {
 }
 
 
-
-gb_internal lbProcedure *lb_create_startup_runtime(lbModule *main_module, lbProcedure *objc_names, Array<lbGlobalVariable> &global_variables) { // Startup Runtime
-	Type *proc_type = alloc_type_proc(nullptr, nullptr, 0, nullptr, 0, false, ProcCC_Odin);
-
-	lbProcedure *p = lb_create_dummy_procedure(main_module, str_lit(LB_STARTUP_RUNTIME_PROC_NAME), proc_type);
-	p->is_startup = true;
-	lb_add_attribute_to_proc(p->module, p->value, "optnone");
-	lb_add_attribute_to_proc(p->module, p->value, "noinline");
-
-	// Make sure shared libraries call their own runtime startup on Linux.
-	LLVMSetVisibility(p->value, LLVMHiddenVisibility);
-	LLVMSetLinkage(p->value, LLVMWeakAnyLinkage);
-
+gb_internal void lb_create_startup_runtime_generate_body(lbModule *m, lbProcedure *p) {
 	lb_begin_procedure_body(p);
 
-	lb_setup_type_info_data(main_module);
+	lb_setup_type_info_data(m);
 
-	if (objc_names) {
-		LLVMBuildCall2(p->builder, lb_type_internal_for_procedures_raw(main_module, objc_names->type), objc_names->value, nullptr, 0, "");
+	if (p->objc_names) {
+		LLVMBuildCall2(p->builder, lb_type_internal_for_procedures_raw(m, p->objc_names->type), p->objc_names->value, nullptr, 0, "");
 	}
 
-	for (auto &var : global_variables) {
+	for (auto &var : *p->global_variables) {
 		if (var.is_initialized) {
 			continue;
 		}
 
-		lbModule *entity_module = main_module;
+		lbModule *entity_module = m;
 
 		Entity *e = var.decl->entity;
 		GB_ASSERT(e->kind == Entity_Variable);
@@ -2001,7 +1980,7 @@ gb_internal lbProcedure *lb_create_startup_runtime(lbModule *main_module, lbProc
 				gbString var_name = gb_string_make(permanent_allocator(), "__$global_any::");
 				gbString e_str = string_canonical_entity_name(temporary_allocator(), e);
 				var_name = gb_string_append_length(var_name, e_str, gb_strlen(e_str));
-				lbAddr g = lb_add_global_generated_with_name(main_module, var_type, {}, make_string_c(var_name));
+				lbAddr g = lb_add_global_generated_with_name(m, var_type, {}, make_string_c(var_name));
 				lb_addr_store(p, g, var.init);
 				lbValue gp = lb_addr_get_ptr(p, g);
 
@@ -2022,17 +2001,36 @@ gb_internal lbProcedure *lb_create_startup_runtime(lbModule *main_module, lbProc
 
 
 	}
-	CheckerInfo *info = main_module->gen->info;
-	
+	CheckerInfo *info = m->gen->info;
+
 	for (Entity *e : info->init_procedures) {
-		lbValue value = lb_find_procedure_value_from_entity(main_module, e);
+		lbValue value = lb_find_procedure_value_from_entity(m, e);
 		lb_emit_call(p, value, {}, ProcInlining_none);
 	}
 
 
 	lb_end_procedure_body(p);
+}
+
+
+gb_internal lbProcedure *lb_create_startup_runtime(lbModule *main_module, lbProcedure *objc_names, Array<lbGlobalVariable> &global_variables) { // Startup Runtime
+	Type *proc_type = alloc_type_proc(nullptr, nullptr, 0, nullptr, 0, false, ProcCC_Odin);
+
+	lbProcedure *p = lb_create_dummy_procedure(main_module, str_lit(LB_STARTUP_RUNTIME_PROC_NAME), proc_type);
+	p->is_startup = true;
+	lb_add_attribute_to_proc(p->module, p->value, "optnone");
+	lb_add_attribute_to_proc(p->module, p->value, "noinline");
+
+	// Make sure shared libraries call their own runtime startup on Linux.
+	LLVMSetVisibility(p->value, LLVMHiddenVisibility);
+	LLVMSetLinkage(p->value, LLVMWeakAnyLinkage);
+
+	p->generate_body    = lb_create_startup_runtime_generate_body;
+	p->global_variables = &global_variables;
+	p->objc_names       = objc_names;
+
+	array_add(&main_module->procedures_to_generate, p);
 
-	lb_verify_function(main_module, p);
 	return p;
 }
 
@@ -2800,6 +2798,7 @@ gb_internal void lb_generate_procedure(lbModule *m, lbProcedure *p) {
 	if (p->is_done) {
 		return;
 	}
+
 	if (p->body != nullptr) { // Build Procedure
 		m->curr_procedure = p;
 		lb_begin_procedure_body(p);
@@ -2807,6 +2806,8 @@ gb_internal void lb_generate_procedure(lbModule *m, lbProcedure *p) {
 		lb_end_procedure_body(p);
 		p->is_done = true;
 		m->curr_procedure = nullptr;
+	} else if (p->generate_body != nullptr) {
+		p->generate_body(m, p);
 	}
 
 	// Add Flags
diff --git a/src/llvm_backend.hpp b/src/llvm_backend.hpp
index b031aeb8c..ebe9fe796 100644
--- a/src/llvm_backend.hpp
+++ b/src/llvm_backend.hpp
@@ -333,6 +333,14 @@ struct lbVariadicReuseSlices {
 	lbAddr slice_addr;
 };
 
+struct lbGlobalVariable {
+	lbValue var;
+	lbValue init;
+	DeclInfo *decl;
+	bool is_initialized;
+};
+
+
 struct lbProcedure {
 	u32 flags;
 	u16 state_flags;
@@ -395,6 +403,10 @@ struct lbProcedure {
 	PtrMap<LLVMValueRef, lbTupleFix> tuple_fix_map;
 
 	Array<lbValue> asan_stack_locals;
+
+	void (*generate_body)(lbModule *m, lbProcedure *p);
+	Array<lbGlobalVariable> *global_variables;
+	lbProcedure *objc_names;
 };
 
 
-- 
cgit v1.2.3


From 111e2f0c1b9c25159bee114f170d0d20914c1c7c Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Thu, 18 Sep 2025 16:53:00 +0100
Subject: After global procedures and types are generated, then queue the
 generation of the procedures for each module

---
 src/llvm_backend.cpp | 73 +++++++++++++++++++++++++---------------------------
 1 file changed, 35 insertions(+), 38 deletions(-)

(limited to 'src/llvm_backend.cpp')

diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index 1524f6c25..7360bdaa7 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -2061,9 +2061,26 @@ gb_internal lbProcedure *lb_create_cleanup_runtime(lbModule *main_module) { // C
 	return p;
 }
 
+gb_internal void lb_generate_procedure(lbModule *m, lbProcedure *p);
 
-gb_internal WORKER_TASK_PROC(lb_generate_procedures_and_types_per_module) {
+gb_internal WORKER_TASK_PROC(lb_generate_procedures_worker_proc) {
 	lbModule *m = cast(lbModule *)data;
+	for (isize i = 0; i < m->procedures_to_generate.count; i++) {
+		lbProcedure *p = m->procedures_to_generate[i];
+		lb_generate_procedure(p->module, p);
+	}
+	return 0;
+}
+
+
+struct lbGenerateProceduresWorkerData {
+	lbModule *m;
+	bool do_threading;
+};
+
+gb_internal WORKER_TASK_PROC(lb_generate_procedures_and_types_per_module) {
+	lbGenerateProceduresWorkerData *wd = cast(lbGenerateProceduresWorkerData *)data;
+	lbModule *m = wd->m;
 	for (Entity *e : m->global_types_to_create) {
 		(void)lb_get_entity_name(m, e);
 		(void)lb_type(m, e->type);
@@ -2073,6 +2090,10 @@ gb_internal WORKER_TASK_PROC(lb_generate_procedures_and_types_per_module) {
 		(void)lb_get_entity_name(m, e);
 		array_add(&m->procedures_to_generate, lb_create_procedure(m, e));
 	}
+
+	if (wd->do_threading) {
+		thread_pool_add_task(lb_generate_procedures_worker_proc, m);
+	}
 	return 0;
 }
 
@@ -2162,13 +2183,22 @@ gb_internal void lb_create_global_procedures_and_types(lbGenerator *gen, Checker
 
 	if (do_threading) {
 		for (auto const &entry : gen->modules) {
-			lbModule *m = entry.value;
-			thread_pool_add_task(lb_generate_procedures_and_types_per_module, m);
+			auto wd = permanent_alloc_item<lbGenerateProceduresWorkerData>();
+			wd->m = entry.value;
+			wd->do_threading = true;
+			thread_pool_add_task(lb_generate_procedures_and_types_per_module, wd);
 		}
 	} else {
+		for (auto const &entry : gen->modules) {
+			auto wd = permanent_alloc_item<lbGenerateProceduresWorkerData>();
+			wd->m = entry.value;
+			wd->do_threading = false;
+			lb_generate_procedures_and_types_per_module(wd);
+		}
+
 		for (auto const &entry : gen->modules) {
 			lbModule *m = entry.value;
-			lb_generate_procedures_and_types_per_module(m);
+			lb_generate_procedures_worker_proc(m);
 		}
 
 	}
@@ -2176,9 +2206,6 @@ gb_internal void lb_create_global_procedures_and_types(lbGenerator *gen, Checker
 	thread_pool_wait();
 }
 
-gb_internal void lb_generate_procedure(lbModule *m, lbProcedure *p);
-
-
 gb_internal bool lb_is_module_empty(lbModule *m) {
 	if (LLVMGetFirstFunction(m->mod) == nullptr &&
 	    LLVMGetFirstGlobal(m->mod) == nullptr) {
@@ -2395,33 +2422,6 @@ gb_internal WORKER_TASK_PROC(lb_llvm_module_pass_worker_proc) {
 	return 0;
 }
 
-
-
-gb_internal WORKER_TASK_PROC(lb_generate_procedures_worker_proc) {
-	lbModule *m = cast(lbModule *)data;
-	for (isize i = 0; i < m->procedures_to_generate.count; i++) {
-		lbProcedure *p = m->procedures_to_generate[i];
-		lb_generate_procedure(p->module, p);
-	}
-	return 0;
-}
-
-gb_internal void lb_generate_procedures(lbGenerator *gen, bool do_threading) {
-	if (do_threading) {
-		for (auto const &entry : gen->modules) {
-			lbModule *m = entry.value;
-			thread_pool_add_task(lb_generate_procedures_worker_proc, m);
-		}
-
-		thread_pool_wait();
-	} else {
-		for (auto const &entry : gen->modules) {
-			lbModule *m = entry.value;
-			lb_generate_procedures_worker_proc(m);
-		}
-	}
-}
-
 gb_internal WORKER_TASK_PROC(lb_generate_missing_procedures_to_check_worker_proc) {
 	lbModule *m = cast(lbModule *)data;
 	for (isize i = 0; i < m->missing_procedures_to_check.count; i++) {
@@ -3332,12 +3332,9 @@ gb_internal bool lb_generate_code(lbGenerator *gen) {
 		do_threading = false;
 	}
 
-	TIME_SECTION("LLVM Global Procedures and Types");
+	TIME_SECTION("LLVM Global Procedures and Types + Procedure Generation");
 	lb_create_global_procedures_and_types(gen, info, do_threading);
 
-	TIME_SECTION("LLVM Procedure Generation");
-	lb_generate_procedures(gen, do_threading);
-
 	if (build_context.command_kind == Command_test && !already_has_entry_point) {
 		TIME_SECTION("LLVM main");
 		lb_create_main_procedure(default_module, gen->startup_runtime, gen->cleanup_runtime);
-- 
cgit v1.2.3


From 37e1e00623c0a824ab8e4870f40de1f05ec4f010 Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Thu, 18 Sep 2025 16:57:21 +0100
Subject: Revert global procedure threading

---
 src/llvm_backend.cpp | 73 +++++++++++++++++++++++++++-------------------------
 1 file changed, 38 insertions(+), 35 deletions(-)

(limited to 'src/llvm_backend.cpp')

diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index 7360bdaa7..1524f6c25 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -2061,26 +2061,9 @@ gb_internal lbProcedure *lb_create_cleanup_runtime(lbModule *main_module) { // C
 	return p;
 }
 
-gb_internal void lb_generate_procedure(lbModule *m, lbProcedure *p);
-
-gb_internal WORKER_TASK_PROC(lb_generate_procedures_worker_proc) {
-	lbModule *m = cast(lbModule *)data;
-	for (isize i = 0; i < m->procedures_to_generate.count; i++) {
-		lbProcedure *p = m->procedures_to_generate[i];
-		lb_generate_procedure(p->module, p);
-	}
-	return 0;
-}
-
-
-struct lbGenerateProceduresWorkerData {
-	lbModule *m;
-	bool do_threading;
-};
 
 gb_internal WORKER_TASK_PROC(lb_generate_procedures_and_types_per_module) {
-	lbGenerateProceduresWorkerData *wd = cast(lbGenerateProceduresWorkerData *)data;
-	lbModule *m = wd->m;
+	lbModule *m = cast(lbModule *)data;
 	for (Entity *e : m->global_types_to_create) {
 		(void)lb_get_entity_name(m, e);
 		(void)lb_type(m, e->type);
@@ -2090,10 +2073,6 @@ gb_internal WORKER_TASK_PROC(lb_generate_procedures_and_types_per_module) {
 		(void)lb_get_entity_name(m, e);
 		array_add(&m->procedures_to_generate, lb_create_procedure(m, e));
 	}
-
-	if (wd->do_threading) {
-		thread_pool_add_task(lb_generate_procedures_worker_proc, m);
-	}
 	return 0;
 }
 
@@ -2183,22 +2162,13 @@ gb_internal void lb_create_global_procedures_and_types(lbGenerator *gen, Checker
 
 	if (do_threading) {
 		for (auto const &entry : gen->modules) {
-			auto wd = permanent_alloc_item<lbGenerateProceduresWorkerData>();
-			wd->m = entry.value;
-			wd->do_threading = true;
-			thread_pool_add_task(lb_generate_procedures_and_types_per_module, wd);
+			lbModule *m = entry.value;
+			thread_pool_add_task(lb_generate_procedures_and_types_per_module, m);
 		}
 	} else {
-		for (auto const &entry : gen->modules) {
-			auto wd = permanent_alloc_item<lbGenerateProceduresWorkerData>();
-			wd->m = entry.value;
-			wd->do_threading = false;
-			lb_generate_procedures_and_types_per_module(wd);
-		}
-
 		for (auto const &entry : gen->modules) {
 			lbModule *m = entry.value;
-			lb_generate_procedures_worker_proc(m);
+			lb_generate_procedures_and_types_per_module(m);
 		}
 
 	}
@@ -2206,6 +2176,9 @@ gb_internal void lb_create_global_procedures_and_types(lbGenerator *gen, Checker
 	thread_pool_wait();
 }
 
+gb_internal void lb_generate_procedure(lbModule *m, lbProcedure *p);
+
+
 gb_internal bool lb_is_module_empty(lbModule *m) {
 	if (LLVMGetFirstFunction(m->mod) == nullptr &&
 	    LLVMGetFirstGlobal(m->mod) == nullptr) {
@@ -2422,6 +2395,33 @@ gb_internal WORKER_TASK_PROC(lb_llvm_module_pass_worker_proc) {
 	return 0;
 }
 
+
+
+gb_internal WORKER_TASK_PROC(lb_generate_procedures_worker_proc) {
+	lbModule *m = cast(lbModule *)data;
+	for (isize i = 0; i < m->procedures_to_generate.count; i++) {
+		lbProcedure *p = m->procedures_to_generate[i];
+		lb_generate_procedure(p->module, p);
+	}
+	return 0;
+}
+
+gb_internal void lb_generate_procedures(lbGenerator *gen, bool do_threading) {
+	if (do_threading) {
+		for (auto const &entry : gen->modules) {
+			lbModule *m = entry.value;
+			thread_pool_add_task(lb_generate_procedures_worker_proc, m);
+		}
+
+		thread_pool_wait();
+	} else {
+		for (auto const &entry : gen->modules) {
+			lbModule *m = entry.value;
+			lb_generate_procedures_worker_proc(m);
+		}
+	}
+}
+
 gb_internal WORKER_TASK_PROC(lb_generate_missing_procedures_to_check_worker_proc) {
 	lbModule *m = cast(lbModule *)data;
 	for (isize i = 0; i < m->missing_procedures_to_check.count; i++) {
@@ -3332,9 +3332,12 @@ gb_internal bool lb_generate_code(lbGenerator *gen) {
 		do_threading = false;
 	}
 
-	TIME_SECTION("LLVM Global Procedures and Types + Procedure Generation");
+	TIME_SECTION("LLVM Global Procedures and Types");
 	lb_create_global_procedures_and_types(gen, info, do_threading);
 
+	TIME_SECTION("LLVM Procedure Generation");
+	lb_generate_procedures(gen, do_threading);
+
 	if (build_context.command_kind == Command_test && !already_has_entry_point) {
 		TIME_SECTION("LLVM main");
 		lb_create_main_procedure(default_module, gen->startup_runtime, gen->cleanup_runtime);
-- 
cgit v1.2.3


From 4b0a07ba27abf76aa35c364a4c7b71745a1969d7 Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Thu, 18 Sep 2025 17:06:09 +0100
Subject: Minor rearrangement

---
 src/llvm_backend.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'src/llvm_backend.cpp')

diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index 1524f6c25..46c319a90 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -3458,6 +3458,9 @@ gb_internal bool lb_generate_code(lbGenerator *gen) {
 		}
 	}
 
+	TIME_SECTION("LLVM Add Foreign Library Paths");
+	lb_add_foreign_library_paths(gen);
+
 	TIME_SECTION("LLVM Function Pass");
 	lb_llvm_function_passes(gen, do_threading && !build_context.ODIN_DEBUG);
 
@@ -3494,9 +3497,6 @@ gb_internal bool lb_generate_code(lbGenerator *gen) {
 		}
 	}
 
-	TIME_SECTION("LLVM Add Foreign Library Paths");
-	lb_add_foreign_library_paths(gen);
-
 	TIME_SECTION("LLVM Correct Entity Linkage");
 	lb_correct_entity_linkage(gen);
 
-- 
cgit v1.2.3


From 9cf69576ab8cb220af5802a04a0aa53dc92046a5 Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Thu, 18 Sep 2025 20:58:24 +0100
Subject: More improvements to minimize code gen size

---
 base/runtime/core_builtin.odin         | 22 +++++++++++++------
 base/runtime/dynamic_map_internal.odin |  3 +++
 src/build_settings.cpp                 |  1 +
 src/llvm_backend.cpp                   | 39 ++++++++++++++++++++++++++--------
 src/llvm_backend.hpp                   |  4 ++--
 src/llvm_backend_general.cpp           |  6 +++---
 src/main.cpp                           |  6 ++++++
 7 files changed, 60 insertions(+), 21 deletions(-)

(limited to 'src/llvm_backend.cpp')

diff --git a/base/runtime/core_builtin.odin b/base/runtime/core_builtin.odin
index 497c4b147..903ea7ed7 100644
--- a/base/runtime/core_builtin.odin
+++ b/base/runtime/core_builtin.odin
@@ -166,11 +166,17 @@ remove_range :: proc(array: ^$D/[dynamic]$T, #any_int lo, hi: int, loc := #calle
 @builtin
 pop :: proc(array: ^$T/[dynamic]$E, loc := #caller_location) -> (res: E) #no_bounds_check {
 	assert(len(array) > 0, loc=loc)
-	res = array[len(array)-1]
-	(^Raw_Dynamic_Array)(array).len -= 1
+	_pop_type_erased(&res, (^Raw_Dynamic_Array)(array), size_of(E))
 	return res
 }
 
+_pop_type_erased :: proc(res: rawptr, array: ^Raw_Dynamic_Array, elem_size: int, loc := #caller_location) {
+	end := rawptr(uintptr(array.data) + uintptr(elem_size*(array.len-1)))
+	intrinsics.mem_copy_non_overlapping(res, end, elem_size)
+	array.len -= 1
+}
+
+
 
 // `pop_safe` trys to remove and return the end value of dynamic array `array` and reduces the length of `array` by 1.
 // If the operation is not possible, it will return false.
@@ -387,16 +393,18 @@ make_slice :: proc($T: typeid/[]$E, #any_int len: int, allocator := context.allo
 //
 // Note: Prefer using the procedure group `make`.
 @(builtin, require_results)
-make_dynamic_array :: proc($T: typeid/[dynamic]$E, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) #optional_allocator_error {
-	return make_dynamic_array_len_cap(T, 0, 0, allocator, loc)
+make_dynamic_array :: proc($T: typeid/[dynamic]$E, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_allocator_error {
+	err = _make_dynamic_array_len_cap((^Raw_Dynamic_Array)(&array), size_of(E), align_of(E), 0, 0, allocator, loc)
+	return
 }
 // `make_dynamic_array_len` allocates and initializes a dynamic array. Like `new`, the first argument is a type, not a value.
 // Unlike `new`, `make`'s return value is the same as the type of its argument, not a pointer to it.
 //
 // Note: Prefer using the procedure group `make`.
 @(builtin, require_results)
-make_dynamic_array_len :: proc($T: typeid/[dynamic]$E, #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) #optional_allocator_error {
-	return make_dynamic_array_len_cap(T, len, len, allocator, loc)
+make_dynamic_array_len :: proc($T: typeid/[dynamic]$E, #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_allocator_error {
+	err = _make_dynamic_array_len_cap((^Raw_Dynamic_Array)(&array), size_of(E), align_of(E), len, len, allocator, loc)
+	return
 }
 // `make_dynamic_array_len_cap` allocates and initializes a dynamic array. Like `new`, the first argument is a type, not a value.
 // Unlike `new`, `make`'s return value is the same as the type of its argument, not a pointer to it.
@@ -501,7 +509,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, #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
+	return __dynamic_map_reserve((^Raw_Map)(m), map_info(T), uint(capacity), loc)
 }
 
 // Shrinks the capacity of a map down to the current length.
diff --git a/base/runtime/dynamic_map_internal.odin b/base/runtime/dynamic_map_internal.odin
index 7b65a2fa0..e288d1f53 100644
--- a/base/runtime/dynamic_map_internal.odin
+++ b/base/runtime/dynamic_map_internal.odin
@@ -985,6 +985,9 @@ __dynamic_map_entry :: proc "odin" (#no_alias m: ^Raw_Map, #no_alias info: ^Map_
 // IMPORTANT: USED WITHIN THE COMPILER
 @(private)
 __dynamic_map_reserve :: proc "odin" (#no_alias m: ^Raw_Map, #no_alias info: ^Map_Info, new_capacity: uint, loc := #caller_location) -> Allocator_Error {
+	if m == nil {
+		return nil
+	}
 	return map_reserve_dynamic(m, info, uintptr(new_capacity), loc)
 }
 
diff --git a/src/build_settings.cpp b/src/build_settings.cpp
index 867c80ac1..54f11a42d 100644
--- a/src/build_settings.cpp
+++ b/src/build_settings.cpp
@@ -555,6 +555,7 @@ struct BuildContext {
 	bool internal_no_inline;
 	bool internal_by_value;
 	bool internal_weak_monomorphization;
+	bool internal_ignore_llvm_verification;
 
 	bool   no_threaded_checker;
 
diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index 46c319a90..5d2accd90 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -8,7 +8,11 @@
 #endif
 
 #ifndef LLVM_IGNORE_VERIFICATION
-#define LLVM_IGNORE_VERIFICATION 0
+#define LLVM_IGNORE_VERIFICATION build_context.internal_ignore_llvm_verification
+#endif
+
+#ifndef LLVM_WEAK_MONOMORPHIZATION
+#define LLVM_WEAK_MONOMORPHIZATION build_context.internal_weak_monomorphization
 #endif
 
 
@@ -620,6 +624,7 @@ gb_internal lbValue lb_hasher_proc_for_type(lbModule *m, Type *type) {
 
 #define LLVM_SET_VALUE_NAME(value, name) LLVMSetValueName2((value), (name), gb_count_of((name))-1);
 
+
 gb_internal lbValue lb_map_get_proc_for_type(lbModule *m, Type *type) {
 	GB_ASSERT(!build_context.dynamic_map_calls);
 	type = base_type(type);
@@ -634,6 +639,9 @@ gb_internal lbValue lb_map_get_proc_for_type(lbModule *m, Type *type) {
 
 	lbProcedure *p = lb_create_dummy_procedure(m, proc_name, t_map_get_proc);
 	string_map_set(&m->gen_procs, proc_name, p);
+
+	p->internal_gen_type = type;
+
 	lb_begin_procedure_body(p);
 	defer (lb_end_procedure_body(p));
 
@@ -1891,6 +1899,10 @@ gb_internal void lb_verify_function(lbModule *m, lbProcedure *p, bool dump_ll=fa
 }
 
 gb_internal WORKER_TASK_PROC(lb_llvm_module_verification_worker_proc) {
+	if (LLVM_IGNORE_VERIFICATION) {
+		return 0;
+	}
+
 	char *llvm_error = nullptr;
 	defer (LLVMDisposeMessage(llvm_error));
 	lbModule *m = cast(lbModule *)data;
@@ -2298,6 +2310,14 @@ gb_internal WORKER_TASK_PROC(lb_llvm_function_pass_per_module) {
 }
 
 
+void lb_remove_unused_functions_and_globals(lbGenerator *gen) {
+	for (auto &entry : gen->modules) {
+		lbModule *m = entry.value;
+		lb_run_remove_unused_function_pass(m);
+		lb_run_remove_unused_globals_pass(m);
+	}
+}
+
 struct lbLLVMModulePassWorkerData {
 	lbModule *m;
 	LLVMTargetMachineRef target_machine;
@@ -2307,9 +2327,6 @@ struct lbLLVMModulePassWorkerData {
 gb_internal WORKER_TASK_PROC(lb_llvm_module_pass_worker_proc) {
 	auto wd = cast(lbLLVMModulePassWorkerData *)data;
 
-	lb_run_remove_unused_function_pass(wd->m);
-	lb_run_remove_unused_globals_pass(wd->m);
-
 	LLVMPassManagerRef module_pass_manager = LLVMCreatePassManager();
 	lb_populate_module_pass_manager(wd->target_machine, module_pass_manager, build_context.optimization_level);
 	LLVMRunPassManager(module_pass_manager, wd->m->mod);
@@ -2386,6 +2403,10 @@ gb_internal WORKER_TASK_PROC(lb_llvm_module_pass_worker_proc) {
 	}
 #endif
 
+	if (LLVM_IGNORE_VERIFICATION) {
+		return 0;
+	}
+
 	if (wd->do_threading) {
 		thread_pool_add_task(lb_llvm_module_verification_worker_proc, wd->m);
 	} else {
@@ -3464,12 +3485,14 @@ gb_internal bool lb_generate_code(lbGenerator *gen) {
 	TIME_SECTION("LLVM Function Pass");
 	lb_llvm_function_passes(gen, do_threading && !build_context.ODIN_DEBUG);
 
+	TIME_SECTION("LLVM Remove Unused Functions and Globals");
+	lb_remove_unused_functions_and_globals(gen);
+
 	TIME_SECTION("LLVM Module Pass and Verification");
 	lb_llvm_module_passes_and_verification(gen, do_threading);
 
-	if (gen->module_verification_failed.load(std::memory_order_relaxed)) {
-		return false;
-	}
+	TIME_SECTION("LLVM Correct Entity Linkage");
+	lb_correct_entity_linkage(gen);
 
 	llvm_error = nullptr;
 	defer (LLVMDisposeMessage(llvm_error));
@@ -3497,8 +3520,6 @@ gb_internal bool lb_generate_code(lbGenerator *gen) {
 		}
 	}
 
-	TIME_SECTION("LLVM Correct Entity Linkage");
-	lb_correct_entity_linkage(gen);
 
 	////////////////////////////////////////////
 	for (auto const &entry: gen->modules) {
diff --git a/src/llvm_backend.hpp b/src/llvm_backend.hpp
index 5d6f56433..698e7657f 100644
--- a/src/llvm_backend.hpp
+++ b/src/llvm_backend.hpp
@@ -241,8 +241,6 @@ struct lbGenerator : LinkerData {
 
 	isize used_module_count;
 
-	std::atomic<bool> module_verification_failed;
-
 	lbProcedure *startup_runtime;
 	lbProcedure *cleanup_runtime;
 	lbProcedure *objc_names;
@@ -409,6 +407,8 @@ struct lbProcedure {
 	void (*generate_body)(lbModule *m, lbProcedure *p);
 	Array<lbGlobalVariable> *global_variables;
 	lbProcedure *objc_names;
+
+	Type *internal_gen_type; // map_set, map_get, etc.
 };
 
 
diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index 3ac405e0b..fb9fa4cea 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -154,7 +154,7 @@ gb_internal bool lb_init_generator(lbGenerator *gen, Checker *c) {
 			map_set(&gen->modules, cast(void *)pkg, m);
 			lb_init_module(m, c);
 
-			if (build_context.internal_weak_monomorphization) {
+			if (LLVM_WEAK_MONOMORPHIZATION) {
 				auto pm = gb_alloc_item(permanent_allocator(), lbModule);
 				pm->pkg = pkg;
 				pm->gen = gen;
@@ -181,7 +181,7 @@ gb_internal bool lb_init_generator(lbGenerator *gen, Checker *c) {
 				lb_init_module(m, c);
 
 
-				if (build_context.internal_weak_monomorphization) {
+				if (LLVM_WEAK_MONOMORPHIZATION) {
 					auto pm  = gb_alloc_item(permanent_allocator(), lbModule);
 					pm->file = file;
 					pm->pkg  = pkg;
@@ -469,7 +469,7 @@ gb_internal lbModule *lb_module_of_entity(lbGenerator *gen, Entity *e, lbModule
 	GB_ASSERT(curr_module != nullptr);
 	lbModule *m = lb_module_of_entity_internal(gen, e, curr_module);
 
-	if (USE_SEPARATE_MODULES && build_context.internal_weak_monomorphization) {
+	if (USE_SEPARATE_MODULES) {
 		if (e->kind == Entity_Procedure && e->Procedure.generated_from_polymorphic) {
 			if (m->polymorphic_module) {
 				return m->polymorphic_module;
diff --git a/src/main.cpp b/src/main.cpp
index 130c3f31d..bbaf6f23f 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -404,6 +404,7 @@ enum BuildFlagKind {
 	BuildFlag_InternalNoInline,
 	BuildFlag_InternalByValue,
 	BuildFlag_InternalWeakMonomorphization,
+	BuildFlag_InternalLLVMVerification,
 
 	BuildFlag_Tilde,
 
@@ -628,6 +629,7 @@ gb_internal bool parse_build_flags(Array<String> args) {
 	add_flag(&build_flags, BuildFlag_InternalNoInline,        str_lit("internal-no-inline"),        BuildFlagParam_None,    Command_all);
 	add_flag(&build_flags, BuildFlag_InternalByValue,         str_lit("internal-by-value"),         BuildFlagParam_None,    Command_all);
 	add_flag(&build_flags, BuildFlag_InternalWeakMonomorphization, str_lit("internal-weak-monomorphization"), BuildFlagParam_None, Command_all);
+	add_flag(&build_flags, BuildFlag_InternalLLVMVerification, str_lit("internal-ignore-llvm-verification"), BuildFlagParam_None, Command_all);
 
 #if ALLOW_TILDE
 	add_flag(&build_flags, BuildFlag_Tilde,                   str_lit("tilde"),                     BuildFlagParam_None,    Command__does_build);
@@ -1589,6 +1591,10 @@ gb_internal bool parse_build_flags(Array<String> args) {
 						case BuildFlag_InternalWeakMonomorphization:
 							build_context.internal_weak_monomorphization = true;
 							break;
+						case BuildFlag_InternalLLVMVerification:
+							build_context.internal_ignore_llvm_verification = true;
+							break;
+
 
 						case BuildFlag_Tilde:
 							build_context.tilde_backend = true;
-- 
cgit v1.2.3


From ec91e2c15b9b51f1ef70055a8b4900c754b1f100 Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Fri, 19 Sep 2025 13:52:25 +0100
Subject: Separate ini global var stuff

---
 src/llvm_backend.cpp | 139 ++++++++++++++++++++++++++++-----------------------
 1 file changed, 76 insertions(+), 63 deletions(-)

(limited to 'src/llvm_backend.cpp')

diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index 77576cfd4..688cfb550 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -1924,6 +1924,74 @@ gb_internal WORKER_TASK_PROC(lb_llvm_module_verification_worker_proc) {
 	return 0;
 }
 
+gb_internal bool lb_init_global_var(lbModule *m, lbProcedure *p, Entity *e, Ast *init_expr, lbGlobalVariable &var) {
+	if (init_expr != nullptr)  {
+		lbValue init = lb_build_expr(p, init_expr);
+		if (init.value == nullptr) {
+			LLVMTypeRef global_type = llvm_addr_type(p->module, var.var);
+			if (is_type_untyped_nil(init.type)) {
+				LLVMSetInitializer(var.var.value, LLVMConstNull(global_type));
+				var.is_initialized = true;
+
+				if (e->Variable.is_rodata) {
+					LLVMSetGlobalConstant(var.var.value, true);
+				}
+				return true;
+			}
+			GB_PANIC("Invalid init value, got %s", expr_to_string(init_expr));
+		}
+
+		if (is_type_any(e->type) || is_type_union(e->type)) {
+			var.init = init;
+		} else if (lb_is_const_or_global(init)) {
+			if (!var.is_initialized) {
+				if (is_type_proc(init.type)) {
+					init.value = LLVMConstPointerCast(init.value, lb_type(p->module, init.type));
+				}
+				LLVMSetInitializer(var.var.value, init.value);
+				var.is_initialized = true;
+
+				if (e->Variable.is_rodata) {
+					LLVMSetGlobalConstant(var.var.value, true);
+				}
+				return true;
+			}
+		} else {
+			var.init = init;
+		}
+	}
+
+	if (var.init.value != nullptr) {
+		GB_ASSERT(!var.is_initialized);
+		Type *t = type_deref(var.var.type);
+
+		if (is_type_any(t)) {
+			// NOTE(bill): Edge case for 'any' type
+			Type *var_type = default_type(var.init.type);
+			gbString var_name = gb_string_make(permanent_allocator(), "__$global_any::");
+			gbString e_str = string_canonical_entity_name(temporary_allocator(), e);
+			var_name = gb_string_append_length(var_name, e_str, gb_strlen(e_str));
+			lbAddr g = lb_add_global_generated_with_name(m, var_type, {}, make_string_c(var_name));
+			lb_addr_store(p, g, var.init);
+			lbValue gp = lb_addr_get_ptr(p, g);
+
+			lbValue data = lb_emit_struct_ep(p, var.var, 0);
+			lbValue ti   = lb_emit_struct_ep(p, var.var, 1);
+			lb_emit_store(p, data, lb_emit_conv(p, gp, t_rawptr));
+			lb_emit_store(p, ti,   lb_typeid(p->module, var_type));
+		} else {
+			LLVMTypeRef vt = llvm_addr_type(p->module, var.var);
+			lbValue src0 = lb_emit_conv(p, var.init, t);
+			LLVMValueRef src = OdinLLVMBuildTransmute(p, src0.value, vt);
+			LLVMValueRef dst = var.var.value;
+			LLVMBuildStore(p->builder, src, dst);
+		}
+
+		var.is_initialized = true;
+	}
+	return false;
+}
+
 
 gb_internal void lb_create_startup_runtime_generate_body(lbModule *m, lbProcedure *p) {
 	lb_begin_procedure_body(p);
@@ -1944,73 +2012,13 @@ gb_internal void lb_create_startup_runtime_generate_body(lbModule *m, lbProcedur
 		Entity *e = var.decl->entity;
 		GB_ASSERT(e->kind == Entity_Variable);
 		e->code_gen_module = entity_module;
-
 		Ast *init_expr = var.decl->init_expr;
-		if (init_expr != nullptr)  {
-			lbValue init = lb_build_expr(p, init_expr);
-			if (init.value == nullptr) {
-				LLVMTypeRef global_type = llvm_addr_type(p->module, var.var);
-				if (is_type_untyped_nil(init.type)) {
-					LLVMSetInitializer(var.var.value, LLVMConstNull(global_type));
-					var.is_initialized = true;
-
-					if (e->Variable.is_rodata) {
-						LLVMSetGlobalConstant(var.var.value, true);
-					}
-					continue;
-				}
-				GB_PANIC("Invalid init value, got %s", expr_to_string(init_expr));
-			}
-
-			if (is_type_any(e->type) || is_type_union(e->type)) {
-				var.init = init;
-			} else if (lb_is_const_or_global(init)) {
-				if (!var.is_initialized) {
-					if (is_type_proc(init.type)) {
-						init.value = LLVMConstPointerCast(init.value, lb_type(p->module, init.type));
-					}
-					LLVMSetInitializer(var.var.value, init.value);
-					var.is_initialized = true;
 
-					if (e->Variable.is_rodata) {
-						LLVMSetGlobalConstant(var.var.value, true);
-					}
-					continue;
-				}
-			} else {
-				var.init = init;
-			}
-		}
-
-		if (var.init.value != nullptr) {
-			GB_ASSERT(!var.is_initialized);
-			Type *t = type_deref(var.var.type);
-
-			if (is_type_any(t)) {
-				// NOTE(bill): Edge case for 'any' type
-				Type *var_type = default_type(var.init.type);
-				gbString var_name = gb_string_make(permanent_allocator(), "__$global_any::");
-				gbString e_str = string_canonical_entity_name(temporary_allocator(), e);
-				var_name = gb_string_append_length(var_name, e_str, gb_strlen(e_str));
-				lbAddr g = lb_add_global_generated_with_name(m, var_type, {}, make_string_c(var_name));
-				lb_addr_store(p, g, var.init);
-				lbValue gp = lb_addr_get_ptr(p, g);
-
-				lbValue data = lb_emit_struct_ep(p, var.var, 0);
-				lbValue ti   = lb_emit_struct_ep(p, var.var, 1);
-				lb_emit_store(p, data, lb_emit_conv(p, gp, t_rawptr));
-				lb_emit_store(p, ti,   lb_typeid(p->module, var_type));
-			} else {
-				LLVMTypeRef vt = llvm_addr_type(p->module, var.var);
-				lbValue src0 = lb_emit_conv(p, var.init, t);
-				LLVMValueRef src = OdinLLVMBuildTransmute(p, src0.value, vt);
-				LLVMValueRef dst = var.var.value;
-				LLVMBuildStore(p->builder, src, dst);
-			}
-
-			var.is_initialized = true;
+		if (init_expr == nullptr && var.init.value == nullptr) {
+			continue;
 		}
 
+		lb_init_global_var(m, p, e, init_expr, var);
 
 	}
 	CheckerInfo *info = m->gen->info;
@@ -2448,7 +2456,12 @@ gb_internal WORKER_TASK_PROC(lb_generate_missing_procedures_to_check_worker_proc
 	for (isize i = 0; i < m->missing_procedures_to_check.count; i++) {
 		lbProcedure *p = m->missing_procedures_to_check[i];
 		debugf("Generate missing procedure: %.*s module %p\n", LIT(p->name), m);
+		isize count = m->procedures_to_generate.count;
 		lb_generate_procedure(m, p);
+		isize new_count = m->procedures_to_generate.count;
+		if (count != new_count) {
+			gb_printf_err("NEW STUFF!\n");
+		}
 	}
 	return 0;
 }
-- 
cgit v1.2.3


From f1e3977cf94dfc0457f05d499cc280d8e1329086 Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Fri, 19 Sep 2025 13:57:52 +0100
Subject: Split up startup call into separate calls

---
 src/llvm_backend.cpp | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

(limited to 'src/llvm_backend.cpp')

diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index 688cfb550..5c75d2570 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -2001,6 +2001,8 @@ gb_internal void lb_create_startup_runtime_generate_body(lbModule *m, lbProcedur
 	if (p->objc_names) {
 		LLVMBuildCall2(p->builder, lb_type_internal_for_procedures_raw(m, p->objc_names->type), p->objc_names->value, nullptr, 0, "");
 	}
+	Type *dummy_type = alloc_type_proc(nullptr, nullptr, 0, nullptr, 0, false, ProcCC_Odin);
+	LLVMTypeRef raw_dummy_type = lb_type_internal_for_procedures_raw(m, dummy_type);
 
 	for (auto &var : *p->global_variables) {
 		if (var.is_initialized) {
@@ -2018,8 +2020,25 @@ gb_internal void lb_create_startup_runtime_generate_body(lbModule *m, lbProcedur
 			continue;
 		}
 
-		lb_init_global_var(m, p, e, init_expr, var);
+		if (type_size_of(e->type) > 32) {
+			String ename = lb_get_entity_name(m, e);
+			gbString name = gb_string_make(permanent_allocator(), "");
+			name = gb_string_appendc(name, "__$startup$");
+			name = gb_string_append_length(name, ename.text, ename.len);
 
+			lbProcedure *dummy = lb_create_dummy_procedure(m, make_string_c(name), dummy_type);
+			LLVMSetVisibility(dummy->value, LLVMHiddenVisibility);
+			LLVMSetLinkage(dummy->value, LLVMWeakAnyLinkage);
+
+			lb_begin_procedure_body(dummy);
+			lb_init_global_var(m, dummy, e, init_expr, var);
+			lb_end_procedure_body(dummy);
+
+			LLVMValueRef context_ptr = lb_find_or_generate_context_ptr(p).addr.value;
+			LLVMBuildCall2(p->builder, raw_dummy_type, dummy->value, &context_ptr, 1, "");
+		} else {
+			lb_init_global_var(m, p, e, init_expr, var);
+		}
 	}
 	CheckerInfo *info = m->gen->info;
 
-- 
cgit v1.2.3


From ee3b10335b09181808fd98ccf46fe9369a11db13 Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Fri, 19 Sep 2025 13:59:58 +0100
Subject: Split further

---
 src/llvm_backend.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/llvm_backend.cpp')

diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index 5c75d2570..f18d4af64 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -2020,7 +2020,7 @@ gb_internal void lb_create_startup_runtime_generate_body(lbModule *m, lbProcedur
 			continue;
 		}
 
-		if (type_size_of(e->type) > 32) {
+		if (type_size_of(e->type) > 8) {
 			String ename = lb_get_entity_name(m, e);
 			gbString name = gb_string_make(permanent_allocator(), "");
 			name = gb_string_appendc(name, "__$startup$");
-- 
cgit v1.2.3


From 6bca1475edb8e2aec4bcbe942835bcc54f9e837e Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Fri, 19 Sep 2025 14:15:25 +0100
Subject: Convert `procedures_to_generate` to a queue

---
 src/llvm_backend.cpp         | 54 +++++++++++++++++++++++++-------------------
 src/llvm_backend.hpp         |  7 +++++-
 src/llvm_backend_general.cpp | 18 ++++++++++++---
 src/llvm_backend_proc.cpp    |  2 +-
 src/llvm_backend_stmt.cpp    |  2 +-
 5 files changed, 54 insertions(+), 29 deletions(-)

(limited to 'src/llvm_backend.cpp')

diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index f18d4af64..3ac5970f8 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -246,26 +246,12 @@ gb_internal String lb_internal_gen_name_from_type(char const *prefix, Type *type
 	return proc_name;
 }
 
-
-gb_internal lbValue lb_equal_proc_for_type(lbModule *m, Type *type) {
-	type = base_type(type);
-	GB_ASSERT(is_type_comparable(type));
+gb_internal void lb_equal_proc_generate_body(lbModule *m, lbProcedure *p) {
+	Type *type = p->internal_gen_type;
 
 	Type *pt = alloc_type_pointer(type);
 	LLVMTypeRef ptr_type = lb_type(m, pt);
 
-	String proc_name = lb_internal_gen_name_from_type("__$equal", type);
-	lbProcedure **found = string_map_get(&m->gen_procs, proc_name);
-	lbProcedure *compare_proc = nullptr;
-	if (found) {
-		compare_proc = *found;
-		GB_ASSERT(compare_proc != nullptr);
-		return {compare_proc->value, compare_proc->type};
-	}
-
-
-	lbProcedure *p = lb_create_dummy_procedure(m, proc_name, t_equal_proc);
-	string_map_set(&m->gen_procs, proc_name, p);
 	lb_begin_procedure_body(p);
 
 	LLVMSetLinkage(p->value, LLVMInternalLinkage);
@@ -393,9 +379,29 @@ gb_internal lbValue lb_equal_proc_for_type(lbModule *m, Type *type) {
 	}
 
 	lb_end_procedure_body(p);
+}
+
+gb_internal lbValue lb_equal_proc_for_type(lbModule *m, Type *type) {
+	type = base_type(type);
+	GB_ASSERT(is_type_comparable(type));
+
+	String proc_name = lb_internal_gen_name_from_type("__$equal", type);
+	lbProcedure **found = string_map_get(&m->gen_procs, proc_name);
+	if (found) {
+		lbProcedure *p = *found;
+		GB_ASSERT(p != nullptr);
+		return {p->value, p->type};
+	}
 
-	compare_proc = p;
-	return {compare_proc->value, compare_proc->type};
+	lbProcedure *p = lb_create_dummy_procedure(m, proc_name, t_equal_proc);
+	string_map_set(&m->gen_procs, proc_name, p);
+	p->internal_gen_type = type;
+	p->generate_body = lb_equal_proc_generate_body;
+
+	// p->generate_body(m, p);
+	mpsc_enqueue(&m->procedures_to_generate, p);
+
+	return {p->value, p->type};
 }
 
 gb_internal lbValue lb_simple_compare_hash(lbProcedure *p, Type *type, lbValue data, lbValue seed) {
@@ -2068,7 +2074,7 @@ gb_internal lbProcedure *lb_create_startup_runtime(lbModule *main_module, lbProc
 	p->global_variables = &global_variables;
 	p->objc_names       = objc_names;
 
-	array_add(&main_module->procedures_to_generate, p);
+	mpsc_enqueue(&main_module->procedures_to_generate, p);
 
 	return p;
 }
@@ -2110,7 +2116,7 @@ gb_internal WORKER_TASK_PROC(lb_generate_procedures_and_types_per_module) {
 
 	for (Entity *e : m->global_procedures_to_create) {
 		(void)lb_get_entity_name(m, e);
-		array_add(&m->procedures_to_generate, lb_create_procedure(m, e));
+		mpsc_enqueue(&m->procedures_to_generate, lb_create_procedure(m, e));
 	}
 	return 0;
 }
@@ -2298,7 +2304,7 @@ gb_internal WORKER_TASK_PROC(lb_llvm_function_pass_per_module) {
 		lb_llvm_function_pass_per_function_internal(m, m->gen->objc_names);
 	}
 
-	for (lbProcedure *p : m->procedures_to_generate) {
+	MUTEX_GUARD_BLOCK(&m->generated_procedures_mutex) for (lbProcedure *p : m->generated_procedures) {
 		if (p->body != nullptr) { // Build Procedure
 			lbFunctionPassManagerKind pass_manager_kind = lbFunctionPassManager_default;
 			if (p->flags & lbProcedureFlag_WithoutMemcpyPass) {
@@ -2447,8 +2453,7 @@ gb_internal WORKER_TASK_PROC(lb_llvm_module_pass_worker_proc) {
 
 gb_internal WORKER_TASK_PROC(lb_generate_procedures_worker_proc) {
 	lbModule *m = cast(lbModule *)data;
-	for (isize i = 0; i < m->procedures_to_generate.count; i++) {
-		lbProcedure *p = m->procedures_to_generate[i];
+	for (lbProcedure *p = nullptr; mpsc_dequeue(&m->procedures_to_generate, &p); /**/) {
 		lb_generate_procedure(p->module, p);
 	}
 	return 0;
@@ -2876,6 +2881,9 @@ gb_internal void lb_generate_procedure(lbModule *m, lbProcedure *p) {
 	}
 
 	lb_verify_function(m, p, true);
+
+	MUTEX_GUARD(&m->generated_procedures_mutex);
+	array_add(&m->generated_procedures, p);
 }
 
 
diff --git a/src/llvm_backend.hpp b/src/llvm_backend.hpp
index 7fe4651bb..6d94df399 100644
--- a/src/llvm_backend.hpp
+++ b/src/llvm_backend.hpp
@@ -186,10 +186,13 @@ struct lbModule {
 
 	StringMap<lbProcedure *> gen_procs;   // key is the canonicalized name
 
-	Array<lbProcedure *> procedures_to_generate;
+	MPSCQueue<lbProcedure *> procedures_to_generate;
 	Array<Entity *> global_procedures_to_create;
 	Array<Entity *> global_types_to_create;
 
+	BlockingMutex generated_procedures_mutex;
+	Array<lbProcedure *> generated_procedures;
+
 	lbProcedure *curr_procedure;
 
 	LLVMBuilderRef const_dummy_builder;
@@ -238,6 +241,8 @@ struct lbGenerator : LinkerData {
 	PtrMap<LLVMContextRef, lbModule *> modules_through_ctx; 
 	lbModule default_module;
 
+	lbModule *equal_module;
+
 	isize used_module_count;
 
 	lbProcedure *startup_runtime;
diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index 49a7fb13f..c84edc178 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -97,12 +97,16 @@ gb_internal WORKER_TASK_PROC(lb_init_module_worker_proc) {
 	map_init(&m->function_type_map);
 	string_map_init(&m->gen_procs);
 	if (USE_SEPARATE_MODULES) {
-		array_init(&m->procedures_to_generate, a, 0, 1<<10);
+		mpsc_init(&m->procedures_to_generate, a);
 		map_init(&m->procedure_values,               1<<11);
+		array_init(&m->generated_procedures,   a, 0, 1<<10);
 	} else {
-		array_init(&m->procedures_to_generate, a, 0, c->info.all_procedures.count);
+		mpsc_init(&m->procedures_to_generate, a);
 		map_init(&m->procedure_values,               c->info.all_procedures.count*2);
+		array_init(&m->generated_procedures,   a, 0, c->info.all_procedures.count*2);
 	}
+
+
 	array_init(&m->global_procedures_to_create, a, 0, 1024);
 	array_init(&m->global_types_to_create, a, 0, 1024);
 	array_init(&m->missing_procedures_to_check, a, 0, 16);
@@ -213,6 +217,14 @@ gb_internal bool lb_init_generator(lbGenerator *gen, Checker *c) {
 				}
 			}
 		}
+
+		if (LLVM_WEAK_MONOMORPHIZATION) {
+			lbModule *m = gb_alloc_item(permanent_allocator(), lbModule);
+			gen->equal_module = m;
+			m->checker = c;
+			map_set(&gen->modules, cast(void *)m, m); // point to itself just add it to the list
+			lb_init_module(m, do_threading);
+		}
 	}
 
 	gen->default_module.gen = gen;
@@ -3169,7 +3181,7 @@ gb_internal lbValue lb_generate_anonymous_proc_lit(lbModule *m, String const &pr
 		value.value = p->value;
 		value.type = p->type;
 
-		array_add(&m->procedures_to_generate, p);
+		mpsc_enqueue(&m->procedures_to_generate, p);
 		if (parent != nullptr) {
 			array_add(&parent->children, p);
 		} else {
diff --git a/src/llvm_backend_proc.cpp b/src/llvm_backend_proc.cpp
index f71b693eb..3b8a829b7 100644
--- a/src/llvm_backend_proc.cpp
+++ b/src/llvm_backend_proc.cpp
@@ -835,7 +835,7 @@ gb_internal void lb_build_nested_proc(lbProcedure *p, AstProcLit *pd, Entity *e)
 
 	lb_add_entity(m, e, value);
 	array_add(&p->children, nested_proc);
-	array_add(&m->procedures_to_generate, nested_proc);
+	mpsc_enqueue(&m->procedures_to_generate, nested_proc);
 }
 
 
diff --git a/src/llvm_backend_stmt.cpp b/src/llvm_backend_stmt.cpp
index 590920b59..f247fa2a7 100644
--- a/src/llvm_backend_stmt.cpp
+++ b/src/llvm_backend_stmt.cpp
@@ -92,7 +92,7 @@ gb_internal void lb_build_constant_value_decl(lbProcedure *p, AstValueDecl *vd)
 			value.value = nested_proc->value;
 			value.type = nested_proc->type;
 
-			array_add(&p->module->procedures_to_generate, nested_proc);
+			mpsc_enqueue(&p->module->procedures_to_generate, nested_proc);
 			array_add(&p->children, nested_proc);
 			string_map_set(&p->module->members, name, value);
 		}
-- 
cgit v1.2.3


From 76705c680087d58b6b50492f848a4804318d1ba8 Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Fri, 19 Sep 2025 14:18:09 +0100
Subject: Convert `missing_procedures_to_check` to a queue

---
 src/llvm_backend.cpp         | 14 +++++++-------
 src/llvm_backend.hpp         |  3 +--
 src/llvm_backend_general.cpp | 12 ++++--------
 3 files changed, 12 insertions(+), 17 deletions(-)

(limited to 'src/llvm_backend.cpp')

diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index 3ac5970f8..02df76243 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -2477,15 +2477,9 @@ gb_internal void lb_generate_procedures(lbGenerator *gen, bool do_threading) {
 
 gb_internal WORKER_TASK_PROC(lb_generate_missing_procedures_to_check_worker_proc) {
 	lbModule *m = cast(lbModule *)data;
-	for (isize i = 0; i < m->missing_procedures_to_check.count; i++) {
-		lbProcedure *p = m->missing_procedures_to_check[i];
+	for (lbProcedure *p = nullptr; mpsc_dequeue(&m->missing_procedures_to_check, &p); /**/) {
 		debugf("Generate missing procedure: %.*s module %p\n", LIT(p->name), m);
-		isize count = m->procedures_to_generate.count;
 		lb_generate_procedure(m, p);
-		isize new_count = m->procedures_to_generate.count;
-		if (count != new_count) {
-			gb_printf_err("NEW STUFF!\n");
-		}
 	}
 	return 0;
 }
@@ -2505,6 +2499,12 @@ gb_internal void lb_generate_missing_procedures(lbGenerator *gen, bool do_thread
 			lb_generate_missing_procedures_to_check_worker_proc(m);
 		}
 	}
+
+	for (auto const &entry : gen->modules) {
+		lbModule *m = entry.value;
+		GB_ASSERT(m->missing_procedures_to_check.count == 0);
+		GB_ASSERT(m->procedures_to_generate.count == 0);
+	}
 }
 
 gb_internal void lb_debug_info_complete_types_and_finalize(lbGenerator *gen) {
diff --git a/src/llvm_backend.hpp b/src/llvm_backend.hpp
index 6d94df399..559ec8300 100644
--- a/src/llvm_backend.hpp
+++ b/src/llvm_backend.hpp
@@ -176,8 +176,7 @@ struct lbModule {
 	StringMap<lbProcedure *> procedures;
 	PtrMap<LLVMValueRef, Entity *> procedure_values;
 
-	BlockingMutex missing_procedures_to_check_mutex;
-	Array<lbProcedure *> missing_procedures_to_check;
+	MPSCQueue<lbProcedure *> missing_procedures_to_check;
 
 	StringMap<LLVMValueRef>   const_strings;
 	String16Map<LLVMValueRef> const_string16s;
diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index c84edc178..cb8c9406e 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -109,7 +109,7 @@ gb_internal WORKER_TASK_PROC(lb_init_module_worker_proc) {
 
 	array_init(&m->global_procedures_to_create, a, 0, 1024);
 	array_init(&m->global_types_to_create, a, 0, 1024);
-	array_init(&m->missing_procedures_to_check, a, 0, 16);
+	mpsc_init(&m->missing_procedures_to_check, a);
 	map_init(&m->debug_values);
 
 	string_map_init(&m->objc_classes);
@@ -3079,18 +3079,16 @@ gb_internal lbValue lb_find_procedure_value_from_entity(lbModule *m, Entity *e)
 		// defer (mutex_unlock(&gen->anonymous_proc_lits_mutex));
 
 		GB_ASSERT(other_module != nullptr);
-		mutex_lock(&other_module->missing_procedures_to_check_mutex);
 		rw_mutex_shared_lock(&other_module->values_mutex);
 		auto *found = map_get(&other_module->values, e);
 		rw_mutex_shared_unlock(&other_module->values_mutex);
 		if (found == nullptr) {
 			// THIS IS THE RACE CONDITION
 			lbProcedure *missing_proc_in_other_module = lb_create_procedure(other_module, e, false);
-			array_add(&other_module->missing_procedures_to_check, missing_proc_in_other_module);
+			mpsc_enqueue(&other_module->missing_procedures_to_check, missing_proc_in_other_module);
 		}
-		mutex_unlock(&other_module->missing_procedures_to_check_mutex);
 	} else {
-		array_add(&m->missing_procedures_to_check, missing_proc);
+		mpsc_enqueue(&m->missing_procedures_to_check, missing_proc);
 	}
 
 	rw_mutex_shared_lock(&m->values_mutex);
@@ -3157,16 +3155,14 @@ gb_internal lbValue lb_generate_anonymous_proc_lit(lbModule *m, String const &pr
 
 
 	if (target_module != m) {
-		mutex_lock(&target_module->missing_procedures_to_check_mutex);
 		rw_mutex_shared_lock(&target_module->values_mutex);
 		lbValue *found = map_get(&target_module->values, e);
 		rw_mutex_shared_unlock(&target_module->values_mutex);
 		if (found == nullptr) {
 			lbProcedure *missing_proc_in_target_module = lb_create_procedure(target_module, e, false);
-			array_add(&target_module->missing_procedures_to_check, missing_proc_in_target_module);
+			mpsc_enqueue(&target_module->missing_procedures_to_check, missing_proc_in_target_module);
 		}
 
-		mutex_unlock(&target_module->missing_procedures_to_check_mutex);
 
 		lbProcedure *p = lb_create_procedure(m, e, true);
 
-- 
cgit v1.2.3


From 9b8771b475a2e0a75205408b2615f69d65a329bd Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Fri, 19 Sep 2025 16:15:04 +0100
Subject: Handle missing procedures better

---
 src/llvm_backend.cpp         | 16 +++++++++++-----
 src/llvm_backend.hpp         |  6 +++---
 src/llvm_backend_general.cpp |  9 +++++++--
 src/llvm_backend_proc.cpp    |  1 -
 4 files changed, 21 insertions(+), 11 deletions(-)

(limited to 'src/llvm_backend.cpp')

diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index 02df76243..1742271b6 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -12,7 +12,7 @@
 #endif
 
 #ifndef LLVM_WEAK_MONOMORPHIZATION
-#define LLVM_WEAK_MONOMORPHIZATION build_context.internal_weak_monomorphization
+#define LLVM_WEAK_MONOMORPHIZATION 1
 #endif
 
 
@@ -2478,8 +2478,14 @@ gb_internal void lb_generate_procedures(lbGenerator *gen, bool do_threading) {
 gb_internal WORKER_TASK_PROC(lb_generate_missing_procedures_to_check_worker_proc) {
 	lbModule *m = cast(lbModule *)data;
 	for (lbProcedure *p = nullptr; mpsc_dequeue(&m->missing_procedures_to_check, &p); /**/) {
-		debugf("Generate missing procedure: %.*s module %p\n", LIT(p->name), m);
-		lb_generate_procedure(m, p);
+		if (!p->is_done.load(std::memory_order_relaxed)) {
+			debugf("Generate missing procedure: %.*s module %p\n", LIT(p->name), m);
+			lb_generate_procedure(m, p);
+		}
+
+		for (lbProcedure *nested = nullptr; mpsc_dequeue(&m->procedures_to_generate, &nested); /**/) {
+			mpsc_enqueue(&m->missing_procedures_to_check, nested);
+		}
 	}
 	return 0;
 }
@@ -2860,7 +2866,7 @@ gb_internal lbProcedure *lb_create_main_procedure(lbModule *m, lbProcedure *star
 }
 
 gb_internal void lb_generate_procedure(lbModule *m, lbProcedure *p) {
-	if (p->is_done) {
+	if (p->is_done.load(std::memory_order_relaxed)) {
 		return;
 	}
 
@@ -2869,7 +2875,7 @@ gb_internal void lb_generate_procedure(lbModule *m, lbProcedure *p) {
 		lb_begin_procedure_body(p);
 		lb_build_stmt(p, p->body);
 		lb_end_procedure_body(p);
-		p->is_done = true;
+		p->is_done.store(true, std::memory_order_relaxed);
 		m->curr_procedure = nullptr;
 	} else if (p->generate_body != nullptr) {
 		p->generate_body(m, p);
diff --git a/src/llvm_backend.hpp b/src/llvm_backend.hpp
index 559ec8300..cee46701f 100644
--- a/src/llvm_backend.hpp
+++ b/src/llvm_backend.hpp
@@ -366,9 +366,9 @@ struct lbProcedure {
 
 	lbFunctionType *abi_function_type;
 
-	LLVMValueRef    value;
-	LLVMBuilderRef  builder;
-	bool            is_done;
+	LLVMValueRef      value;
+	LLVMBuilderRef    builder;
+	std::atomic<bool> is_done;
 
 	lbAddr           return_ptr;
 	Array<lbDefer>   defer_stmts;
diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index f42087f6b..02f67b1b8 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -3082,9 +3082,12 @@ gb_internal lbValue lb_find_procedure_value_from_entity(lbModule *m, Entity *e)
 		if (found == nullptr) {
 			// THIS IS THE RACE CONDITION
 			lbProcedure *missing_proc_in_other_module = lb_create_procedure(other_module, e, false);
-			mpsc_enqueue(&other_module->missing_procedures_to_check, missing_proc_in_other_module);
+			if (!missing_proc_in_other_module->is_done.load(std::memory_order_relaxed)) {
+				mpsc_enqueue(&other_module->missing_procedures_to_check, missing_proc_in_other_module);
+			}
 		}
 	} else {
+		GB_PANIC("missing procedure: %.*s", LIT(missing_proc->name));
 		mpsc_enqueue(&m->missing_procedures_to_check, missing_proc);
 	}
 
@@ -3157,7 +3160,9 @@ gb_internal lbValue lb_generate_anonymous_proc_lit(lbModule *m, String const &pr
 		rw_mutex_shared_unlock(&target_module->values_mutex);
 		if (found == nullptr) {
 			lbProcedure *missing_proc_in_target_module = lb_create_procedure(target_module, e, false);
-			mpsc_enqueue(&target_module->missing_procedures_to_check, missing_proc_in_target_module);
+			if (!missing_proc_in_target_module->is_done.load(std::memory_order_relaxed)) {
+				mpsc_enqueue(&target_module->missing_procedures_to_check, missing_proc_in_target_module);
+			}
 		}
 
 		lbProcedure *p = lb_create_procedure(m, e, true);
diff --git a/src/llvm_backend_proc.cpp b/src/llvm_backend_proc.cpp
index 3b8a829b7..ee17ef771 100644
--- a/src/llvm_backend_proc.cpp
+++ b/src/llvm_backend_proc.cpp
@@ -99,7 +99,6 @@ gb_internal lbProcedure *lb_create_procedure(lbModule *m, Entity *entity, bool i
 		}
 	}
 
-
 	lbProcedure *p = gb_alloc_item(permanent_allocator(), lbProcedure);
 
 	p->module = m;
-- 
cgit v1.2.3


From c9eef7c835b46ace09e0e149ef52af44f7ff7f36 Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Mon, 22 Sep 2025 21:10:01 +0100
Subject: Single thread `lb_create_startup_runtime_generate_body`

---
 src/llvm_backend.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'src/llvm_backend.cpp')

diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index 1742271b6..d0e9d293d 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -12,7 +12,7 @@
 #endif
 
 #ifndef LLVM_WEAK_MONOMORPHIZATION
-#define LLVM_WEAK_MONOMORPHIZATION 1
+#define LLVM_WEAK_MONOMORPHIZATION (USE_SEPARATE_MODULES && 1)
 #endif
 
 
@@ -2070,11 +2070,10 @@ gb_internal lbProcedure *lb_create_startup_runtime(lbModule *main_module, lbProc
 	LLVMSetVisibility(p->value, LLVMHiddenVisibility);
 	LLVMSetLinkage(p->value, LLVMWeakAnyLinkage);
 
-	p->generate_body    = lb_create_startup_runtime_generate_body;
 	p->global_variables = &global_variables;
 	p->objc_names       = objc_names;
 
-	mpsc_enqueue(&main_module->procedures_to_generate, p);
+	lb_create_startup_runtime_generate_body(main_module, p);
 
 	return p;
 }
-- 
cgit v1.2.3


From 90d1229ead934ae78678dac835dc380db6cfd7ef Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Wed, 24 Sep 2025 09:13:48 +0100
Subject: Make `LLVM_WEAK_MONOMORPHIZATION` opt-in again

---
 src/llvm_backend.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/llvm_backend.cpp')

diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index d0e9d293d..33b03e235 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -12,7 +12,7 @@
 #endif
 
 #ifndef LLVM_WEAK_MONOMORPHIZATION
-#define LLVM_WEAK_MONOMORPHIZATION (USE_SEPARATE_MODULES && 1)
+#define LLVM_WEAK_MONOMORPHIZATION (USE_SEPARATE_MODULES && build_context.internal_weak_monomorphization)
 #endif
 
 
-- 
cgit v1.2.3


From 31f0aaa62f2799d7c5e38c10cabe034284ae8e5d Mon Sep 17 00:00:00 2001
From: gingerBill <gingerBill@users.noreply.github.com>
Date: Wed, 24 Sep 2025 09:55:22 +0100
Subject: Try to improve const `union` LLVM construction

---
 src/llvm_backend.cpp         |  2 +-
 src/llvm_backend_const.cpp   | 94 ++++++++++++++++++++++++++++++++++++++++++++
 src/llvm_backend_expr.cpp    | 15 +++++++
 src/llvm_backend_general.cpp | 78 ++++++++++++++++++++++++++++--------
 4 files changed, 172 insertions(+), 17 deletions(-)

(limited to 'src/llvm_backend.cpp')

diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index 33b03e235..3af473c3a 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -1914,7 +1914,7 @@ gb_internal WORKER_TASK_PROC(lb_llvm_module_verification_worker_proc) {
 	lbModule *m = cast(lbModule *)data;
 
 	if (LLVMVerifyModule(m->mod, LLVMReturnStatusAction, &llvm_error)) {
-		gb_printf_err("LLVM Error:\n%s\n", llvm_error);
+		gb_printf_err("LLVM Error in module %s:\n%s\n", m->module_name, llvm_error);
 		if (build_context.keep_temp_files) {
 			TIME_SECTION("LLVM Print Module to File");
 			String filepath_ll = lb_filepath_ll_for_module(m);
diff --git a/src/llvm_backend_const.cpp b/src/llvm_backend_const.cpp
index 98e50dd78..781cc52b8 100644
--- a/src/llvm_backend_const.cpp
+++ b/src/llvm_backend_const.cpp
@@ -537,6 +537,100 @@ gb_internal bool lb_is_nested_possibly_constant(Type *ft, Selection const &sel,
 	return lb_is_elem_const(elem, ft);
 }
 
+gb_internal LLVMValueRef lb_construct_const_union(lbModule *m, LLVMValueRef variant_value, Type *variant_type, Type *union_type) {
+	Type *bt = base_type(union_type);
+	GB_ASSERT(bt->kind == Type_Union);
+	GB_ASSERT(lb_type(m, variant_type) == LLVMTypeOf(variant_value));
+
+	if (bt->Union.variants.count == 0) {
+		GB_ASSERT(LLVMIsNull(variant_value));
+		return variant_value;
+	}
+
+	LLVMTypeRef llvm_type = lb_type(m, union_type);
+	LLVMTypeRef llvm_variant_type = lb_type(m, variant_type);
+
+	if (is_type_union_maybe_pointer(bt)) {
+		GB_ASSERT(lb_sizeof(LLVMTypeOf(variant_value)) == lb_sizeof(llvm_type));
+		return LLVMConstBitCast(variant_value, llvm_type);
+	}
+
+	if (bt->Union.variants.count == 1) {
+		unsigned long long the_tag = cast(unsigned long long)union_variant_index(union_type, variant_type);
+		LLVMTypeRef tag_type = lb_type(m, union_tag_type(bt));
+
+		LLVMValueRef values[3] = {};
+		unsigned i = 0;
+		values[i++] = variant_value;
+		values[i++] = LLVMConstInt(tag_type, the_tag, false);
+
+		i64 used_size = bt->Union.variant_block_size + lb_sizeof(tag_type);
+		i64 padding = type_size_of(union_type) - used_size;
+		i64 align = type_align_of(union_type);
+		if (padding > 0) {
+			LLVMTypeRef padding_type = lb_type_padding_filler(m, padding, align);
+			values[i++] = LLVMConstNull(padding_type);
+		}
+
+		return LLVMConstNamedStruct(llvm_type, values, i);
+	}
+
+	LLVMTypeRef block_type = LLVMStructGetTypeAtIndex(llvm_type, 0);
+
+	LLVMTypeRef block_padding = nullptr;
+	i64 block_padding_size = bt->Union.variant_block_size - type_size_of(variant_type);
+	if (block_padding_size > 0) {
+		block_padding = lb_type_padding_filler(m, block_padding_size, type_align_of(variant_type));
+		return nullptr;
+	}
+
+	LLVMTypeRef tag_type = lb_type(m, union_tag_type(bt));
+
+	i64 used_size = bt->Union.variant_block_size + lb_sizeof(tag_type);
+	i64 padding = type_size_of(union_type) - used_size;
+	i64 align = type_align_of(union_type);
+	LLVMTypeRef padding_type = nullptr;
+	if (padding > 0) {
+		padding_type = lb_type_padding_filler(m, padding, align);
+	}
+
+
+	unsigned i = 0;
+	LLVMValueRef values[3] = {};
+
+	LLVMValueRef variant_value_wrapped = variant_value;
+
+	if (lb_sizeof(llvm_variant_type) == 0) {
+		variant_value_wrapped = LLVMConstNull(block_type);
+	} else if (block_type != llvm_variant_type) {
+		return nullptr;
+	}
+
+	values[i++] = variant_value_wrapped;
+
+	if (block_padding_size > 0) {
+		values[i++] = LLVMConstNull(block_padding);
+	}
+	unsigned long long the_tag = cast(unsigned long long)union_variant_index(union_type, variant_type);
+	values[i++] = LLVMConstInt(tag_type, the_tag, false);
+	if (padding > 0) {
+		values[i++] = LLVMConstNull(padding_type);
+	}
+	return LLVMConstNamedStruct(llvm_type, values, i);
+}
+
+gb_internal bool lb_try_construct_const_union(lbModule *m, lbValue *value, Type *variant_type, Type *union_type) {
+	if (lb_is_const(*value)) {
+		LLVMValueRef res = lb_construct_const_union(m, value->value, variant_type, union_type);
+		if (res != nullptr) {
+			*value = {res, union_type};
+			return true;
+		}
+	}
+	return false;
+}
+
+
 gb_internal lbValue lb_const_value(lbModule *m, Type *type, ExactValue value, lbConstContext cc) {
 	if (cc.allow_local) {
 		cc.is_rodata = false;
diff --git a/src/llvm_backend_expr.cpp b/src/llvm_backend_expr.cpp
index cff91813e..4a1f39c19 100644
--- a/src/llvm_backend_expr.cpp
+++ b/src/llvm_backend_expr.cpp
@@ -2495,6 +2495,11 @@ gb_internal lbValue lb_emit_conv(lbProcedure *p, lbValue value, Type *t) {
 			Type *vt = dst->Union.variants[0];
 			if (internal_check_is_assignable_to(src_type, vt)) {
 				value = lb_emit_conv(p, value, vt);
+				if (lb_is_const(value)) {
+					LLVMValueRef res = lb_construct_const_union(m, value.value, vt, t);
+					return {res, t};
+				}
+
 				lbAddr parent = lb_add_local_generated(p, t, true);
 				lb_emit_store_union_variant(p, parent.addr, value, vt);
 				return lb_addr_load(p, parent);
@@ -2503,11 +2508,18 @@ gb_internal lbValue lb_emit_conv(lbProcedure *p, lbValue value, Type *t) {
 		for (Type *vt : dst->Union.variants) {
 			if (src_type == t_llvm_bool && is_type_boolean(vt)) {
 				value = lb_emit_conv(p, value, vt);
+				if (lb_try_construct_const_union(m, &value, vt, t)) {
+					return value;
+				}
+
 				lbAddr parent = lb_add_local_generated(p, t, true);
 				lb_emit_store_union_variant(p, parent.addr, value, vt);
 				return lb_addr_load(p, parent);
 			}
 			if (are_types_identical(src_type, vt)) {
+				if (lb_try_construct_const_union(m, &value, vt, t)) {
+					return value;
+				}
 				lbAddr parent = lb_add_local_generated(p, t, true);
 				lb_emit_store_union_variant(p, parent.addr, value, vt);
 				return lb_addr_load(p, parent);
@@ -2545,6 +2557,9 @@ gb_internal lbValue lb_emit_conv(lbProcedure *p, lbValue value, Type *t) {
 		if (valid_count == 1) {
 			Type *vt = dst->Union.variants[first_success_index];
 			value = lb_emit_conv(p, value, vt);
+			if (lb_try_construct_const_union(m, &value, vt, t)) {
+					return value;
+				}
 			lbAddr parent = lb_add_local_generated(p, t, true);
 			lb_emit_store_union_variant(p, parent.addr, value, vt);
 			return lb_addr_load(p, parent);
diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index 3fa7a076e..fc770102c 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -1719,8 +1719,69 @@ gb_internal LLVMTypeRef lb_type_internal_for_procedures_raw(lbModule *m, Type *t
 	map_set(&m->func_raw_types, type, new_abi_fn_type);
 
 	return new_abi_fn_type;
+}
+
+
+gb_internal LLVMTypeRef lb_type_internal_union_block_type(lbModule *m, Type *type) {
+	GB_ASSERT(type->kind == Type_Union);
+
+	if (type->Union.variants.count <= 0) {
+		return nullptr;
+	}
+	if (type->Union.variants.count == 1) {
+		return lb_type(m, type->Union.variants[0]);
+	}
+
+	i64 align = type_align_of(type);
+	i64 size = type_size_of(type);
+	gb_unused(size);
 
+	unsigned block_size = cast(unsigned)type->Union.variant_block_size;
+
+	bool all_pointers = align == build_context.ptr_size;
+	for (isize i = 0; all_pointers && i < type->Union.variants.count; i++) {
+		Type *t = type->Union.variants[i];
+		if (!is_type_internally_pointer_like(t)) {
+			all_pointers = false;
+		}
+	}
+	if (all_pointers) {
+		return lb_type(m, t_rawptr);
+	}
+
+	{
+		Type *pt = type->Union.variants[0];
+		for (isize i = 1; i < type->Union.variants.count; i++) {
+			Type *t = type->Union.variants[i];
+			if (!are_types_identical(pt, t)) {
+				goto end_check_for_all_the_same;
+			}
+		}
+		return lb_type(m, pt);
+	} end_check_for_all_the_same:;
+
+	{
+		Type *first_different = nullptr;
+		for (isize i = 0; i < type->Union.variants.count; i++) {
+			Type *t = type->Union.variants[i];
+			if (type_size_of(t) == 0) {
+				continue;
+			}
+			if (first_different == nullptr) {
+				first_different = t;
+			} else if (!are_types_identical(first_different, t)) {
+				goto end_rest_zero_except_one;
+			}
+		}
+		if (first_different != nullptr) {
+			return lb_type(m, first_different);
+		}
+	} end_rest_zero_except_one:;
+
+	return lb_type_padding_filler(m, block_size, align);
 }
+
+
 gb_internal LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
 	LLVMContextRef ctx = m->ctx;
 	i64 size = type_size_of(type); // Check size
@@ -2233,8 +2294,6 @@ gb_internal LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
 				return LLVMStructTypeInContext(ctx, fields, gb_count_of(fields), false);
 			}
 
-			unsigned block_size = cast(unsigned)type->Union.variant_block_size;
-
 			auto fields = array_make<LLVMTypeRef>(temporary_allocator(), 0, 3);
 			if (is_type_union_maybe_pointer(type)) {
 				LLVMTypeRef variant = lb_type(m, type->Union.variants[0]);
@@ -2252,20 +2311,7 @@ gb_internal LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
 					array_add(&fields, padding_type);
 				}
 			} else {
-				LLVMTypeRef block_type = nullptr;
-
-				bool all_pointers = align == build_context.ptr_size;
-				for (isize i = 0; all_pointers && i < type->Union.variants.count; i++) {
-					Type *t = type->Union.variants[i];
-					if (!is_type_internally_pointer_like(t)) {
-						all_pointers = false;
-					}
-				}
-				if (all_pointers) {
-					block_type = lb_type(m, t_rawptr);
-				} else {
-					block_type = lb_type_padding_filler(m, block_size, align);
-				}
+				LLVMTypeRef block_type = lb_type_internal_union_block_type(m, type);
 
 				LLVMTypeRef tag_type = lb_type(m, union_tag_type(type));
 				array_add(&fields, block_type);
-- 
cgit v1.2.3