From e4bf5476c3cc218b1265b2cb90c3b4fe3c9d3df8 Mon Sep 17 00:00:00 2001
From: ske <contact@ske.land>
Date: Tue, 30 Dec 2025 22:08:40 -0300
Subject: Fix literal endianness (fix #6068)

---
 src/llvm_backend_const.cpp        | 23 +++++++---
 tests/issues/run.bat              |  1 +
 tests/issues/run.sh               |  1 +
 tests/issues/test_issue_6068.odin | 92 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 112 insertions(+), 5 deletions(-)
 create mode 100644 tests/issues/test_issue_6068.odin

diff --git a/src/llvm_backend_const.cpp b/src/llvm_backend_const.cpp
index 22e124792..9c407be00 100644
--- a/src/llvm_backend_const.cpp
+++ b/src/llvm_backend_const.cpp
@@ -498,6 +498,13 @@ gb_internal LLVMValueRef lb_big_int_to_llvm(lbModule *m, Type *original_type, Bi
 	if (big_int_is_zero(a)) {
 		return LLVMConstNull(lb_type(m, original_type));
 	}
+	
+	BigInt val = {};
+	big_int_init(&val, a);
+
+	if (big_int_is_neg(&val)) {
+		mp_incr(&val);
+	}
 
 	size_t sz = cast(size_t)type_size_of(original_type);
 	u64 rop64[4] = {}; // 2 u64 is the maximum we will ever need, so doubling it will be fine :P
@@ -509,7 +516,7 @@ gb_internal LLVMValueRef lb_big_int_to_llvm(lbModule *m, Type *original_type, Bi
 	size_t nails = 0;
 	mp_endian endian = MP_LITTLE_ENDIAN;
 
-	max_count = mp_pack_count(a, nails, size);
+	max_count = mp_pack_count(&val, nails, size);
 	if (sz < max_count) {
 		debug_print_big_int(a);
 		gb_printf_err("%s -> %tu\n", type_to_string(original_type), sz);
@@ -520,7 +527,7 @@ gb_internal LLVMValueRef lb_big_int_to_llvm(lbModule *m, Type *original_type, Bi
 	mp_err err = mp_pack(rop, sz, &written,
 	                     MP_LSB_FIRST,
 	                     size, endian, nails,
-	                     a);
+	                     &val);
 	GB_ASSERT(err == MP_OKAY);
 
 	if (!is_type_endian_little(original_type)) {
@@ -531,12 +538,18 @@ gb_internal LLVMValueRef lb_big_int_to_llvm(lbModule *m, Type *original_type, Bi
 		}
 	}
 
+	if (big_int_is_neg(a)) {
+		// sizeof intead of sz for sign extend to work properly
+		for (size_t i = 0; i < sizeof rop64; i++) {
+			rop[i] = ~rop[i];
+		}
+	} 
+
+	big_int_dealloc(&val);
+
 	GB_ASSERT(!is_type_array(original_type));
 
 	LLVMValueRef value = LLVMConstIntOfArbitraryPrecision(lb_type(m, original_type), cast(unsigned)((sz+7)/8), cast(u64 *)rop);
-	if (big_int_is_neg(a)) {
-		value = LLVMConstNeg(value);
-	}
 
 	return value;
 }
diff --git a/tests/issues/run.bat b/tests/issues/run.bat
index bbd7cbc90..0ceaf554c 100644
--- a/tests/issues/run.bat
+++ b/tests/issues/run.bat
@@ -26,6 +26,7 @@ set COMMON=-define:ODIN_TEST_FANCY=false -file -vet -strict-style -ignore-unused
 ..\..\..\odin build ..\test_issue_5097-2.odin %COMMON% || exit /b
 ..\..\..\odin build ..\test_issue_5265.odin %COMMON% || exit /b
 ..\..\..\odin test ..\test_issue_5699.odin %COMMON%  || exit /b
+..\..\..\odin test ..\test_issue_6068.odin %COMMON%  || exit /b
 
 @echo off
 
diff --git a/tests/issues/run.sh b/tests/issues/run.sh
index a9a4bb88d..ce02ba20a 100755
--- a/tests/issues/run.sh
+++ b/tests/issues/run.sh
@@ -33,6 +33,7 @@ $ODIN build ../test_issue_5097.odin $COMMON
 $ODIN build ../test_issue_5097-2.odin $COMMON
 $ODIN build ../test_issue_5265.odin $COMMON
 $ODIN test ../test_issue_5699.odin $COMMON
+$ODIN test ../test_issue_6068.odin $COMMON
 
 set +x
 
diff --git a/tests/issues/test_issue_6068.odin b/tests/issues/test_issue_6068.odin
new file mode 100644
index 000000000..011c95442
--- /dev/null
+++ b/tests/issues/test_issue_6068.odin
@@ -0,0 +1,92 @@
+// Tests issue #6068 https://github.com/odin-lang/Odin/issues/6068
+package test_issues
+
+import "core:testing"
+
+@test
+test_issue_6068 :: proc(t: ^testing.T) {
+	{
+		check_be : i128be = -1
+		check_le : i128le = -1
+		value := -1
+		reverse := i128be(value)
+
+		// test variable
+		testing.expect(t, i128be(value) == check_be)
+		testing.expect(t, i128be(-1) == check_be)
+		testing.expect(t, cast(i128be)value == check_be)
+		testing.expect(t, cast(i128be)-1 == check_be)
+		testing.expect(t, i128be(int(-1)) == check_be)
+		testing.expect(t, cast(i128be)int(-1) == check_be)
+		testing.expect(t, i128le(value) == check_le)
+		testing.expect(t, i128le(-1) == check_le)
+		testing.expect(t, cast(i128le)value == check_le)
+		testing.expect(t, cast(i128le)-1 == check_le)
+		testing.expect(t, i128le(int(-1)) == check_le)
+		testing.expect(t, cast(i128le)int(-1) == check_le)
+		testing.expect(t, i128le(reverse) == check_le)
+		testing.expect(t, cast(i128le)reverse == check_le)
+
+		// test literal
+		testing.expect(t, i128be(value) == -1)
+		testing.expect(t, i128be(-1) == -1)
+		testing.expect(t, cast(i128be)value == -1)
+		testing.expect(t, cast(i128be)-1 == -1)
+		testing.expect(t, i128be(int(-1)) == -1)
+		testing.expect(t, cast(i128be)int(-1) == -1)
+		testing.expect(t, i128le(value) == -1)
+		testing.expect(t, i128le(-1) == -1)
+		testing.expect(t, cast(i128le)value == -1)
+		testing.expect(t, cast(i128le)-1 == -1)
+		testing.expect(t, i128le(int(-1)) == -1)
+		testing.expect(t, cast(i128le)int(-1) == -1)
+		testing.expect(t, i128le(reverse) == -1)
+		testing.expect(t, cast(i128le)reverse == -1)
+	}
+
+	// NOTE(ske): [llvm_backend_const.cpp:lb_big_int_to_llvm]
+	// floats behaved wonky when I tested because I forgot to sign extend whole
+	// rop so I added more tests here to be safe
+	{
+		check_be : f64be = -1.234
+		check_le : f64le = -1.234
+		value : f64 = -1.234
+		reverse := f64be(value)
+
+		// test variable
+		testing.expect(t, f64be(value) == check_be)
+		testing.expect(t, f64be(-1.234) == check_be)
+		testing.expect(t, cast(f64be)value == check_be)
+		testing.expect(t, cast(f64be)-1.234 == check_be)
+		testing.expect(t, f64be(int(-1.234)) == check_be)
+		testing.expect(t, cast(f64be)int(-1.234) == check_be)
+		testing.expect(t, f64le(value) == check_le)
+		testing.expect(t, f64le(-1.234) == check_le)
+		testing.expect(t, cast(f64le)value == check_le)
+		testing.expect(t, cast(f64le)-1.234 == check_le)
+		testing.expect(t, f64le(int(-1.234)) == check_le)
+		testing.expect(t, cast(f64le)int(-1.234) == check_le)
+		testing.expect(t, f64le(reverse) == check_le)
+		testing.expect(t, cast(f64le)reverse == check_le)
+
+		// test literal
+		testing.expect(t, f64be(value) == -1.234)
+		testing.expect(t, f64be(-1.234) == -1.234)
+		testing.expect(t, cast(f64be)value == -1.234)
+		testing.expect(t, cast(f64be)-1.234 == -1.234)
+		testing.expect(t, f64be(int(-1.234)) == -1.234)
+		testing.expect(t, cast(f64be)int(-1.234) == -1.234)
+		testing.expect(t, f64le(value) == -1.234)
+		testing.expect(t, f64le(-1.234) == -1.234)
+		testing.expect(t, cast(f64le)value == -1.234)
+		testing.expect(t, cast(f64le)-1.234 == -1.234)
+		testing.expect(t, f64le(int(-1.234)) == -1.234)
+		testing.expect(t, cast(f64le)int(-1.234) == -1.234)
+		testing.expect(t, f64le(reverse) == -1.234)
+		testing.expect(t, cast(f64le)reverse == -1.234)
+	}
+
+	testing.expect(t, i64be(-1) + i64be(1) == 0)
+	testing.expect(t, i64le(-1) + i64le(i64be(1)) == 0)
+	testing.expect(t, i64be(-7) * i64be(7) == -49)
+}
-- 
cgit v1.2.3