From b190404b217f59b9bed65bdf588a4e0369f60a95 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 26 Jan 2022 16:37:16 +0000
Subject: Fix double map dereference indexing

---
 src/llvm_backend_general.cpp | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'src/llvm_backend_general.cpp')

diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index 17eeb0bea..998dce88f 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -271,6 +271,10 @@ lbAddr lb_addr(lbValue addr) {
 
 
 lbAddr lb_addr_map(lbValue addr, lbValue map_key, Type *map_type, Type *map_result) {
+	GB_ASSERT(is_type_pointer(addr.type));
+	Type *mt = type_deref(addr.type);
+	GB_ASSERT(is_type_map(mt));
+
 	lbAddr v = {lbAddr_Map, addr};
 	v.map.key    = map_key;
 	v.map.type   = map_type;
-- 
cgit v1.2.3


From 498f68c06b64b9e5bd6a8bd2aef2fb71ecabe5fc Mon Sep 17 00:00:00 2001
From: CiD- <jkercher43@gmail.com>
Date: Wed, 26 Jan 2022 14:37:15 -0500
Subject: avoid segfault on map resize

---
 src/llvm_backend_general.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'src/llvm_backend_general.cpp')

diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index 998dce88f..2fc21b534 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -1602,8 +1602,9 @@ LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
 						return llvm_type;
 					}
 					llvm_type = LLVMStructCreateNamed(ctx, name);
+					LLVMTypeRef found_val = *found;
 					map_set(&m->types, type, llvm_type);
-					lb_clone_struct_type(llvm_type, *found);
+					lb_clone_struct_type(llvm_type, found_val);
 					return llvm_type;
 				}
 			}
-- 
cgit v1.2.3


From 0cc40db565a9c4b99e6fa0844b9ac512558626e4 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Tue, 8 Feb 2022 17:04:55 +0000
Subject: Begin work on support objc intrinsics

---
 src/check_builtin.cpp         | 223 +++++++++++++++++++++++++++++++++++++++++-
 src/check_decl.cpp            |   3 +
 src/checker.cpp               |  36 +++++++
 src/checker.hpp               |  15 ++-
 src/checker_builtin_procs.hpp |   6 ++
 src/entity.cpp                |   1 +
 src/llvm_backend.cpp          |  59 ++++++++++-
 src/llvm_backend.hpp          |   6 +-
 src/llvm_backend_general.cpp  |   8 +-
 src/llvm_backend_proc.cpp     |   3 +
 src/llvm_backend_utility.cpp  |  96 ++++++++++++++++++
 src/types.cpp                 |  10 ++
 12 files changed, 459 insertions(+), 7 deletions(-)

(limited to 'src/llvm_backend_general.cpp')

diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp
index 1fb3d6037..8ada77b12 100644
--- a/src/check_builtin.cpp
+++ b/src/check_builtin.cpp
@@ -143,6 +143,219 @@ void check_or_return_split_types(CheckerContext *c, Operand *x, String const &na
 }
 
 
+bool does_require_msgSend_stret(Type *return_type) {
+	if (return_type == nullptr) {
+		return false;
+	}
+	if (build_context.metrics.arch == TargetArch_i386 || build_context.metrics.arch == TargetArch_amd64) {
+		i64 struct_limit = type_size_of(t_uintptr) << 1;
+		return type_size_of(return_type) > struct_limit;
+	}
+	if (build_context.metrics.arch == TargetArch_arm64) {
+		return false;
+	}
+
+	// if (build_context.metrics.arch == TargetArch_arm32) {
+	// 	i64 struct_limit = type_size_of(t_uintptr);
+	// 	// NOTE(bill): This is technically wrong
+	// 	return is_type_struct(return_type) && !is_type_raw_union(return_type) && type_size_of(return_type) > struct_limit;
+	// }
+	GB_PANIC("unsupported architecture");
+	return false;
+}
+
+ObjcMsgKind get_objc_proc_kind(Type *return_type) {
+	if (return_type == nullptr) {
+		return ObjcMsg_normal;
+	}
+
+	if (build_context.metrics.arch == TargetArch_i386 || build_context.metrics.arch == TargetArch_amd64) {
+		if (is_type_float(return_type)) {
+			return ObjcMsg_fpret;
+		}
+		if (build_context.metrics.arch == TargetArch_amd64) {
+			if (is_type_complex(return_type)) {
+				// URL: https://github.com/opensource-apple/objc4/blob/cd5e62a5597ea7a31dccef089317abb3a661c154/runtime/message.h#L143-L159
+				return ObjcMsg_fpret;
+			}
+		}
+	}
+	if (build_context.metrics.arch != TargetArch_arm64) {
+		if (does_require_msgSend_stret(return_type)) {
+			return ObjcMsg_stret;
+		}
+	}
+	return ObjcMsg_normal;
+}
+
+void add_objc_proc_type(CheckerContext *c, Ast *call, Type *return_type, Slice<Type *> param_types) {
+	ObjcMsgKind kind = get_objc_proc_kind(return_type);
+
+	Scope *scope = create_scope(c->info, nullptr);
+
+	// NOTE(bill, 2022-02-08): the backend's ABI handling should handle this correctly, I hope
+	Type *params = alloc_type_tuple();
+	{
+		auto variables = array_make<Entity *>(permanent_allocator(), 0, param_types.count);
+
+		for_array(i, param_types)  {
+			Type *type = param_types[i];
+			Entity *param = alloc_entity_param(scope, blank_token, type, false, true);
+			array_add(&variables, param);
+		}
+		params->Tuple.variables = slice_from_array(variables);
+	}
+
+	Type *results = alloc_type_tuple();
+	if (return_type) {
+		auto variables = array_make<Entity *>(permanent_allocator(), 1);
+		results->Tuple.variables = slice_from_array(variables);
+		Entity *param = alloc_entity_param(scope, blank_token, return_type, false, true);
+		results->Tuple.variables[0] = param;
+	}
+
+
+	ObjcMsgData data = {};
+	data.kind = kind;
+	data.proc_type = alloc_type_proc(scope, params, param_types.count, results, results->Tuple.variables.count, false, ProcCC_CDecl);
+
+	mutex_lock(&c->info->objc_types_mutex);
+	map_set(&c->info->objc_msgSend_types, call, data);
+	mutex_unlock(&c->info->objc_types_mutex);
+
+	add_package_dependency(c, "runtime", "objc_lookUpClass");
+	add_package_dependency(c, "runtime", "sel_registerName");
+
+	add_package_dependency(c, "runtime", "objc_msgSend");
+	add_package_dependency(c, "runtime", "objc_msgSend_fpret");
+	add_package_dependency(c, "runtime", "objc_msgSend_fp2ret");
+	add_package_dependency(c, "runtime", "objc_msgSend_stret");
+}
+
+bool check_builtin_objc_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 id, Type *type_hint) {
+	auto const is_constant_string = [](CheckerContext *c, String const &builtin_name, Ast *expr, String *name_) -> bool {
+		Operand op = {};
+		check_expr(c, &op, expr);
+		if (op.mode == Addressing_Constant && op.value.kind == ExactValue_String) {
+			if (name_) *name_ = op.value.value_string;
+			return true;
+		}
+		gbString e = expr_to_string(op.expr);
+		gbString t = type_to_string(op.type);
+		error(op.expr, "'%.*s' expected a constant string value, got %s of type %s", LIT(builtin_name), e, t);
+		gb_string_free(t);
+		gb_string_free(e);
+		return false;
+	};
+	String builtin_name = builtin_procs[id].name;
+
+	if (build_context.metrics.os != TargetOs_darwin) {
+		error(call, "'%.*s' only works on darwin", LIT(builtin_name));
+		return false;
+	}
+
+
+	ast_node(ce, CallExpr, call);
+	switch (id) {
+	default:
+		GB_PANIC("Implement objective built-in procedure: %.*s", LIT(builtin_name));
+		return false;
+
+	case BuiltinProc_objc_send: {
+		Type *return_type = nullptr;
+
+		Operand rt = {};
+		check_expr_or_type(c, &rt, ce->args[0]);
+		if (rt.mode == Addressing_Type) {
+			return_type = rt.type;
+		} else if (is_operand_nil(rt)) {
+			return_type = nullptr;
+		} else {
+			gbString e = expr_to_string(rt.expr);
+			error(rt.expr, "'%.*s' expected a type or nil to define the return type of the Objective-C call, got %s", LIT(builtin_name), e);
+			gb_string_free(e);
+			return false;
+		}
+
+		operand->type = return_type;
+		operand->mode = return_type ? Addressing_Value : Addressing_NoValue;
+
+		String class_name = {};
+		String sel_name = {};
+
+		Type *sel_type = t_objc_SEL;
+		Operand self = {};
+		check_expr_or_type(c, &self, ce->args[1]);
+		if (self.mode == Addressing_Type) {
+			if (!internal_check_is_assignable_to(self.type, t_objc_object)) {
+				gbString t = type_to_string(self.type);
+				error(self.expr, "'%.*s' expected a type or value derived from intrinsics.objc_object, got type %s", LIT(builtin_name), t);
+				gb_string_free(t);
+				return false;
+			}
+			if (!(self.type->kind == Type_Named &&
+			      self.type->Named.type_name != nullptr &&
+			      self.type->Named.type_name->TypeName.objc_class_name != "")) {
+				gbString t = type_to_string(self.type);
+				error(self.expr, "'%.*s' expected a named type with the attribute @(obj_class=<string>) , got type %s", LIT(builtin_name), t);
+				gb_string_free(t);
+				return false;
+			}
+
+			sel_type = t_objc_Class;
+		} else if (!is_operand_value(self) || !check_is_assignable_to(c, &self, t_objc_id)) {
+			gbString e = expr_to_string(self.expr);
+			gbString t = type_to_string(self.type);
+			error(self.expr, "'%.*s'3 expected a type or value derived from intrinsics.objc_object, got '%s' of type %s %d", LIT(builtin_name), e, t, self.type->kind);
+			gb_string_free(t);
+			gb_string_free(e);
+			return false;
+		} else if (!is_type_pointer(self.type)) {
+			gbString e = expr_to_string(self.expr);
+			gbString t = type_to_string(self.type);
+			error(self.expr, "'%.*s' expected a pointer of a value derived from intrinsics.objc_object, got '%s' of type %s", LIT(builtin_name), e, t);
+			gb_string_free(t);
+			gb_string_free(e);
+			return false;
+		} else {
+			Type *type = type_deref(self.type);
+			if (!(type->kind == Type_Named &&
+			      type->Named.type_name != nullptr &&
+			      type->Named.type_name->TypeName.objc_class_name != "")) {
+				gbString t = type_to_string(type);
+				error(self.expr, "'%.*s' expected a named type with the attribute @(obj_class=<string>) , got type %s", LIT(builtin_name), t);
+				gb_string_free(t);
+				return false;
+			}
+		}
+
+
+		if (!is_constant_string(c, builtin_name, ce->args[2], &sel_name)) {
+			return false;
+		}
+
+		isize const arg_offset = 1;
+		auto param_types = slice_make<Type *>(permanent_allocator(), ce->args.count-arg_offset);
+		param_types[0] = t_objc_id;
+		param_types[1] = sel_type;
+
+		for (isize i = 2+arg_offset; i < ce->args.count; i++) {
+			Operand x = {};
+			check_expr(c, &x, ce->args[i]);
+			param_types[i-arg_offset] = x.type;
+		}
+
+		add_objc_proc_type(c, call, return_type, param_types);
+
+		return true;
+	} break;
+
+	case BuiltinProc_objc_create: {
+		GB_PANIC("TODO: BuiltinProc_objc_create");
+		return false;
+	} break;
+	}
+}
 
 bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 id, Type *type_hint) {
 	ast_node(ce, CallExpr, call);
@@ -179,6 +392,8 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32
 	case BuiltinProc_len:
 	case BuiltinProc_min:
 	case BuiltinProc_max:
+	case BuiltinProc_objc_send:
+	case BuiltinProc_objc_create:
 		// NOTE(bill): The first arg may be a Type, this will be checked case by case
 		break;
 
@@ -202,7 +417,7 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32
 		break;
 	}
 
-	String builtin_name = builtin_procs[id].name;;
+	String builtin_name = builtin_procs[id].name;
 
 
 	if (ce->args.count > 0) {
@@ -219,6 +434,10 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32
 		GB_PANIC("Implement built-in procedure: %.*s", LIT(builtin_name));
 		break;
 
+	case BuiltinProc_objc_send:
+	case BuiltinProc_objc_create:
+		return check_builtin_objc_procedure(c, operand, call, id, type_hint);
+
 	case BuiltinProc___entry_point:
 		operand->mode = Addressing_NoValue;
 		operand->type = nullptr;
@@ -3815,6 +4034,8 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32
 			operand->type = t_hasher_proc;
 			break;
 		}
+
+
 	}
 
 	return true;
diff --git a/src/check_decl.cpp b/src/check_decl.cpp
index f6dade812..243dbbbc6 100644
--- a/src/check_decl.cpp
+++ b/src/check_decl.cpp
@@ -338,6 +338,9 @@ void check_type_decl(CheckerContext *ctx, Entity *e, Ast *init_expr, Type *def)
 	if (decl != nullptr) {
 		AttributeContext ac = {};
 		check_decl_attributes(ctx, decl->attributes, type_decl_attribute, &ac);
+		if (e->kind == Entity_TypeName && ac.objc_class != "") {
+			e->TypeName.objc_class_name = ac.objc_class;
+		}
 	}
 
 
diff --git a/src/checker.cpp b/src/checker.cpp
index 7fb4fdb29..2ab487592 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -841,6 +841,17 @@ void add_global_enum_constant(Slice<Entity *> const &fields, char const *name, i
 	GB_PANIC("Unfound enum value for global constant: %s %lld", name, cast(long long)value);
 }
 
+Type *add_global_type_name(Scope *scope, String const &type_name, Type *backing_type) {
+	Entity *e = alloc_entity_type_name(scope, make_token_ident(type_name), nullptr, EntityState_Resolved);
+	Type *named_type = alloc_type_named(type_name, backing_type, e);
+	e->type = named_type;
+	set_base_type(named_type, backing_type);
+	if (scope_insert(scope, e)) {
+		compiler_error("double declaration of %.*s", LIT(e->token.string));
+	}
+	return named_type;
+}
+
 
 void init_universal(void) {
 	BuildContext *bc = &build_context;
@@ -985,6 +996,17 @@ void init_universal(void) {
 	t_f64_ptr      = alloc_type_pointer(t_f64);
 	t_u8_slice     = alloc_type_slice(t_u8);
 	t_string_slice = alloc_type_slice(t_string);
+
+	// intrinsics types for objective-c stuff
+	{
+		t_objc_object   = add_global_type_name(intrinsics_pkg->scope, str_lit("objc_object"),   alloc_type_struct());
+		t_objc_selector = add_global_type_name(intrinsics_pkg->scope, str_lit("objc_selector"), alloc_type_struct());
+		t_objc_class    = add_global_type_name(intrinsics_pkg->scope, str_lit("objc_class"),    alloc_type_struct());
+
+		t_objc_id       = alloc_type_pointer(t_objc_object);
+		t_objc_SEL      = alloc_type_pointer(t_objc_selector);
+		t_objc_Class    = alloc_type_pointer(t_objc_class);
+	}
 }
 
 
@@ -1041,6 +1063,9 @@ void init_checker_info(CheckerInfo *i) {
 	semaphore_init(&i->collect_semaphore);
 
 	mpmc_init(&i->intrinsics_entry_point_usage, a, 1<<10); // just waste some memory here, even if it probably never used
+
+	mutex_init(&i->objc_types_mutex);
+	map_init(&i->objc_msgSend_types, a);
 }
 
 void destroy_checker_info(CheckerInfo *i) {
@@ -1073,6 +1098,9 @@ void destroy_checker_info(CheckerInfo *i) {
 	mutex_destroy(&i->type_and_value_mutex);
 	mutex_destroy(&i->identifier_uses_mutex);
 	mutex_destroy(&i->foreign_mutex);
+
+	mutex_destroy(&i->objc_types_mutex);
+	map_destroy(&i->objc_msgSend_types);
 }
 
 CheckerContext make_checker_context(Checker *c) {
@@ -3161,6 +3189,14 @@ DECL_ATTRIBUTE_PROC(type_decl_attribute) {
 	} else if (name == "private") {
 		// NOTE(bill): Handled elsewhere `check_collect_value_decl`
 		return true;
+	} else if (name == "objc_class") {
+		ExactValue ev = check_decl_attribute_value(c, value);
+		if (ev.kind != ExactValue_String || ev.value_string == "") {
+			error(elem, "Expected a non-empty string value for '%.*s'", LIT(name));
+		} else {
+			ac->objc_class = ev.value_string;
+		}
+		return true;
 	}
 	return false;
 }
diff --git a/src/checker.hpp b/src/checker.hpp
index 9a8753efd..b812e10a4 100644
--- a/src/checker.hpp
+++ b/src/checker.hpp
@@ -107,6 +107,7 @@ struct AttributeContext {
 	String  thread_local_model;
 	String  deprecated_message;
 	String  warning_message;
+	String  objc_class;
 	DeferredProcedure deferred_procedure;
 	bool    is_export           : 1;
 	bool    is_static           : 1;
@@ -267,6 +268,17 @@ struct UntypedExprInfo {
 typedef PtrMap<Ast *, ExprInfo *> UntypedExprInfoMap; 
 typedef MPMCQueue<ProcInfo *> ProcBodyQueue;
 
+enum ObjcMsgKind : u32 {
+	ObjcMsg_normal,
+	ObjcMsg_fpret,
+	ObjcMsg_fp2ret,
+	ObjcMsg_stret,
+};
+struct ObjcMsgData {
+	ObjcMsgKind kind;
+	Type *proc_type;
+};
+
 // CheckerInfo stores all the symbol information for a type-checked program
 struct CheckerInfo {
 	Checker *checker;
@@ -340,7 +352,8 @@ struct CheckerInfo {
 
 	MPMCQueue<Ast *> intrinsics_entry_point_usage;
 
-
+	BlockingMutex objc_types_mutex;
+	PtrMap<Ast *, ObjcMsgData> objc_msgSend_types;
 };
 
 struct CheckerContext {
diff --git a/src/checker_builtin_procs.hpp b/src/checker_builtin_procs.hpp
index d833a055f..1a9d7d7a0 100644
--- a/src/checker_builtin_procs.hpp
+++ b/src/checker_builtin_procs.hpp
@@ -250,6 +250,9 @@ BuiltinProc__type_end,
 
 	BuiltinProc___entry_point,
 
+	BuiltinProc_objc_send,
+	BuiltinProc_objc_create,
+
 	BuiltinProc_COUNT,
 };
 gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = {
@@ -500,4 +503,7 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = {
 	{STR_LIT(""), 0, false, Expr_Stmt, BuiltinProcPkg_intrinsics},
 
 	{STR_LIT("__entry_point"), 0, false, Expr_Stmt, BuiltinProcPkg_intrinsics},
+
+	{STR_LIT("objc_send"),   3, true,  Expr_Expr, BuiltinProcPkg_intrinsics},
+	{STR_LIT("objc_create"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 };
diff --git a/src/entity.cpp b/src/entity.cpp
index 8327a517e..4d5b3b9e1 100644
--- a/src/entity.cpp
+++ b/src/entity.cpp
@@ -186,6 +186,7 @@ struct Entity {
 			Type * type_parameter_specialization;
 			String ir_mangled_name;
 			bool   is_type_alias;
+			String objc_class_name;
 		} TypeName;
 		struct {
 			u64     tags;
diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index 304effb7f..7941c65a3 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -652,7 +652,53 @@ lbProcedure *lb_create_startup_type_info(lbModule *m) {
 	return p;
 }
 
-lbProcedure *lb_create_startup_runtime(lbModule *main_module, lbProcedure *startup_type_info, Array<lbGlobalVariable> &global_variables) { // Startup Runtime
+lbProcedure *lb_create_objc_names(lbModule *main_module) {
+	if (build_context.metrics.os != TargetOs_darwin) {
+		return nullptr;
+	}
+	Type *proc_type = alloc_type_proc(nullptr, nullptr, 0, nullptr, 0, false, ProcCC_CDecl);
+	lbProcedure *p = lb_create_dummy_procedure(main_module, str_lit("__$init_objc_names"), proc_type);
+	p->is_startup = true;
+	return p;
+}
+
+void lb_finalize_objc_names(lbProcedure *p) {
+	if (p == nullptr) {
+		return;
+	}
+	lbModule *m = p->module;
+
+	LLVMPassManagerRef default_function_pass_manager = LLVMCreateFunctionPassManagerForModule(m->mod);
+	lb_populate_function_pass_manager(m, default_function_pass_manager, false, build_context.optimization_level);
+	LLVMFinalizeFunctionPassManager(default_function_pass_manager);
+
+	LLVMSetLinkage(p->value, LLVMInternalLinkage);
+	lb_begin_procedure_body(p);
+	for_array(i, m->objc_classes.entries) {
+		auto const &entry = m->objc_classes.entries[i];
+		String name = entry.key.string;
+		auto args = array_make<lbValue>(permanent_allocator(), 1);
+		args[0] = lb_const_value(m, t_cstring, exact_value_string(name));
+		lbValue ptr = lb_emit_runtime_call(p, "objc_lookUpClass", args);
+		lb_addr_store(p, entry.value, ptr);
+	}
+
+	for_array(i, m->objc_selectors.entries) {
+		auto const &entry = m->objc_selectors.entries[i];
+		String name = entry.key.string;
+		auto args = array_make<lbValue>(permanent_allocator(), 1);
+		args[0] = lb_const_value(m, t_cstring, exact_value_string(name));
+		lbValue ptr = lb_emit_runtime_call(p, "sel_registerName", args);
+		lb_addr_store(p, entry.value, ptr);
+	}
+
+	lb_end_procedure_body(p);
+
+	lb_run_function_pass_manager(default_function_pass_manager, p);
+
+}
+
+lbProcedure *lb_create_startup_runtime(lbModule *main_module, lbProcedure *startup_type_info, lbProcedure *objc_names, Array<lbGlobalVariable> &global_variables) { // Startup Runtime
 	LLVMPassManagerRef default_function_pass_manager = LLVMCreateFunctionPassManagerForModule(main_module->mod);
 	lb_populate_function_pass_manager(main_module, default_function_pass_manager, false, build_context.optimization_level);
 	LLVMFinalizeFunctionPassManager(default_function_pass_manager);
@@ -666,6 +712,10 @@ lbProcedure *lb_create_startup_runtime(lbModule *main_module, lbProcedure *start
 
 	LLVMBuildCall2(p->builder, LLVMGetElementType(lb_type(main_module, startup_type_info->type)), startup_type_info->value, nullptr, 0, "");
 
+	if (objc_names) {
+		LLVMBuildCall2(p->builder, LLVMGetElementType(lb_type(main_module, objc_names->type)), objc_names->value, nullptr, 0, "");
+	}
+
 	for_array(i, global_variables) {
 		auto *var = &global_variables[i];
 		if (var->is_initialized) {
@@ -1570,8 +1620,10 @@ void lb_generate_code(lbGenerator *gen) {
 	TIME_SECTION("LLVM Runtime Type Information Creation");
 	lbProcedure *startup_type_info = lb_create_startup_type_info(default_module);
 
+	lbProcedure *objc_names = lb_create_objc_names(default_module);
+
 	TIME_SECTION("LLVM Runtime Startup Creation (Global Variables)");
-	lbProcedure *startup_runtime = lb_create_startup_runtime(default_module, startup_type_info, global_variables);
+	lbProcedure *startup_runtime = lb_create_startup_runtime(default_module, startup_type_info, objc_names, global_variables);
 	gb_unused(startup_runtime);
 
 	TIME_SECTION("LLVM Global Procedures and Types");
@@ -1650,6 +1702,8 @@ void lb_generate_code(lbGenerator *gen) {
 		}
 	}
 
+	lb_finalize_objc_names(objc_names);
+
 	if (build_context.ODIN_DEBUG) {
 		TIME_SECTION("LLVM Debug Info Complete Types and Finalize");
 		for_array(j, gen->modules.entries) {
@@ -1662,6 +1716,7 @@ void lb_generate_code(lbGenerator *gen) {
 	}
 
 
+
 	TIME_SECTION("LLVM Function Pass");
 	for_array(i, gen->modules.entries) {
 		lbModule *m = gen->modules.entries[i].value;
diff --git a/src/llvm_backend.hpp b/src/llvm_backend.hpp
index d7093bc63..087cda22a 100644
--- a/src/llvm_backend.hpp
+++ b/src/llvm_backend.hpp
@@ -144,6 +144,9 @@ struct lbModule {
 	PtrMap<void *, LLVMMetadataRef> debug_values; 
 
 	Array<lbIncompleteDebugType> debug_incomplete_types;
+
+	StringMap<lbAddr> objc_classes;
+	StringMap<lbAddr> objc_selectors;
 };
 
 struct lbGenerator {
@@ -293,7 +296,6 @@ struct lbProcedure {
 
 
 bool lb_init_generator(lbGenerator *gen, Checker *c);
-void lb_generate_module(lbGenerator *gen);
 
 String lb_mangle_name(lbModule *m, Entity *e);
 String lb_get_entity_name(lbModule *m, Entity *e, String name = {});
@@ -366,7 +368,7 @@ lbContextData *lb_push_context_onto_stack(lbProcedure *p, lbAddr ctx);
 lbContextData *lb_push_context_onto_stack_from_implicit_parameter(lbProcedure *p);
 
 
-lbAddr lb_add_global_generated(lbModule *m, Type *type, lbValue value={});
+lbAddr lb_add_global_generated(lbModule *m, Type *type, lbValue value={}, Entity **entity_=nullptr);
 lbAddr lb_add_local(lbProcedure *p, Type *type, Entity *e=nullptr, bool zero_init=true, i32 param_index=0, bool force_no_init=false);
 
 void lb_add_foreign_library_path(lbModule *m, Entity *e);
diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index 2fc21b534..1c98aa77f 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -72,6 +72,9 @@ void lb_init_module(lbModule *m, Checker *c) {
 
 	map_init(&m->debug_values, a);
 	array_init(&m->debug_incomplete_types, a, 0, 1024);
+
+	string_map_init(&m->objc_classes, a);
+	string_map_init(&m->objc_selectors, a);
 }
 
 bool lb_init_generator(lbGenerator *gen, Checker *c) {
@@ -2450,7 +2453,7 @@ lbValue lb_find_procedure_value_from_entity(lbModule *m, Entity *e) {
 	return {};
 }
 
-lbAddr lb_add_global_generated(lbModule *m, Type *type, lbValue value) {
+lbAddr lb_add_global_generated(lbModule *m, Type *type, lbValue value, Entity **entity_) {
 	GB_ASSERT(type != nullptr);
 	type = default_type(type);
 
@@ -2476,6 +2479,9 @@ lbAddr lb_add_global_generated(lbModule *m, Type *type, lbValue value) {
 
 	lb_add_entity(m, e, g);
 	lb_add_member(m, name, g);
+
+	if (entity_) *entity_ = e;
+
 	return lb_addr(g);
 }
 
diff --git a/src/llvm_backend_proc.cpp b/src/llvm_backend_proc.cpp
index 7a6fac603..6de0aaed7 100644
--- a/src/llvm_backend_proc.cpp
+++ b/src/llvm_backend_proc.cpp
@@ -2106,6 +2106,9 @@ lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValue const &tv,
 			res.type = t_uintptr;
 			return res;
 		}
+
+	case BuiltinProc_objc_send:
+		return lb_handle_obj_send(p, expr);
 	}
 
 	GB_PANIC("Unhandled built-in procedure %.*s", LIT(builtin_procs[id].name));
diff --git a/src/llvm_backend_utility.cpp b/src/llvm_backend_utility.cpp
index 7e2bd7daa..d92f711ba 100644
--- a/src/llvm_backend_utility.cpp
+++ b/src/llvm_backend_utility.cpp
@@ -1819,3 +1819,99 @@ void lb_set_wasm_export_attributes(LLVMValueRef value, String export_name) {
 	LLVMSetVisibility(value, LLVMDefaultVisibility);
 	LLVMAddTargetDependentFunctionAttr(value, "wasm-export-name",   alloc_cstring(permanent_allocator(), export_name));
 }
+
+
+lbValue lb_lookup_runtime_procedure(lbModule *m, String const &name);
+
+lbValue lb_handle_obj_id(lbProcedure *p, Ast *expr) {
+	TypeAndValue const &tav = type_and_value_of_expr(expr);
+	if (tav.mode == Addressing_Type) {
+		Type *type = tav.type;
+		GB_ASSERT_MSG(type->kind == Type_Named, "%s", type_to_string(type));
+		Entity *e = type->Named.type_name;
+		GB_ASSERT(e->kind == Entity_TypeName);
+		String name = e->TypeName.objc_class_name;
+
+		lbAddr *found = string_map_get(&p->module->objc_classes, name);
+		if (found) {
+			return lb_addr_load(p, *found);
+		} else {
+			lbModule *default_module = &p->module->gen->default_module;
+			Entity *e = nullptr;
+			lbAddr default_addr = lb_add_global_generated(default_module, t_objc_Class, {}, &e);
+
+			lbValue ptr = lb_find_value_from_entity(p->module, e);
+			lbAddr local_addr = lb_addr(ptr);
+
+			string_map_set(&default_module->objc_classes, name, default_addr);
+			if (default_module != p->module) {
+				string_map_set(&p->module->objc_classes, name, local_addr);
+			}
+			return lb_addr_load(p, local_addr);
+		}
+	}
+
+	return lb_build_expr(p, expr);
+}
+
+
+lbValue lb_handle_obj_selector(lbProcedure *p, String const &name) {
+	lbAddr *found = string_map_get(&p->module->objc_selectors, name);
+	if (found) {
+		return lb_addr_load(p, *found);
+	} else {
+		lbModule *default_module = &p->module->gen->default_module;
+		Entity *e = nullptr;
+		lbAddr default_addr = lb_add_global_generated(default_module, t_objc_SEL, {}, &e);
+
+		lbValue ptr = lb_find_value_from_entity(p->module, e);
+		lbAddr local_addr = lb_addr(ptr);
+
+		string_map_set(&default_module->objc_selectors, name, default_addr);
+		if (default_module != p->module) {
+			string_map_set(&p->module->objc_selectors, name, local_addr);
+		}
+		return lb_addr_load(p, local_addr);
+	}
+}
+
+
+lbValue lb_handle_obj_send(lbProcedure *p, Ast *expr) {
+	ast_node(ce, CallExpr, expr);
+
+	lbModule *m = p->module;
+	CheckerInfo *info = m->info;
+	ObjcMsgData data = map_must_get(&info->objc_msgSend_types, expr);
+	GB_ASSERT(data.proc_type != nullptr);
+
+	GB_ASSERT(ce->args.count >= 3);
+	auto args = array_make<lbValue>(permanent_allocator(), 0, ce->args.count-1);
+
+	lbValue id = lb_handle_obj_id(p, ce->args[1]);
+	Ast *sel_expr = ce->args[2];
+	GB_ASSERT(sel_expr->tav.value.kind == ExactValue_String);
+	lbValue sel = lb_handle_obj_selector(p, sel_expr->tav.value.value_string);
+
+	array_add(&args, id);
+	array_add(&args, sel);
+	for (isize i = 3; i < ce->args.count; i++) {
+		lbValue arg = lb_build_expr(p, ce->args[i]);
+		array_add(&args, arg);
+	}
+
+
+	lbValue the_proc = {};
+	switch (data.kind) {
+	default:
+		GB_PANIC("unhandled ObjcMsgKind %u", data.kind);
+		break;
+	case ObjcMsg_normal: the_proc = lb_lookup_runtime_procedure(m, str_lit("objc_msgSend"));        break;
+	case ObjcMsg_fpret:  the_proc = lb_lookup_runtime_procedure(m, str_lit("objc_msgSend_fpret"));  break;
+	case ObjcMsg_fp2ret: the_proc = lb_lookup_runtime_procedure(m, str_lit("objc_msgSend_fp2ret")); break;
+	case ObjcMsg_stret:  the_proc = lb_lookup_runtime_procedure(m, str_lit("objc_msgSend_stret"));  break;
+	}
+
+	the_proc = lb_emit_conv(p, the_proc, data.proc_type);
+
+	return lb_emit_call(p, the_proc, args);
+}
diff --git a/src/types.cpp b/src/types.cpp
index 9ee6ba359..cdb31c6e1 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -685,6 +685,16 @@ gb_global Type *t_map_header                     = nullptr;
 gb_global Type *t_equal_proc  = nullptr;
 gb_global Type *t_hasher_proc = nullptr;
 
+gb_global Type *t_objc_object   = nullptr;
+gb_global Type *t_objc_selector = nullptr;
+gb_global Type *t_objc_class    = nullptr;
+
+gb_global Type *t_objc_id    = nullptr;
+gb_global Type *t_objc_SEL   = nullptr;
+gb_global Type *t_objc_Class = nullptr;
+
+
+
 gb_global RecursiveMutex g_type_mutex;
 
 struct TypePath;
-- 
cgit v1.2.3


From fdbbf242718746ad71cb410162c6d0b8c68c5af0 Mon Sep 17 00:00:00 2001
From: gitlost <burmartke@gmail.com>
Date: Fri, 18 Mar 2022 13:57:22 +0000
Subject: Fix issue #1592 "LLVM code gen error when using a constant in an if"
 Changes lb_build_if_stmt() to return null lbValue if condition is   cmpAnd,
 cmpOr or non-const neg and check in lb_build_if_stmt()   to avoid short
 circuiting if that's the case Adds test to "tests/issues" and adds step in CI
 to check this dir

---
 .github/workflows/ci.yml          |  12 +
 src/llvm_backend_expr.cpp         |   4 +-
 src/llvm_backend_general.cpp      |  15 +-
 src/llvm_backend_stmt.cpp         |   5 +-
 tests/issues/test_issue_1592.odin | 489 ++++++++++++++++++++++++++++++++++++++
 5 files changed, 519 insertions(+), 6 deletions(-)
 create mode 100644 tests/issues/test_issue_1592.odin

(limited to 'src/llvm_backend_general.cpp')

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2bd3ca9ad..a3b1d8058 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -38,6 +38,9 @@ jobs:
           cd tests/vendor
           make
         timeout-minutes: 10
+      - name: Odin issues tests
+        run: ./odin run tests/issues -collection:tests=tests
+        timeout-minutes: 10
       - name: Odin check examples/all for Linux i386
         run: ./odin check examples/all -vet -strict-style -target:linux_i386
         timeout-minutes: 10
@@ -87,6 +90,9 @@ jobs:
           cd tests/vendor
           make
         timeout-minutes: 10
+      - name: Odin issues tests
+        run: ./odin run tests/issues -collection:tests=tests
+        timeout-minutes: 10
       - name: Odin check examples/all for Darwin arm64
         run: ./odin check examples/all -vet -strict-style -target:darwin_arm64
         timeout-minutes: 10
@@ -153,6 +159,12 @@ jobs:
           cd tests\core\math\big
           call build.bat
         timeout-minutes: 10
+      - name: Odin issues tests
+        shell: cmd
+        run: |
+          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          odin run tests\issues -collection:tests=tests
+        timeout-minutes: 10
       - name: Odin check examples/all for Windows 32bits
         shell: cmd
         run: |
diff --git a/src/llvm_backend_expr.cpp b/src/llvm_backend_expr.cpp
index 4294747b9..133df4d41 100644
--- a/src/llvm_backend_expr.cpp
+++ b/src/llvm_backend_expr.cpp
@@ -3028,7 +3028,7 @@ lbValue lb_build_expr(lbProcedure *p, Ast *expr) {
 		lbBlock *done  = lb_create_block(p, "if.done"); // NOTE(bill): Append later
 		lbBlock *else_ = lb_create_block(p, "if.else");
 
-		lbValue cond = lb_build_cond(p, te->cond, then, else_);
+		lb_build_cond(p, te->cond, then, else_);
 		lb_start_block(p, then);
 
 		Type *type = default_type(type_of_expr(expr));
@@ -4646,7 +4646,7 @@ lbAddr lb_build_addr(lbProcedure *p, Ast *expr) {
 		lbBlock *done  = lb_create_block(p, "if.done"); // NOTE(bill): Append later
 		lbBlock *else_ = lb_create_block(p, "if.else");
 
-		lbValue cond = lb_build_cond(p, te->cond, then, else_);
+		lb_build_cond(p, te->cond, then, else_);
 		lb_start_block(p, then);
 
 		Type *ptr_type = alloc_type_pointer(default_type(type_of_expr(expr)));
diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index 1c98aa77f..dd1555193 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -2602,6 +2602,9 @@ lbValue lb_build_cond(lbProcedure *p, Ast *cond, lbBlock *true_block, lbBlock *f
 	GB_ASSERT(true_block  != nullptr);
 	GB_ASSERT(false_block != nullptr);
 
+	// Use to signal not to do compile time short circuit for consts
+	lbValue no_comptime_short_circuit = {};
+
 	switch (cond->kind) {
 	case_ast_node(pe, ParenExpr, cond);
 		return lb_build_cond(p, pe->expr, true_block, false_block);
@@ -2609,7 +2612,11 @@ lbValue lb_build_cond(lbProcedure *p, Ast *cond, lbBlock *true_block, lbBlock *f
 
 	case_ast_node(ue, UnaryExpr, cond);
 		if (ue->op.kind == Token_Not) {
-			return lb_build_cond(p, ue->expr, false_block, true_block);
+			lbValue cond_val = lb_build_cond(p, ue->expr, false_block, true_block);
+			if (cond_val.value && LLVMIsConstant(cond_val.value)) {
+				return lb_const_bool(p->module, cond_val.type, LLVMConstIntGetZExtValue(cond_val.value) == 0);
+			}
+			return no_comptime_short_circuit;
 		}
 	case_end;
 
@@ -2618,12 +2625,14 @@ lbValue lb_build_cond(lbProcedure *p, Ast *cond, lbBlock *true_block, lbBlock *f
 			lbBlock *block = lb_create_block(p, "cmp.and");
 			lb_build_cond(p, be->left, block, false_block);
 			lb_start_block(p, block);
-			return lb_build_cond(p, be->right, true_block, false_block);
+			lb_build_cond(p, be->right, true_block, false_block);
+			return no_comptime_short_circuit;
 		} else if (be->op.kind == Token_CmpOr) {
 			lbBlock *block = lb_create_block(p, "cmp.or");
 			lb_build_cond(p, be->left, true_block, block);
 			lb_start_block(p, block);
-			return lb_build_cond(p, be->right, true_block, false_block);
+			lb_build_cond(p, be->right, true_block, false_block);
+			return no_comptime_short_circuit;
 		}
 	case_end;
 	}
diff --git a/src/llvm_backend_stmt.cpp b/src/llvm_backend_stmt.cpp
index 916c0433e..2afb5300b 100644
--- a/src/llvm_backend_stmt.cpp
+++ b/src/llvm_backend_stmt.cpp
@@ -1652,13 +1652,16 @@ void lb_build_if_stmt(lbProcedure *p, Ast *node) {
 	}
 
 	lbValue cond = lb_build_cond(p, is->cond, then, else_);
+	// Note `cond.value` only set for non-and/or conditions and const negs so that the `LLVMIsConstant()`
+	// and `LLVMConstIntGetZExtValue()` calls below will be valid and `LLVMInstructionEraseFromParent()`
+	// will target the correct (& only) branch statement
 
 	if (is->label != nullptr) {
 		lbTargetList *tl = lb_push_target_list(p, is->label, done, nullptr, nullptr);
 		tl->is_block = true;
 	}
 
-	if (LLVMIsConstant(cond.value)) {
+	if (cond.value && LLVMIsConstant(cond.value)) {
 		// NOTE(bill): Do a compile time short circuit for when the condition is constantly known.
 		// This done manually rather than relying on the SSA passes because sometimes the SSA passes
 		// miss some even if they are constantly known, especially with few optimization passes.
diff --git a/tests/issues/test_issue_1592.odin b/tests/issues/test_issue_1592.odin
new file mode 100644
index 000000000..bb350a30b
--- /dev/null
+++ b/tests/issues/test_issue_1592.odin
@@ -0,0 +1,489 @@
+// Tests issue #1592 https://github.com/odin-lang/Odin/issues/1592
+package test_issues
+
+import "core:fmt"
+import "core:testing"
+import tc "tests:common"
+
+main :: proc() {
+	t := testing.T{}
+
+	/* This won't short-circuit */
+	test_orig()
+
+	/* These will short-circuit */
+	test_simple_const_false(&t)
+	test_simple_const_true(&t)
+
+	/* These won't short-circuit */
+	test_simple_proc_false(&t)
+	test_simple_proc_true(&t)
+
+	/* These won't short-circuit */
+	test_const_false_const_false(&t)
+	test_const_false_const_true(&t)
+	test_const_true_const_false(&t)
+	test_const_true_const_true(&t)
+
+	/* These won't short-circuit */
+	test_proc_false_const_false(&t)
+	test_proc_false_const_true(&t)
+	test_proc_true_const_false(&t)
+	test_proc_true_const_true(&t)
+
+	tc.report(&t)
+}
+
+/* Original issue #1592 example */
+
+// I get a LLVM code gen error when this constant is false, but it works when it is true
+CONSTANT_BOOL :: false
+
+bool_result :: proc() -> bool {
+	return false
+}
+
+@test
+test_orig :: proc() {
+	if bool_result() || CONSTANT_BOOL {
+	}
+}
+
+CONSTANT_FALSE :: false
+CONSTANT_TRUE :: true
+
+false_result :: proc() -> bool {
+	return false
+}
+true_result :: proc() -> bool {
+	return true
+}
+
+@test
+test_simple_const_false :: proc(t: ^testing.T) {
+	if CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if (CONSTANT_FALSE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !CONSTANT_FALSE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if (!CONSTANT_FALSE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !(CONSTANT_FALSE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !!CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if CONSTANT_FALSE == true {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if CONSTANT_FALSE == false {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !(CONSTANT_FALSE == true) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !(CONSTANT_FALSE == false) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+}
+
+@test
+test_simple_const_true :: proc(t: ^testing.T) {
+	if CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if (CONSTANT_TRUE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !CONSTANT_TRUE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if (!CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if (!CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !!CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if CONSTANT_TRUE == true {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if CONSTANT_TRUE == false {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(CONSTANT_TRUE == true) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(CONSTANT_TRUE == false) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+}
+
+@test
+test_simple_proc_false :: proc(t: ^testing.T) {
+	if false_result() {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !false_result() {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+}
+
+@test
+test_simple_proc_true :: proc(t: ^testing.T) {
+	if true_result() {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !true_result() {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+}
+
+@test
+test_const_false_const_false :: proc(t: ^testing.T) {
+	if CONSTANT_FALSE || CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if CONSTANT_FALSE && CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !CONSTANT_FALSE || CONSTANT_FALSE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !CONSTANT_FALSE && CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if CONSTANT_FALSE || !CONSTANT_FALSE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if CONSTANT_FALSE && !CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !(CONSTANT_FALSE || CONSTANT_FALSE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !(CONSTANT_FALSE && CONSTANT_FALSE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+}
+
+@test
+test_const_false_const_true :: proc(t: ^testing.T) {
+	if CONSTANT_FALSE || CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if CONSTANT_FALSE && CONSTANT_TRUE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !CONSTANT_FALSE || CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !CONSTANT_FALSE && CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+
+	if CONSTANT_FALSE || !CONSTANT_TRUE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if CONSTANT_FALSE && !CONSTANT_TRUE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !(CONSTANT_FALSE || CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(CONSTANT_FALSE && CONSTANT_TRUE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+}
+
+@test
+test_const_true_const_false :: proc(t: ^testing.T) {
+	if CONSTANT_TRUE || CONSTANT_FALSE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if CONSTANT_TRUE && CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !CONSTANT_TRUE || CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !CONSTANT_TRUE && CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if CONSTANT_TRUE || !CONSTANT_FALSE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if CONSTANT_TRUE && !CONSTANT_FALSE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+
+	if !(CONSTANT_TRUE || CONSTANT_FALSE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(CONSTANT_TRUE && CONSTANT_FALSE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+}
+
+@test
+test_const_true_const_true :: proc(t: ^testing.T) {
+	if CONSTANT_TRUE || CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if CONSTANT_TRUE && CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+
+	if !CONSTANT_TRUE || CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !CONSTANT_TRUE && CONSTANT_TRUE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if CONSTANT_TRUE || !CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if CONSTANT_TRUE && !CONSTANT_TRUE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !(CONSTANT_TRUE || CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(CONSTANT_TRUE && CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+}
+
+@test
+test_proc_false_const_false :: proc(t: ^testing.T) {
+	if false_result() || CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if false_result() && CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !(false_result() || CONSTANT_FALSE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if !(false_result() && CONSTANT_FALSE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+}
+
+@test
+test_proc_false_const_true :: proc(t: ^testing.T) {
+	if false_result() || CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if false_result() && CONSTANT_TRUE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !(false_result() || CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(false_result() && CONSTANT_TRUE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+}
+
+@test
+test_proc_true_const_false :: proc(t: ^testing.T) {
+	if true_result() || CONSTANT_FALSE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if true_result() && CONSTANT_FALSE {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+
+	if !(true_result() || CONSTANT_FALSE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(true_result() && CONSTANT_FALSE) {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+}
+
+@test
+test_proc_true_const_true :: proc(t: ^testing.T) {
+	if true_result() || CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+	if true_result() && CONSTANT_TRUE {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	} else {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	}
+
+	if !(true_result() || CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+	if !(true_result() && CONSTANT_TRUE) {
+		tc.expect(t, false, fmt.tprintf("%s: !false\n", #procedure))
+	} else {
+		tc.expect(t, true, fmt.tprintf("%s: !true\n", #procedure))
+	}
+}
-- 
cgit v1.2.3


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

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

(limited to 'src/llvm_backend_general.cpp')

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


From f702c782f15994cfab165c58a8415d122f7c9d0d Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Thu, 24 Mar 2022 12:18:17 +0000
Subject: Make constant string backing structures use PrivateLinkage compared
 to InternalLinkage

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

(limited to 'src/llvm_backend_general.cpp')

diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index f6dd97966..330059622 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -2337,7 +2337,7 @@ LLVMValueRef lb_find_or_add_entity_string_ptr(lbModule *m, String const &str) {
 
 		LLVMValueRef global_data = LLVMAddGlobal(m->mod, LLVMTypeOf(data), name);
 		LLVMSetInitializer(global_data, data);
-		LLVMSetLinkage(global_data, LLVMInternalLinkage);
+		LLVMSetLinkage(global_data, LLVMPrivateLinkage);
 
 		LLVMValueRef ptr = LLVMConstInBoundsGEP(global_data, indices, 2);
 		string_map_set(&m->const_strings, key, ptr);
@@ -2379,7 +2379,7 @@ lbValue lb_find_or_add_entity_string_byte_slice(lbModule *m, String const &str)
 	}
 	LLVMValueRef global_data = LLVMAddGlobal(m->mod, LLVMTypeOf(data), name);
 	LLVMSetInitializer(global_data, data);
-	LLVMSetLinkage(global_data, LLVMInternalLinkage);
+	LLVMSetLinkage(global_data, LLVMPrivateLinkage);
 
 	LLVMValueRef ptr = nullptr;
 	if (str.len != 0) {
@@ -2615,7 +2615,7 @@ lbValue lb_generate_global_array(lbModule *m, Type *elem_type, i64 count, String
 	g.value = LLVMAddGlobal(m->mod, lb_type(m, t), text);
 	g.type = alloc_type_pointer(t);
 	LLVMSetInitializer(g.value, LLVMConstNull(lb_type(m, t)));
-	LLVMSetLinkage(g.value, LLVMInternalLinkage);
+	LLVMSetLinkage(g.value, LLVMPrivateLinkage);
 	string_map_set(&m->members, s, g);
 	return g;
 }
-- 
cgit v1.2.3


From 3cab2592c3e5a06882ffd711871a08c893b043f1 Mon Sep 17 00:00:00 2001
From: Jeroen van Rijn <Kelimion@users.noreply.github.com>
Date: Wed, 6 Apr 2022 18:26:23 +0200
Subject: Compiler: Add early error for output path being a directory.

- Introduce new `Path` type and an array of build paths on the build context.
- Resolve input and output paths/files early (before parsing).
- Error early if inputs are missing or outputs are directories.
- Plumb new file path generation into linker stage instead of its adhoc method.

TODO:
- Remove more adhoc file path generation in parser and linker stage.
- Make intermediate object file generation use new path system.
- Round out and robustify Path helper functions.
---
 .gitignore                    |   1 +
 Makefile                      |   4 +-
 build_odin.sh                 |   4 +-
 src/build_settings.cpp        | 220 ++++++++++++++++++++++++----
 src/common.cpp                | 257 +-------------------------------
 src/gb/gb.h                   |  46 ++++--
 src/llvm_backend.cpp          |  14 +-
 src/llvm_backend_general.cpp  |   1 -
 src/main.cpp                  | 152 +++++++++----------
 src/parser.cpp                |   2 +-
 src/path.cpp                  | 333 ++++++++++++++++++++++++++++++++++++++++++
 src/string.cpp                |  10 +-
 tests/core/build.bat          |  28 ++--
 tests/core/math/big/build.bat |   2 +-
 tests/issues/run.sh           |   4 +-
 15 files changed, 674 insertions(+), 404 deletions(-)
 create mode 100644 src/path.cpp

(limited to 'src/llvm_backend_general.cpp')

diff --git a/.gitignore b/.gitignore
index e8b3d3050..d03a86fd7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -269,6 +269,7 @@ bin/
 # - Linux/MacOS
 odin
 odin.dSYM
+*.bin
 
 # shared collection
 shared/
diff --git a/Makefile b/Makefile
index 82150c6a2..1a1c93180 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
-all: debug demo
+all: debug
 
 demo:
-	./odin run examples/demo/demo.odin
+	./odin run examples/demo
 
 report:
 	./odin report
diff --git a/build_odin.sh b/build_odin.sh
index aef3f2836..4810cafd2 100755
--- a/build_odin.sh
+++ b/build_odin.sh
@@ -102,7 +102,7 @@ build_odin() {
 }
 
 run_demo() {
-	./odin run examples/demo/demo.odin -file
+	./odin run examples/demo
 }
 
 case $OS in
@@ -147,4 +147,4 @@ if [[ $# -eq 1 ]]; then
 	exit 0
 else
 	panic "Too many arguments!"
-fi
+fi
\ No newline at end of file
diff --git a/src/build_settings.cpp b/src/build_settings.cpp
index 2f3eb03a5..0b582eac8 100644
--- a/src/build_settings.cpp
+++ b/src/build_settings.cpp
@@ -3,7 +3,6 @@
 #include <sys/sysctl.h>
 #endif
 
-
 // #if defined(GB_SYSTEM_WINDOWS)
 // #define DEFAULT_TO_THREADED_CHECKER
 // #endif
@@ -198,6 +197,22 @@ enum RelocMode : u8 {
 	RelocMode_DynamicNoPIC,
 };
 
+enum BuildPath : u8 {
+	BuildPath_Main_Package,     // Input  Path to the package directory (or file) we're building.
+	BuildPath_RC,               // Input  Path for .rc  file, can be set with `-resource:`.
+	BuildPath_RES,              // Output Path for .res file, generated from previous.
+	BuildPath_Win_SDK_Root,     // windows_sdk_root
+	BuildPath_Win_SDK_UM_Lib,   // windows_sdk_um_library_path
+	BuildPath_Win_SDK_UCRT_Lib, // windows_sdk_ucrt_library_path
+	BuildPath_VS_EXE,           // vs_exe_path
+	BuildPath_VS_LIB,           // vs_library_path
+
+	BuildPath_Output,           // Output Path for .exe, .dll, .so, etc. Can be overridden with `-out:`.
+	BuildPath_PDB,              // Output Path for .pdb file, can be overridden with `-pdb-name:`.
+
+	BuildPathCOUNT,
+};
+
 // This stores the information for the specify architecture of this build
 struct BuildContext {
 	// Constants
@@ -226,9 +241,13 @@ struct BuildContext {
 
 	bool show_help;
 
+	Array<Path> build_paths;   // Contains `Path` objects to output filename, pdb, resource and intermediate files.
+	                           // BuildPath enum contains the indices of paths we know *before* the work starts.
+
 	String out_filepath;
 	String resource_filepath;
 	String pdb_filepath;
+
 	bool   has_resource;
 	String link_flags;
 	String extra_linker_flags;
@@ -300,8 +319,6 @@ struct BuildContext {
 
 };
 
-
-
 gb_global BuildContext build_context = {0};
 
 bool global_warnings_as_errors(void) {
@@ -605,28 +622,6 @@ bool allow_check_foreign_filepath(void) {
 // is_abs_path
 // has_subdir
 
-enum TargetFileValidity : u8 {
-	TargetFileValidity_Invalid,
-
-	TargetFileValidity_Writable_File,
-	TargetFileValidity_No_Write_Permission,
-	TargetFileValidity_Directory,
-
-	TargetTargetFileValidity_COUNT,
-};
-
-TargetFileValidity set_output_filename(void) {
-	// Assembles the output filename from build_context information.
-	// Returns `true`  if it doesn't exist or is a file.
-	// Returns `false` if a directory or write-protected file.
-
-
-
-
-	return TargetFileValidity_Writable_File;
-}
-
-
 String const WIN32_SEPARATOR_STRING = {cast(u8 *)"\\", 1};
 String const NIX_SEPARATOR_STRING   = {cast(u8 *)"/",  1};
 
@@ -973,7 +968,6 @@ char *token_pos_to_string(TokenPos const &pos) {
 	return s;
 }
 
-
 void init_build_context(TargetMetrics *cross_target) {
 	BuildContext *bc = &build_context;
 
@@ -1152,8 +1146,178 @@ void init_build_context(TargetMetrics *cross_target) {
 
 	bc->optimization_level = gb_clamp(bc->optimization_level, 0, 3);
 
-
-
 	#undef LINK_FLAG_X64
 	#undef LINK_FLAG_386
 }
+
+#if defined(GB_SYSTEM_WINDOWS)
+// NOTE(IC): In order to find Visual C++ paths without relying on environment variables.
+// NOTE(Jeroen): No longer needed in `main.cpp -> linker_stage`. We now resolve those paths in `init_build_paths`.
+#include "microsoft_craziness.h"
+#endif
+
+// NOTE(Jeroen): Set/create the output and other paths and report an error as appropriate.
+// We've previously called `parse_build_flags`, so `out_filepath` should be set.
+bool init_build_paths(String init_filename) {
+	gbAllocator   ha = heap_allocator();
+	BuildContext *bc = &build_context;
+
+	// NOTE(Jeroen): We're pre-allocating BuildPathCOUNT slots so that certain paths are always at the same enumerated index.
+	array_init(&bc->build_paths, permanent_allocator(), BuildPathCOUNT);
+
+	// [BuildPathMainPackage] Turn given init path into a `Path`, which includes normalizing it into a full path.
+	bc->build_paths[BuildPath_Main_Package] = path_from_string(ha, init_filename);
+
+	bool produces_output_file = false;
+	if (bc->command_kind == Command_doc && bc->cmd_doc_flags & CmdDocFlag_DocFormat) {
+		produces_output_file = true;
+	} else if (bc->command_kind & Command__does_build) {
+		produces_output_file = true;
+	}
+
+	if (!produces_output_file) {
+		// Command doesn't produce output files. We're done.
+		return true;
+	}
+
+	#if defined(GB_SYSTEM_WINDOWS)
+		if (bc->resource_filepath.len > 0) {
+			bc->build_paths[BuildPath_RC]      = path_from_string(ha, bc->resource_filepath);
+			bc->build_paths[BuildPath_RES]     = path_from_string(ha, bc->resource_filepath);
+			bc->build_paths[BuildPath_RC].ext  = copy_string(ha, STR_LIT("rc"));
+			bc->build_paths[BuildPath_RES].ext = copy_string(ha, STR_LIT("res"));
+		}
+
+		if (bc->pdb_filepath.len > 0) {
+			bc->build_paths[BuildPath_PDB]          = path_from_string(ha, bc->pdb_filepath);
+		}
+
+		if ((bc->command_kind & Command__does_build) && (!bc->ignore_microsoft_magic)) {
+			// NOTE(ic): It would be nice to extend this so that we could specify the Visual Studio version that we want instead of defaulting to the latest.
+			Find_Result_Utf8 find_result = find_visual_studio_and_windows_sdk_utf8();
+
+			if (find_result.windows_sdk_version == 0) {
+				gb_printf_err("Windows SDK not found.\n");
+				return false;
+			}
+
+			GB_ASSERT(find_result.windows_sdk_um_library_path.len > 0);
+			GB_ASSERT(find_result.windows_sdk_ucrt_library_path.len > 0);
+
+			if (find_result.windows_sdk_root.len > 0) {
+				bc->build_paths[BuildPath_Win_SDK_Root]     = path_from_string(ha, find_result.windows_sdk_root);
+			}
+
+			if (find_result.windows_sdk_um_library_path.len > 0) {
+				bc->build_paths[BuildPath_Win_SDK_UM_Lib]   = path_from_string(ha, find_result.windows_sdk_um_library_path);
+			}
+
+			if (find_result.windows_sdk_ucrt_library_path.len > 0) {
+				bc->build_paths[BuildPath_Win_SDK_UCRT_Lib] = path_from_string(ha, find_result.windows_sdk_ucrt_library_path);
+			}
+
+			if (find_result.vs_exe_path.len > 0) {
+				bc->build_paths[BuildPath_VS_EXE]           = path_from_string(ha, find_result.vs_exe_path);
+			}
+
+			if (find_result.vs_library_path.len > 0) {
+				bc->build_paths[BuildPath_VS_LIB]           = path_from_string(ha, find_result.vs_library_path);
+			}
+
+			gb_free(ha, find_result.windows_sdk_root.text);
+			gb_free(ha, find_result.windows_sdk_um_library_path.text);
+			gb_free(ha, find_result.windows_sdk_ucrt_library_path.text);
+			gb_free(ha, find_result.vs_exe_path.text);
+			gb_free(ha, find_result.vs_library_path.text);
+
+		}
+	#endif
+
+	// All the build targets and OSes.
+	String output_extension;
+
+	if (bc->command_kind == Command_doc && bc->cmd_doc_flags & CmdDocFlag_DocFormat) {
+		output_extension = STR_LIT("odin-doc");
+	} else if (is_arch_wasm()) {
+		output_extension = STR_LIT("wasm");
+	} else if (build_context.build_mode == BuildMode_Executable) {
+		// By default use a .bin executable extension.
+		output_extension = STR_LIT("bin");
+
+		if (build_context.metrics.os == TargetOs_windows) {
+			output_extension = STR_LIT("exe");
+		} else if (build_context.cross_compiling && selected_target_metrics->metrics == &target_essence_amd64) {
+			output_extension = make_string(nullptr, 0);
+		}
+	} else if (build_context.build_mode == BuildMode_DynamicLibrary) {
+		// By default use a .so shared library extension.
+		output_extension = STR_LIT("so");
+
+		if (build_context.metrics.os == TargetOs_windows) {
+			output_extension = STR_LIT("dll");
+		} else if (build_context.metrics.os == TargetOs_darwin) {
+			output_extension = STR_LIT("dylib");
+		}
+	} else if (build_context.build_mode == BuildMode_Object) {
+		// By default use a .o object extension.
+		output_extension = STR_LIT("o");
+
+		if (build_context.metrics.os == TargetOs_windows) {
+			output_extension = STR_LIT("obj");
+		}
+	} else if (build_context.build_mode == BuildMode_Assembly) {
+		// By default use a .S asm extension.
+		output_extension = STR_LIT("S");
+	} else if (build_context.build_mode == BuildMode_LLVM_IR) {
+		output_extension = STR_LIT("ll");
+	} else {
+		GB_PANIC("Unhandled build mode/target combination.\n");
+	}
+
+	if (bc->out_filepath.len > 0) {
+		bc->build_paths[BuildPath_Output] = path_from_string(ha, bc->out_filepath);
+	} else {
+		String output_name = remove_directory_from_path(init_filename);
+		output_name        = remove_extension_from_path(output_name);
+		output_name        = copy_string(ha, string_trim_whitespace(output_name));
+
+		/*
+		NOTE(Jeroen): This fallback substitution can't be made at this stage.
+		if (gen->output_name.len == 0) {
+			gen->output_name = c->info.init_scope->pkg->name;
+		}
+		*/
+		Path output_path = path_from_string(ha, output_name);
+
+		#ifndef GB_SYSTEM_WINDOWS
+			char cwd[4096];
+			getcwd(&cwd[0], 4096);
+
+			const u8 * cwd_str = (const u8 *)&cwd[0];
+			output_path.basename = copy_string(ha, make_string(cwd_str, strlen(cwd)));
+		#endif
+
+		// Replace extension.
+		if (output_path.ext.len > 0) {
+			gb_free(ha, output_path.ext.text);
+		}
+		output_path.ext  = copy_string(ha, output_extension);
+
+		bc->build_paths[BuildPath_Output] = output_path;
+	}
+
+	// Do we have an extension? We might not if the output filename was supplied.
+	if (bc->build_paths[BuildPath_Output].ext.len == 0) {
+		bc->build_paths[BuildPath_Output].ext = copy_string(ha, output_extension);
+	}
+
+	// Check if output path is a directory.
+	if (path_is_directory(bc->build_paths[BuildPath_Output])) {
+		String output_file = path_to_string(ha, bc->build_paths[BuildPath_Output]);
+		defer (gb_free(ha, output_file.text));
+		gb_printf_err("Output path %.*s is a directory.\n", LIT(output_file));
+		return false;
+	}
+
+	return true;
+}
\ No newline at end of file
diff --git a/src/common.cpp b/src/common.cpp
index aaacda04b..94248fb62 100644
--- a/src/common.cpp
+++ b/src/common.cpp
@@ -675,262 +675,7 @@ wchar_t **command_line_to_wargv(wchar_t *cmd_line, int *_argc) {
 
 #endif
 
-
-#if defined(GB_SYSTEM_WINDOWS)
-	bool path_is_directory(String path) {
-		gbAllocator a = heap_allocator();
-		String16 wstr = string_to_string16(a, path);
-		defer (gb_free(a, wstr.text));
-
-		i32 attribs = GetFileAttributesW(wstr.text);
-		if (attribs < 0) return false;
-
-		return (attribs & FILE_ATTRIBUTE_DIRECTORY) != 0;
-	}
-
-#else
-	bool path_is_directory(String path) {
-		gbAllocator a = heap_allocator();
-		char *copy = cast(char *)copy_string(a, path).text;
-		defer (gb_free(a, copy));
-
-		struct stat s;
-		if (stat(copy, &s) == 0) {
-			return (s.st_mode & S_IFDIR) != 0;
-		}
-		return false;
-	}
-#endif
-
-
-String path_to_full_path(gbAllocator a, String path) {
-	gbAllocator ha = heap_allocator();
-	char *path_c = gb_alloc_str_len(ha, cast(char *)path.text, path.len);
-	defer (gb_free(ha, path_c));
-
-	char *fullpath = gb_path_get_full_name(a, path_c);
-	String res = string_trim_whitespace(make_string_c(fullpath));
-#if defined(GB_SYSTEM_WINDOWS)
-	for (isize i = 0; i < res.len; i++) {
-		if (res.text[i] == '\\') {
-			res.text[i] = '/';
-		}
-	}
-#endif
-	return res;
-}
-
-
-
-struct FileInfo {
-	String name;
-	String fullpath;
-	i64    size;
-	bool   is_dir;
-};
-
-enum ReadDirectoryError {
-	ReadDirectory_None,
-
-	ReadDirectory_InvalidPath,
-	ReadDirectory_NotExists,
-	ReadDirectory_Permission,
-	ReadDirectory_NotDir,
-	ReadDirectory_Empty,
-	ReadDirectory_Unknown,
-
-	ReadDirectory_COUNT,
-};
-
-i64 get_file_size(String path) {
-	char *c_str = alloc_cstring(heap_allocator(), path);
-	defer (gb_free(heap_allocator(), c_str));
-
-	gbFile f = {};
-	gbFileError err = gb_file_open(&f, c_str);
-	defer (gb_file_close(&f));
-	if (err != gbFileError_None) {
-		return -1;
-	}
-	return gb_file_size(&f);
-}
-
-
-#if defined(GB_SYSTEM_WINDOWS)
-ReadDirectoryError read_directory(String path, Array<FileInfo> *fi) {
-	GB_ASSERT(fi != nullptr);
-
-	gbAllocator a = heap_allocator();
-
-	while (path.len > 0) {
-		Rune end = path[path.len-1];
-		if (end == '/') {
-			path.len -= 1;
-		} else if (end == '\\') {
-			path.len -= 1;
-		} else {
-			break;
-		}
-	}
-
-	if (path.len == 0) {
-		return ReadDirectory_InvalidPath;
-	}
-	{
-		char *c_str = alloc_cstring(a, path);
-		defer (gb_free(a, c_str));
-
-		gbFile f = {};
-		gbFileError file_err = gb_file_open(&f, c_str);
-		defer (gb_file_close(&f));
-
-		switch (file_err) {
-		case gbFileError_Invalid:    return ReadDirectory_InvalidPath;
-		case gbFileError_NotExists:  return ReadDirectory_NotExists;
-		// case gbFileError_Permission: return ReadDirectory_Permission;
-		}
-	}
-
-	if (!path_is_directory(path)) {
-		return ReadDirectory_NotDir;
-	}
-
-
-	char *new_path = gb_alloc_array(a, char, path.len+3);
-	defer (gb_free(a, new_path));
-
-	gb_memmove(new_path, path.text, path.len);
-	gb_memmove(new_path+path.len, "/*", 2);
-	new_path[path.len+2] = 0;
-
-	String np = make_string(cast(u8 *)new_path, path.len+2);
-	String16 wstr = string_to_string16(a, np);
-	defer (gb_free(a, wstr.text));
-
-	WIN32_FIND_DATAW file_data = {};
-	HANDLE find_file = FindFirstFileW(wstr.text, &file_data);
-	if (find_file == INVALID_HANDLE_VALUE) {
-		return ReadDirectory_Unknown;
-	}
-	defer (FindClose(find_file));
-
-	array_init(fi, a, 0, 100);
-
-	do {
-		wchar_t *filename_w = file_data.cFileName;
-		i64 size = cast(i64)file_data.nFileSizeLow;
-		size |= (cast(i64)file_data.nFileSizeHigh) << 32;
-		String name = string16_to_string(a, make_string16_c(filename_w));
-		if (name == "." || name == "..") {
-			gb_free(a, name.text);
-			continue;
-		}
-
-		String filepath = {};
-		filepath.len = path.len+1+name.len;
-		filepath.text = gb_alloc_array(a, u8, filepath.len+1);
-		defer (gb_free(a, filepath.text));
-		gb_memmove(filepath.text, path.text, path.len);
-		gb_memmove(filepath.text+path.len, "/", 1);
-		gb_memmove(filepath.text+path.len+1, name.text, name.len);
-
-		FileInfo info = {};
-		info.name = name;
-		info.fullpath = path_to_full_path(a, filepath);
-		info.size = size;
-		info.is_dir = (file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
-		array_add(fi, info);
-	} while (FindNextFileW(find_file, &file_data));
-
-	if (fi->count == 0) {
-		return ReadDirectory_Empty;
-	}
-
-	return ReadDirectory_None;
-}
-#elif defined(GB_SYSTEM_LINUX) || defined(GB_SYSTEM_OSX) || defined(GB_SYSTEM_FREEBSD) || defined(GB_SYSTEM_OPENBSD)
-
-#include <dirent.h>
-
-ReadDirectoryError read_directory(String path, Array<FileInfo> *fi) {
-	GB_ASSERT(fi != nullptr);
-
-	gbAllocator a = heap_allocator();
-
-	char *c_path = alloc_cstring(a, path);
-	defer (gb_free(a, c_path));
-
-	DIR *dir = opendir(c_path);
-	if (!dir) {
-		switch (errno) {
-		case ENOENT:
-			return ReadDirectory_NotExists;
-		case EACCES:
-			return ReadDirectory_Permission;
-		case ENOTDIR:
-			return ReadDirectory_NotDir;
-		default:
-			// ENOMEM: out of memory
-			// EMFILE: per-process limit on open fds reached
-			// ENFILE: system-wide limit on total open files reached
-			return ReadDirectory_Unknown;
-		}
-		GB_PANIC("unreachable");
-	}
-
-	array_init(fi, a, 0, 100);
-
-	for (;;) {
-		struct dirent *entry = readdir(dir);
-		if (entry == nullptr) {
-			break;
-		}
-
-		String name = make_string_c(entry->d_name);
-		if (name == "." || name == "..") {
-			continue;
-		}
-
-		String filepath = {};
-		filepath.len = path.len+1+name.len;
-		filepath.text = gb_alloc_array(a, u8, filepath.len+1);
-		defer (gb_free(a, filepath.text));
-		gb_memmove(filepath.text, path.text, path.len);
-		gb_memmove(filepath.text+path.len, "/", 1);
-		gb_memmove(filepath.text+path.len+1, name.text, name.len);
-		filepath.text[filepath.len] = 0;
-
-
-		struct stat dir_stat = {};
-
-		if (stat((char *)filepath.text, &dir_stat)) {
-			continue;
-		}
-
-		if (S_ISDIR(dir_stat.st_mode)) {
-			continue;
-		}
-
-		i64 size = dir_stat.st_size;
-
-		FileInfo info = {};
-		info.name = name;
-		info.fullpath = path_to_full_path(a, filepath);
-		info.size = size;
-		array_add(fi, info);
-	}
-
-	if (fi->count == 0) {
-		return ReadDirectory_Empty;
-	}
-
-	return ReadDirectory_None;
-}
-#else
-#error Implement read_directory
-#endif
-
-
+#include "path.cpp"
 
 struct LoadedFile {
 	void *handle;
diff --git a/src/gb/gb.h b/src/gb/gb.h
index b72a893f7..3b2d6434c 100644
--- a/src/gb/gb.h
+++ b/src/gb/gb.h
@@ -6273,20 +6273,44 @@ char *gb_path_get_full_name(gbAllocator a, char const *path) {
 #else
 	char *p, *result, *fullpath = NULL;
 	isize len;
-	p = realpath(path, NULL);
-	fullpath = p;
-	if (p == NULL) {
-		// NOTE(bill): File does not exist
-		fullpath = cast(char *)path;
-	}
+	fullpath = realpath(path, NULL);
+
+	if (fullpath == NULL) {
+		// NOTE(Jeroen): Path doesn't exist.
+		if (gb_strlen(path) > 0 && path[0] == '/') {
+			// But it is an absolute path, so return as-is.
+
+			fullpath = (char *)path;
+			len      = gb_strlen(fullpath) + 1;
+			result   = gb_alloc_array(a, char, len + 1);
+
+			gb_memmove(result, fullpath, len);
+			result[len] = 0;
+
+		} else {
+			// Appears to be a relative path, so construct an absolute one relative to <cwd>.
+			char cwd[4096];
+			getcwd(&cwd[0], 4096);
+
+			isize path_len = gb_strlen(path);
+			isize cwd_len  = gb_strlen(cwd);
+			len            = cwd_len + 1 + path_len + 1;
+			result         = gb_alloc_array(a, char, len);
 
-	len = gb_strlen(fullpath);
+			gb_memmove(result, (void *)cwd, cwd_len);
+			result[cwd_len] = '/';
 
-	result = gb_alloc_array(a, char, len + 1);
-	gb_memmove(result, fullpath, len);
-	result[len] = 0;
-	free(p);
+			gb_memmove(result + cwd_len + 1, (void *)path, gb_strlen(path));
+			result[len] = 0;
 
+		}
+	} else {
+		len      = gb_strlen(fullpath) + 1;
+		result   = gb_alloc_array(a, char, len + 1);
+		gb_memmove(result, fullpath, len);
+		result[len] = 0;
+		free(fullpath);
+	}
 	return result;
 #endif
 }
diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index f5cb84785..7781997f7 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -967,7 +967,12 @@ lbProcedure *lb_create_main_procedure(lbModule *m, lbProcedure *startup_runtime)
 }
 
 String lb_filepath_ll_for_module(lbModule *m) {
-	String path = m->gen->output_base;
+	String path = concatenate3_strings(permanent_allocator(),
+		build_context.build_paths[BuildPath_Output].basename,
+		STR_LIT("/"),
+		build_context.build_paths[BuildPath_Output].name
+	);
+
 	if (m->pkg) {
 		path = concatenate3_strings(permanent_allocator(), path, STR_LIT("-"), m->pkg->name);
 	} else if (USE_SEPARATE_MODULES) {
@@ -978,7 +983,12 @@ String lb_filepath_ll_for_module(lbModule *m) {
 	return path;
 }
 String lb_filepath_obj_for_module(lbModule *m) {
-	String path = m->gen->output_base;
+	String path = concatenate3_strings(permanent_allocator(),
+		build_context.build_paths[BuildPath_Output].basename,
+		STR_LIT("/"),
+		build_context.build_paths[BuildPath_Output].name
+	);
+
 	if (m->pkg) {
 		path = concatenate3_strings(permanent_allocator(), path, STR_LIT("-"), m->pkg->name);
 	}
diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index 330059622..1a431a4ac 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -87,7 +87,6 @@ bool lb_init_generator(lbGenerator *gen, Checker *c) {
 		return false;
 	}
 
-
 	String init_fullpath = c->parser->init_fullpath;
 
 	if (build_context.out_filepath.len == 0) {
diff --git a/src/main.cpp b/src/main.cpp
index fc8792ceb..7b0364149 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -46,7 +46,6 @@ gb_global Timings global_timings = {0};
 #include "checker.cpp"
 #include "docs.cpp"
 
-
 #include "llvm_backend.cpp"
 
 #if defined(GB_SYSTEM_OSX)
@@ -57,16 +56,8 @@ gb_global Timings global_timings = {0};
 #endif
 
 #include "query_data.cpp"
-
-
-#if defined(GB_SYSTEM_WINDOWS)
-// NOTE(IC): In order to find Visual C++ paths without relying on environment variables.
-#include "microsoft_craziness.h"
-#endif
-
 #include "bug_report.cpp"
 
-
 // NOTE(bill): 'name' is used in debugging and profiling modes
 i32 system_exec_command_line_app(char const *name, char const *fmt, ...) {
 	isize const cmd_cap = 64<<20; // 64 MiB should be more than enough
@@ -130,34 +121,35 @@ i32 system_exec_command_line_app(char const *name, char const *fmt, ...) {
 }
 
 
-
-
 i32 linker_stage(lbGenerator *gen) {
 	i32 result = 0;
 	Timings *timings = &global_timings;
 
-	String output_base = gen->output_base;
+	String output_filename = path_to_string(heap_allocator(), build_context.build_paths[BuildPath_Output]);
+	debugf("Linking %.*s\n", LIT(output_filename));
+
+	// TOOD(Jeroen): Make a `build_paths[BuildPath_Object] to avoid `%.*s.o`.
 
 	if (is_arch_wasm()) {
 		timings_start_section(timings, str_lit("wasm-ld"));
 
 	#if defined(GB_SYSTEM_WINDOWS)
 		result = system_exec_command_line_app("wasm-ld",
-			"\"%.*s\\bin\\wasm-ld\" \"%.*s.wasm.o\" -o \"%.*s.wasm\" %.*s %.*s",
+			"\"%.*s\\bin\\wasm-ld\" \"%.*s.o\" -o \"%.*s\" %.*s %.*s",
 			LIT(build_context.ODIN_ROOT),
-			LIT(output_base), LIT(output_base), LIT(build_context.link_flags), LIT(build_context.extra_linker_flags));
+			LIT(output_filename), LIT(output_filename), LIT(build_context.link_flags), LIT(build_context.extra_linker_flags));
 	#else
 		result = system_exec_command_line_app("wasm-ld",
-			"wasm-ld \"%.*s.wasm.o\" -o \"%.*s.wasm\" %.*s %.*s",
-			LIT(output_base), LIT(output_base), LIT(build_context.link_flags), LIT(build_context.extra_linker_flags));
+			"wasm-ld \"%.*s.o\" -o \"%.*s\" %.*s %.*s",
+			LIT(output_filename), LIT(output_filename), LIT(build_context.link_flags), LIT(build_context.extra_linker_flags));
 	#endif
 		return result;
 	}
 
 	if (build_context.cross_compiling && selected_target_metrics->metrics == &target_essence_amd64) {
-#ifdef GB_SYSTEM_UNIX
+#if defined(GB_SYSTEM_UNIX) 
 		result = system_exec_command_line_app("linker", "x86_64-essence-gcc \"%.*s.o\" -o \"%.*s\" %.*s %.*s",
-			LIT(output_base), LIT(output_base), LIT(build_context.link_flags), LIT(build_context.extra_linker_flags));
+			LIT(output_filename), LIT(output_filename), LIT(build_context.link_flags), LIT(build_context.extra_linker_flags));
 #else
 		gb_printf_err("Linking for cross compilation for this platform is not yet supported (%.*s %.*s)\n",
 			LIT(target_os_names[build_context.metrics.os]),
@@ -181,28 +173,11 @@ i32 linker_stage(lbGenerator *gen) {
 		gbString lib_str = gb_string_make(heap_allocator(), "");
 		defer (gb_string_free(lib_str));
 
-		char const *output_ext = "exe";
 		gbString link_settings = gb_string_make_reserve(heap_allocator(), 256);
 		defer (gb_string_free(link_settings));
 
-
-		// NOTE(ic): It would be nice to extend this so that we could specify the Visual Studio version that we want instead of defaulting to the latest.
-		Find_Result_Utf8 find_result = find_visual_studio_and_windows_sdk_utf8();
-
-		if (find_result.windows_sdk_version == 0) {
-			gb_printf_err("Windows SDK not found.\n");
-			exit(1);
-		}
-
-		if (build_context.ignore_microsoft_magic) {
-			find_result = {};
-		}
-
 		// Add library search paths.
-		if (find_result.vs_library_path.len > 0) {
-			GB_ASSERT(find_result.windows_sdk_um_library_path.len > 0);
-			GB_ASSERT(find_result.windows_sdk_ucrt_library_path.len > 0);
-
+		if (build_context.build_paths[BuildPath_VS_LIB].basename.len > 0) {
 			String path = {};
 			auto add_path = [&](String path) {
 				if (path[path.len-1] == '\\') {
@@ -210,9 +185,9 @@ i32 linker_stage(lbGenerator *gen) {
 				}
 				link_settings = gb_string_append_fmt(link_settings, " /LIBPATH:\"%.*s\"", LIT(path));
 			};
-			add_path(find_result.windows_sdk_um_library_path);
-			add_path(find_result.windows_sdk_ucrt_library_path);
-			add_path(find_result.vs_library_path);
+			add_path(build_context.build_paths[BuildPath_Win_SDK_UM_Lib].basename);
+			add_path(build_context.build_paths[BuildPath_Win_SDK_UCRT_Lib].basename);
+			add_path(build_context.build_paths[BuildPath_VS_LIB].basename);
 		}
 
 
@@ -252,14 +227,14 @@ i32 linker_stage(lbGenerator *gen) {
 
 
 		if (build_context.build_mode == BuildMode_DynamicLibrary) {
-			output_ext = "dll";
 			link_settings = gb_string_append_fmt(link_settings, " /DLL");
 		} else {
 			link_settings = gb_string_append_fmt(link_settings, " /ENTRY:mainCRTStartup");
 		}
 
 		if (build_context.pdb_filepath != "") {
-			link_settings = gb_string_append_fmt(link_settings, " /PDB:%.*s", LIT(build_context.pdb_filepath));
+			String pdb_path = path_to_string(heap_allocator(), build_context.build_paths[BuildPath_PDB]);
+			link_settings = gb_string_append_fmt(link_settings, " /PDB:%.*s", LIT(pdb_path));
 		}
 
 		if (build_context.no_crt) {
@@ -300,13 +275,21 @@ i32 linker_stage(lbGenerator *gen) {
 			object_files = gb_string_append_fmt(object_files, "\"%.*s\" ", LIT(object_path));
 		}
 
+		String vs_exe_path = path_to_string(heap_allocator(), build_context.build_paths[BuildPath_VS_EXE]);
+		defer (gb_free(heap_allocator(), vs_exe_path.text));
+
 		char const *subsystem_str = build_context.use_subsystem_windows ? "WINDOWS" : "CONSOLE";
 		if (!build_context.use_lld) { // msvc
 			if (build_context.has_resource) {
+				String rc_path  = path_to_string(heap_allocator(), build_context.build_paths[BuildPath_RC]);
+				String res_path = path_to_string(heap_allocator(), build_context.build_paths[BuildPath_RES]);
+				defer (gb_free(heap_allocator(), rc_path.text));
+				defer (gb_free(heap_allocator(), res_path.text));
+
 				result = system_exec_command_line_app("msvc-link",
-					"\"rc.exe\" /nologo /fo \"%.*s.res\" \"%.*s.rc\"",
-					LIT(output_base),
-					LIT(build_context.resource_filepath)
+					"\"rc.exe\" /nologo /fo \"%.*s\" \"%.*s\"",
+					LIT(res_path),
+					LIT(rc_path)
 				);
 
 				if (result) {
@@ -314,13 +297,13 @@ i32 linker_stage(lbGenerator *gen) {
 				}
 
 				result = system_exec_command_line_app("msvc-link",
-					"\"%.*slink.exe\" %s \"%.*s.res\" -OUT:\"%.*s.%s\" %s "
+					"\"%.*slink.exe\" %s \"%.*s\" -OUT:\"%.*s\" %s "
 					"/nologo /incremental:no /opt:ref /subsystem:%s "
 					" %.*s "
 					" %.*s "
 					" %s "
 					"",
-					LIT(find_result.vs_exe_path), object_files, LIT(output_base), LIT(output_base), output_ext,
+					LIT(vs_exe_path), object_files, LIT(res_path), LIT(output_filename),
 					link_settings,
 					subsystem_str,
 					LIT(build_context.link_flags),
@@ -329,13 +312,13 @@ i32 linker_stage(lbGenerator *gen) {
 				  );
 			} else {
 				result = system_exec_command_line_app("msvc-link",
-					"\"%.*slink.exe\" %s -OUT:\"%.*s.%s\" %s "
+					"\"%.*slink.exe\" %s -OUT:\"%.*s\" %s "
 					"/nologo /incremental:no /opt:ref /subsystem:%s "
 					" %.*s "
 					" %.*s "
 					" %s "
 					"",
-					LIT(find_result.vs_exe_path), object_files, LIT(output_base), output_ext,
+					LIT(vs_exe_path), object_files, LIT(output_filename),
 					link_settings,
 					subsystem_str,
 					LIT(build_context.link_flags),
@@ -350,13 +333,13 @@ i32 linker_stage(lbGenerator *gen) {
 
 		} else { // lld
 			result = system_exec_command_line_app("msvc-lld-link",
-				"\"%.*s\\bin\\lld-link\" %s -OUT:\"%.*s.%s\" %s "
+				"\"%.*s\\bin\\lld-link\" %s -OUT:\"%.*s\" %s "
 				"/nologo /incremental:no /opt:ref /subsystem:%s "
 				" %.*s "
 				" %.*s "
 				" %s "
 				"",
-				LIT(build_context.ODIN_ROOT), object_files, LIT(output_base),output_ext,
+				LIT(build_context.ODIN_ROOT), object_files, LIT(output_filename),
 				link_settings,
 				subsystem_str,
 				LIT(build_context.link_flags),
@@ -415,7 +398,7 @@ i32 linker_stage(lbGenerator *gen) {
 				} else if (string_ends_with(lib, str_lit(".so"))) {
 					// dynamic lib, relative path to executable
 					// NOTE(vassvik): it is the user's responsibility to make sure the shared library files are visible
-					//                at runtimeto the executable
+					//                at runtime to the executable
 					lib_str = gb_string_append_fmt(lib_str, " -l:\"%s/%.*s\" ", cwd, LIT(lib));
 				} else {
 					// dynamic or static system lib, just link regularly searching system library paths
@@ -431,9 +414,6 @@ i32 linker_stage(lbGenerator *gen) {
 			object_files = gb_string_append_fmt(object_files, "\"%.*s\" ", LIT(object_path));
 		}
 
-		// Unlike the Win32 linker code, the output_ext includes the dot, because
-		// typically executable files on *NIX systems don't have extensions.
-		String output_ext = {};
 		gbString link_settings = gb_string_make_reserve(heap_allocator(), 32);
 
 		if (build_context.no_crt) {
@@ -461,26 +441,12 @@ i32 linker_stage(lbGenerator *gen) {
 			// correctly this way since all the other dependencies provided implicitly
 			// by the compiler frontend are still needed and most of the command
 			// line arguments prepared previously are incompatible with ld.
-			//
-			// Shared libraries are .dylib on MacOS and .so on Linux.
-			if (build_context.metrics.os == TargetOs_darwin) {
-				output_ext = STR_LIT(".dylib");
-			} else {
-				output_ext = STR_LIT(".so");
-			}
 			link_settings = gb_string_appendc(link_settings, "-Wl,-init,'_odin_entry_point' ");
 			link_settings = gb_string_appendc(link_settings, "-Wl,-fini,'_odin_exit_point' ");
 		} else if (build_context.metrics.os != TargetOs_openbsd) {
 			// OpenBSD defaults to PIE executable. do not pass -no-pie for it.
 			link_settings = gb_string_appendc(link_settings, "-no-pie ");
 		}
-		if (build_context.out_filepath.len > 0) {
-			//NOTE(thebirk): We have a custom -out arguments, so we should use the extension from that
-			isize pos = string_extension_position(build_context.out_filepath);
-			if (pos > 0) {
-				output_ext = substring(build_context.out_filepath, pos, build_context.out_filepath.len);
-			}
-		}
 
 		gbString platform_lib_str = gb_string_make(heap_allocator(), "");
 		defer (gb_string_free(platform_lib_str));
@@ -507,7 +473,7 @@ i32 linker_stage(lbGenerator *gen) {
 		defer (gb_string_free(link_command_line));
 
 		link_command_line = gb_string_appendc(link_command_line, object_files);
-		link_command_line = gb_string_append_fmt(link_command_line, " -o \"%.*s%.*s\" ", LIT(output_base), LIT(output_ext));
+		link_command_line = gb_string_append_fmt(link_command_line, " -o \"%.*s\" ", LIT(output_filename));
 		link_command_line = gb_string_append_fmt(link_command_line, " %s ", platform_lib_str);
 		link_command_line = gb_string_append_fmt(link_command_line, " %s ", lib_str);
 		link_command_line = gb_string_append_fmt(link_command_line, " %.*s ", LIT(build_context.link_flags));
@@ -524,9 +490,7 @@ i32 linker_stage(lbGenerator *gen) {
 		if (build_context.ODIN_DEBUG) {
 			// NOTE: macOS links DWARF symbols dynamically. Dsymutil will map the stubs in the exe
 			// to the symbols in the object file
-			result = system_exec_command_line_app("dsymutil",
-				"dsymutil %.*s%.*s", LIT(output_base), LIT(output_ext)
-			);
+			result = system_exec_command_line_app("dsymutil", "dsymutil %.*s", LIT(output_filename));
 
 			if (result) {
 				return result;
@@ -1526,6 +1490,10 @@ bool parse_build_flags(Array<String> args) {
 									gb_printf_err("Invalid -resource path %.*s, missing .rc\n", LIT(path));
 									bad_flags = true;
 									break;
+								} else if (!gb_file_exists((const char *)path.text)) {
+									gb_printf_err("Invalid -resource path %.*s, file does not exist.\n", LIT(path));
+									bad_flags = true;
+									break;
 								}
 								build_context.resource_filepath = substring(path, 0, string_extension_position(path));
 								build_context.has_resource = true;
@@ -1540,6 +1508,11 @@ bool parse_build_flags(Array<String> args) {
 							String path = value.value_string;
 							path = string_trim_whitespace(path);
 							if (is_build_flag_path_valid(path)) {
+								if (path_is_directory(path)) {
+									gb_printf_err("Invalid -pdb-name path. %.*s, is a directory.\n", LIT(path));
+									bad_flags = true;
+									break;									
+								}
 								// #if defined(GB_SYSTEM_WINDOWS)
 								// 	String ext = path_extension(path);
 								// 	if (ext != ".pdb") {
@@ -2666,6 +2639,8 @@ int main(int arg_count, char const **arg_ptr) {
 		return 1;
 	}
 
+	init_filename = copy_string(permanent_allocator(), init_filename);
+
 	if (init_filename == "-help" ||
 	    init_filename == "--help") {
 		build_context.show_help = true;
@@ -2688,6 +2663,12 @@ int main(int arg_count, char const **arg_ptr) {
 				gb_printf_err("Did you mean `%.*s %.*s %.*s -file`?\n", LIT(args[0]), LIT(command), LIT(init_filename));
 				gb_printf_err("The `-file` flag tells it to treat a file as a self-contained package.\n");
 				return 1;
+			} else {
+				String const ext = str_lit(".odin");
+				if (!string_ends_with(init_filename, ext)) {
+					gb_printf_err("Expected either a directory or a .odin file, got '%.*s'\n", LIT(init_filename));
+					return 1;
+				}
 			}
 		}
 	}
@@ -2709,13 +2690,24 @@ int main(int arg_count, char const **arg_ptr) {
 			get_fullpath_relative(heap_allocator(), odin_root_dir(), str_lit("shared")));
 	}
 
-
 	init_build_context(selected_target_metrics ? selected_target_metrics->metrics : nullptr);
 	// if (build_context.word_size == 4 && build_context.metrics.os != TargetOs_js) {
 	// 	print_usage_line(0, "%.*s 32-bit is not yet supported for this platform", LIT(args[0]));
 	// 	return 1;
 	// }
 
+	// Set and check build paths...
+	if (!init_build_paths(init_filename)) {
+		return 1;
+	}
+
+	if (build_context.show_debug_messages) {
+		for_array(i, build_context.build_paths) {
+			String build_path = path_to_string(heap_allocator(), build_context.build_paths[i]);
+			debugf("build_paths[%ld]: %.*s\n", i, LIT(build_path));
+		}		
+	}
+
 	init_global_thread_pool();
 	defer (thread_pool_destroy(&global_thread_pool));
 
@@ -2732,6 +2724,8 @@ int main(int arg_count, char const **arg_ptr) {
 	}
 	defer (destroy_parser(parser));
 
+	// TODO(jeroen): Remove the `init_filename` param.
+	// Let's put that on `build_context.build_paths[0]` instead.
 	if (parse_packages(parser, init_filename) != ParseFile_None) {
 		return 1;
 	}
@@ -2810,16 +2804,14 @@ int main(int arg_count, char const **arg_ptr) {
 	}
 
 	if (run_output) {
+		String exe_name = path_to_string(heap_allocator(), build_context.build_paths[BuildPath_Output]);
+		defer (gb_free(heap_allocator(), exe_name.text));
+
 	#if defined(GB_SYSTEM_WINDOWS)
-		return system_exec_command_line_app("odin run", "%.*s.exe %.*s", LIT(gen->output_base), LIT(run_args_string));
+		return system_exec_command_line_app("odin run", "%.*s %.*s", LIT(exe_name), LIT(run_args_string));
 	#else
-		//NOTE(thebirk): This whole thing is a little leaky
-		String output_ext = {};
-		String complete_path = concatenate_strings(permanent_allocator(), gen->output_base, output_ext);
-		complete_path = path_to_full_path(permanent_allocator(), complete_path);
-		return system_exec_command_line_app("odin run", "\"%.*s\" %.*s", LIT(complete_path), LIT(run_args_string));
+		return system_exec_command_line_app("odin run", "\"%.*s\" %.*s", LIT(exe_name), LIT(run_args_string));
 	#endif
 	}
-
 	return 0;
 }
diff --git a/src/parser.cpp b/src/parser.cpp
index 767119aa8..df7f908a6 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -5751,7 +5751,7 @@ ParseFileError parse_packages(Parser *p, String init_filename) {
 			}
 		}
 	}
-	
+
 
 	{ // Add these packages serially and then process them parallel
 		mutex_lock(&p->wait_mutex);
diff --git a/src/path.cpp b/src/path.cpp
new file mode 100644
index 000000000..8d8e532b8
--- /dev/null
+++ b/src/path.cpp
@@ -0,0 +1,333 @@
+/*
+	Path handling utilities.
+*/
+
+#if defined(GB_SYSTEM_WINDOWS)
+	bool path_is_directory(String path) {
+		gbAllocator a = heap_allocator();
+		String16 wstr = string_to_string16(a, path);
+		defer (gb_free(a, wstr.text));
+
+		i32 attribs = GetFileAttributesW(wstr.text);
+		if (attribs < 0) return false;
+
+		return (attribs & FILE_ATTRIBUTE_DIRECTORY) != 0;
+	}
+
+#else
+	bool path_is_directory(String path) {
+		gbAllocator a = heap_allocator();
+		char *copy = cast(char *)copy_string(a, path).text;
+		defer (gb_free(a, copy));
+
+		struct stat s;
+		if (stat(copy, &s) == 0) {
+			return (s.st_mode & S_IFDIR) != 0;
+		}
+		return false;
+	}
+#endif
+
+
+String path_to_full_path(gbAllocator a, String path) {
+	gbAllocator ha = heap_allocator();
+	char *path_c = gb_alloc_str_len(ha, cast(char *)path.text, path.len);
+	defer (gb_free(ha, path_c));
+
+	char *fullpath = gb_path_get_full_name(a, path_c);
+	String res = string_trim_whitespace(make_string_c(fullpath));
+#if defined(GB_SYSTEM_WINDOWS)
+	for (isize i = 0; i < res.len; i++) {
+		if (res.text[i] == '\\') {
+			res.text[i] = '/';
+		}
+	}
+#endif
+	return copy_string(a, res);
+}
+
+struct Path {
+	String basename;
+	String name;
+	String ext;
+};
+
+// NOTE(Jeroen): Naively turns a Path into a string.
+String path_to_string(gbAllocator a, Path path) {
+	if (path.basename.len + path.name.len + path.ext.len == 0) {
+		return make_string(nullptr, 0);
+	}
+
+	isize len = path.basename.len + 1 + path.name.len + 1;
+	if (path.ext.len > 0) {
+		 len += path.ext.len + 1;
+	}
+
+	u8 *str = gb_alloc_array(a, u8, len);
+
+	isize i = 0;
+	gb_memmove(str+i, path.basename.text, path.basename.len); i += path.basename.len;
+	gb_memmove(str+i, "/", 1);                                i += 1;
+	gb_memmove(str+i, path.name.text,     path.name.len);     i += path.name.len;
+	if (path.ext.len > 0) {
+		gb_memmove(str+i, ".", 1);                            i += 1;
+		gb_memmove(str+i, path.ext.text,  path.ext.len);      i += path.ext.len;
+	}
+	str[i] = 0;
+
+	String res = make_string(str, i);
+	res        = string_trim_whitespace(res);
+	return res;
+}
+
+// NOTE(Jeroen): Naively turns a Path into a string, then normalizes it using `path_to_full_path`.
+String path_to_full_path(gbAllocator a, Path path) {
+	String temp = path_to_string(heap_allocator(), path);
+	defer (gb_free(heap_allocator(), temp.text));
+
+	return path_to_full_path(a, temp);
+}
+
+// NOTE(Jeroen): Takes a path like "odin" or "W:\Odin", turns it into a full path,
+// and then breaks it into its components to make a Path.
+Path path_from_string(gbAllocator a, String const &path) {
+	Path res = {};
+
+	if (path.len == 0) return res;
+
+	String fullpath = path_to_full_path(a, path);
+	defer (gb_free(heap_allocator(), fullpath.text));
+
+	res.basename     = directory_from_path(fullpath);
+	res.basename     = copy_string(a, res.basename);
+
+	if (string_ends_with(fullpath, '/')) {
+		// It's a directory. We don't need to tinker with the name and extension.
+		return res;
+	}
+
+	isize name_start = (res.basename.len > 0) ? res.basename.len + 1 : res.basename.len;
+	res.name         = substring(fullpath, name_start, fullpath.len);
+	res.name         = remove_extension_from_path(res.name);
+	res.name         = copy_string(a, res.name);
+
+	res.ext          = path_extension(fullpath, false); // false says not to include the dot.
+	res.ext          = copy_string(a, res.ext);
+	return res;
+}
+
+bool path_is_directory(Path path) {
+	String path_string = path_to_full_path(heap_allocator(), path);
+	defer (gb_free(heap_allocator(), path_string.text));
+
+	return path_is_directory(path_string);
+}
+
+struct FileInfo {
+	String name;
+	String fullpath;
+	i64    size;
+	bool   is_dir;
+};
+
+enum ReadDirectoryError {
+	ReadDirectory_None,
+
+	ReadDirectory_InvalidPath,
+	ReadDirectory_NotExists,
+	ReadDirectory_Permission,
+	ReadDirectory_NotDir,
+	ReadDirectory_Empty,
+	ReadDirectory_Unknown,
+
+	ReadDirectory_COUNT,
+};
+
+i64 get_file_size(String path) {
+	char *c_str = alloc_cstring(heap_allocator(), path);
+	defer (gb_free(heap_allocator(), c_str));
+
+	gbFile f = {};
+	gbFileError err = gb_file_open(&f, c_str);
+	defer (gb_file_close(&f));
+	if (err != gbFileError_None) {
+		return -1;
+	}
+	return gb_file_size(&f);
+}
+
+
+#if defined(GB_SYSTEM_WINDOWS)
+ReadDirectoryError read_directory(String path, Array<FileInfo> *fi) {
+	GB_ASSERT(fi != nullptr);
+
+	gbAllocator a = heap_allocator();
+
+	while (path.len > 0) {
+		Rune end = path[path.len-1];
+		if (end == '/') {
+			path.len -= 1;
+		} else if (end == '\\') {
+			path.len -= 1;
+		} else {
+			break;
+		}
+	}
+
+	if (path.len == 0) {
+		return ReadDirectory_InvalidPath;
+	}
+	{
+		char *c_str = alloc_cstring(a, path);
+		defer (gb_free(a, c_str));
+
+		gbFile f = {};
+		gbFileError file_err = gb_file_open(&f, c_str);
+		defer (gb_file_close(&f));
+
+		switch (file_err) {
+		case gbFileError_Invalid:    return ReadDirectory_InvalidPath;
+		case gbFileError_NotExists:  return ReadDirectory_NotExists;
+		// case gbFileError_Permission: return ReadDirectory_Permission;
+		}
+	}
+
+	if (!path_is_directory(path)) {
+		return ReadDirectory_NotDir;
+	}
+
+
+	char *new_path = gb_alloc_array(a, char, path.len+3);
+	defer (gb_free(a, new_path));
+
+	gb_memmove(new_path, path.text, path.len);
+	gb_memmove(new_path+path.len, "/*", 2);
+	new_path[path.len+2] = 0;
+
+	String np = make_string(cast(u8 *)new_path, path.len+2);
+	String16 wstr = string_to_string16(a, np);
+	defer (gb_free(a, wstr.text));
+
+	WIN32_FIND_DATAW file_data = {};
+	HANDLE find_file = FindFirstFileW(wstr.text, &file_data);
+	if (find_file == INVALID_HANDLE_VALUE) {
+		return ReadDirectory_Unknown;
+	}
+	defer (FindClose(find_file));
+
+	array_init(fi, a, 0, 100);
+
+	do {
+		wchar_t *filename_w = file_data.cFileName;
+		i64 size = cast(i64)file_data.nFileSizeLow;
+		size |= (cast(i64)file_data.nFileSizeHigh) << 32;
+		String name = string16_to_string(a, make_string16_c(filename_w));
+		if (name == "." || name == "..") {
+			gb_free(a, name.text);
+			continue;
+		}
+
+		String filepath = {};
+		filepath.len = path.len+1+name.len;
+		filepath.text = gb_alloc_array(a, u8, filepath.len+1);
+		defer (gb_free(a, filepath.text));
+		gb_memmove(filepath.text, path.text, path.len);
+		gb_memmove(filepath.text+path.len, "/", 1);
+		gb_memmove(filepath.text+path.len+1, name.text, name.len);
+
+		FileInfo info = {};
+		info.name = name;
+		info.fullpath = path_to_full_path(a, filepath);
+		info.size = size;
+		info.is_dir = (file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
+		array_add(fi, info);
+	} while (FindNextFileW(find_file, &file_data));
+
+	if (fi->count == 0) {
+		return ReadDirectory_Empty;
+	}
+
+	return ReadDirectory_None;
+}
+#elif defined(GB_SYSTEM_LINUX) || defined(GB_SYSTEM_OSX) || defined(GB_SYSTEM_FREEBSD) || defined(GB_SYSTEM_OPENBSD)
+
+#include <dirent.h>
+
+ReadDirectoryError read_directory(String path, Array<FileInfo> *fi) {
+	GB_ASSERT(fi != nullptr);
+
+	gbAllocator a = heap_allocator();
+
+	char *c_path = alloc_cstring(a, path);
+	defer (gb_free(a, c_path));
+
+	DIR *dir = opendir(c_path);
+	if (!dir) {
+		switch (errno) {
+		case ENOENT:
+			return ReadDirectory_NotExists;
+		case EACCES:
+			return ReadDirectory_Permission;
+		case ENOTDIR:
+			return ReadDirectory_NotDir;
+		default:
+			// ENOMEM: out of memory
+			// EMFILE: per-process limit on open fds reached
+			// ENFILE: system-wide limit on total open files reached
+			return ReadDirectory_Unknown;
+		}
+		GB_PANIC("unreachable");
+	}
+
+	array_init(fi, a, 0, 100);
+
+	for (;;) {
+		struct dirent *entry = readdir(dir);
+		if (entry == nullptr) {
+			break;
+		}
+
+		String name = make_string_c(entry->d_name);
+		if (name == "." || name == "..") {
+			continue;
+		}
+
+		String filepath = {};
+		filepath.len = path.len+1+name.len;
+		filepath.text = gb_alloc_array(a, u8, filepath.len+1);
+		defer (gb_free(a, filepath.text));
+		gb_memmove(filepath.text, path.text, path.len);
+		gb_memmove(filepath.text+path.len, "/", 1);
+		gb_memmove(filepath.text+path.len+1, name.text, name.len);
+		filepath.text[filepath.len] = 0;
+
+
+		struct stat dir_stat = {};
+
+		if (stat((char *)filepath.text, &dir_stat)) {
+			continue;
+		}
+
+		if (S_ISDIR(dir_stat.st_mode)) {
+			continue;
+		}
+
+		i64 size = dir_stat.st_size;
+
+		FileInfo info = {};
+		info.name = name;
+		info.fullpath = path_to_full_path(a, filepath);
+		info.size = size;
+		array_add(fi, info);
+	}
+
+	if (fi->count == 0) {
+		return ReadDirectory_Empty;
+	}
+
+	return ReadDirectory_None;
+}
+#else
+#error Implement read_directory
+#endif
+
diff --git a/src/string.cpp b/src/string.cpp
index d3dbc6904..3515df48e 100644
--- a/src/string.cpp
+++ b/src/string.cpp
@@ -245,15 +245,14 @@ gb_inline isize string_extension_position(String const &str) {
 	return dot_pos;
 }
 
-String path_extension(String const &str) {
+String path_extension(String const &str, bool include_dot = true) {
 	isize pos = string_extension_position(str);
 	if (pos < 0) {
 		return make_string(nullptr, 0);
 	}
-	return substring(str, pos, str.len);
+	return substring(str, include_dot ? pos : pos + 1, str.len);
 }
 
-
 String string_trim_whitespace(String str) {
 	while (str.len > 0 && rune_is_whitespace(str[str.len-1])) {
 		str.len--;
@@ -328,7 +327,10 @@ String directory_from_path(String const &s) {
 			break;
 		}
 	}
-	return substring(s, 0, i);
+	if (i >= 0) {
+		return substring(s, 0, i);	
+	}
+	return substring(s, 0, 0);
 }
 
 String concatenate_strings(gbAllocator a, String const &x, String const &y) {
diff --git a/tests/core/build.bat b/tests/core/build.bat
index 2f9ba672e..1973c22aa 100644
--- a/tests/core/build.bat
+++ b/tests/core/build.bat
@@ -5,61 +5,61 @@ python3 download_assets.py
 echo ---
 echo Running core:image tests
 echo ---
-%PATH_TO_ODIN% run image    %COMMON%
+%PATH_TO_ODIN% run image    %COMMON% -out:test_image
 
 echo ---
 echo Running core:compress tests
 echo ---
-%PATH_TO_ODIN% run compress %COMMON%
+%PATH_TO_ODIN% run compress %COMMON% -out:test_compress
 
 echo ---
 echo Running core:strings tests
 echo ---
-%PATH_TO_ODIN% run strings %COMMON%
+%PATH_TO_ODIN% run strings %COMMON% -out:test_strings
 
 echo ---
 echo Running core:hash tests
 echo ---
-%PATH_TO_ODIN% run hash %COMMON% -o:size
+%PATH_TO_ODIN% run hash %COMMON% -o:size -out:test_hash
 
 echo ---
 echo Running core:odin tests
 echo ---
-%PATH_TO_ODIN% run odin %COMMON% -o:size
+%PATH_TO_ODIN% run odin %COMMON% -o:size -out:test_odin
 
 echo ---
 echo Running core:crypto hash tests
 echo ---
-%PATH_TO_ODIN% run crypto %COMMON%
+%PATH_TO_ODIN% run crypto %COMMON% -out:test_crypto
 
 echo ---
 echo Running core:encoding tests
 echo ---
-%PATH_TO_ODIN% run encoding/hxa %COMMON%
-%PATH_TO_ODIN% run encoding/json %COMMON%
-%PATH_TO_ODIN% run encoding/varint %COMMON%
+%PATH_TO_ODIN% run encoding/hxa    %COMMON% -out:test_hxa
+%PATH_TO_ODIN% run encoding/json   %COMMON% -out:test_json
+%PATH_TO_ODIN% run encoding/varint %COMMON% -out:test_varint
 
 echo ---
 echo Running core:math/noise tests
 echo ---
-%PATH_TO_ODIN% run math/noise %COMMON%
+%PATH_TO_ODIN% run math/noise      %COMMON% -out:test_noise
 
 echo ---
 echo Running core:math tests
 echo ---
-%PATH_TO_ODIN% run math %COMMON%
+%PATH_TO_ODIN% run math %COMMON% -out:test_math
 
 echo ---
 echo Running core:math/linalg/glsl tests
 echo ---
-%PATH_TO_ODIN% run math/linalg/glsl %COMMON%
+%PATH_TO_ODIN% run math/linalg/glsl %COMMON% -out:test_glsl
 
 echo ---
 echo Running core:path/filepath tests
 echo ---
-%PATH_TO_ODIN% run path/filepath %COMMON%
+%PATH_TO_ODIN% run path/filepath %COMMON% -out:test_filepath
 
 echo ---
 echo Running core:reflect tests
 echo ---
-%PATH_TO_ODIN% run reflect %COMMON%
+%PATH_TO_ODIN% run reflect %COMMON% -out:test_reflect
diff --git a/tests/core/math/big/build.bat b/tests/core/math/big/build.bat
index 16bdbc8ca..ad199d775 100644
--- a/tests/core/math/big/build.bat
+++ b/tests/core/math/big/build.bat
@@ -4,7 +4,7 @@ set PATH_TO_ODIN==..\..\..\..\odin
 set TEST_ARGS=-fast-tests
 set TEST_ARGS=-no-random
 set TEST_ARGS=
-set OUT_NAME=math_big_test_library
+set OUT_NAME=math_big_test_library.dll
 set COMMON=-build-mode:shared -show-timings -no-bounds-check -define:MATH_BIG_EXE=false -vet -strict-style
 echo ---
 echo Running core:math/big tests
diff --git a/tests/issues/run.sh b/tests/issues/run.sh
index 117a9a5f1..91ec99e05 100755
--- a/tests/issues/run.sh
+++ b/tests/issues/run.sh
@@ -8,10 +8,10 @@ COMMON="-collection:tests=tests -out:tests/issues/build/test_issue"
 set -x
 
 ./odin build tests/issues/test_issue_829.odin $COMMON -file
-tests/issues/build/test_issue
+tests/issues/build/test_issue.bin
 
 ./odin build tests/issues/test_issue_1592.odin $COMMON -file
-tests/issues/build/test_issue
+tests/issues/build/test_issue.bin
 
 set +x
 
-- 
cgit v1.2.3