Fix x86_64 ABI small issue (#1174)

* Fix x86_64 ABI small issue Update tests for fix.

---------

Co-authored-by: Christoffer Lerno <christoffer@aegik.com>

src/compiler/abi/c_abi_x64.c

@@ -462,7 +462,7 @@ bool x64_bits_contain_no_user_data(Type *type, unsigned start, unsigned end)
 		{
 			Decl *member = members[i];
 			unsigned offset = member->offset;
-			if (offset > end) break;
+			if (offset >= end) break;
 			unsigned field_start = offset < start ? start - offset : 0;
 			if (!x64_bits_contain_no_user_data(member->type, field_start, end - offset)) return false;
 		}

test/test_suite/abi/darwinx64_2.c3t

@@ -152,27 +152,21 @@ define void @test.f12_1(i32 %0)
 define void @test.f13(ptr noalias sret(%St13_0) align 8 %0, i32 %1, i32 %2, i32 %3, i32 %4, ptr byval(%St13_1) align 8 %5, i32 %6) #0 {
 define void @test.f14(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, i8 signext %6) #0 {
 define void @test.f15(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, ptr %6)
-
 define void @test.f16(float %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, float %8)
-
 define void @test.fl18(i32 %0, i32 %1)
 define void @test.f20(ptr byval(%St20) align 32 %0)
-define ptr @test.f21(i64 %0, ptr %1)
-
+define ptr @test.f21(i32 %0, ptr %1)
 define void @test.f22(i64 %0, i64 %1, i64 %2, i64 %3)
 entry:
   %x = alloca %St22s, align 16
   %y = alloca %St22s, align 16
-
 define void @test.f23(i32 %0, i64 %1, i32 %2)
 define { i64, i32 } @test.f24(ptr %0, ptr %1)
-
 define <4 x float> @test.f25(<4 x float> %0) #0 {
 entry:
   %fadd = fadd <4 x float> %0, %0
   ret <4 x float> %fadd
 }
-
 define { ptr, ptr } @test.f26(ptr %0)
 define <4 x float> @test.f27(<4 x float> %0)
 define <8 x float> @test.f27a(<8 x float> %0)

test/test_suite/stdlib/map_linux.c3t

@@ -140,20 +140,20 @@ entry:
   store %"any*" %2, ptr %varargslots, align 16
   %3 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 12, ptr %varargslots, i64 1)
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal, ptr align 8 @.__const, i32 16, i1 false)
-  %lo1 = load i64, ptr %literal, align 8
+  %lo1 = load i32, ptr %literal, align 8
   %ptradd2 = getelementptr inbounds i8, ptr %literal, i64 8
   %hi3 = load ptr, ptr %ptradd2, align 8
-  %4 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i64 %lo1, ptr %hi3)
+  %4 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo1, ptr %hi3)
   %ptradd5 = getelementptr inbounds i8, ptr %map, i64 32
   %5 = insertvalue %"any*" undef, ptr %ptradd5, 0
   %6 = insertvalue %"any*" %5, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   store %"any*" %6, ptr %varargslots4, align 16
   %7 = call i64 @std.io.printfn(ptr %retparam6, ptr @.str.1, i64 12, ptr %varargslots4, i64 1)
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal7, ptr align 8 @.__const.2, i32 16, i1 false)
-  %lo8 = load i64, ptr %literal7, align 8
+  %lo8 = load i32, ptr %literal7, align 8
   %ptradd9 = getelementptr inbounds i8, ptr %literal7, i64 8
   %hi10 = load ptr, ptr %ptradd9, align 8
-  %8 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i64 %lo8, ptr %hi10)
+  %8 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo8, ptr %hi10)
   %ptradd12 = getelementptr inbounds i8, ptr %map, i64 32
   %9 = insertvalue %"any*" undef, ptr %ptradd12, 0
   %10 = insertvalue %"any*" %9, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
@@ -187,10 +187,10 @@ after_check18:                                    ; preds = %entry, %after_check
   store %"any*" %24, ptr %varargslots23, align 16
   %25 = call i64 @std.io.printfn(ptr %retparam25, ptr @.str.6, i64 9, ptr %varargslots23, i64 1)
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal28, ptr align 8 @.__const.7, i32 16, i1 false)
-  %lo29 = load i64, ptr %literal28, align 8
+  %lo29 = load i32, ptr %literal28, align 8
   %ptradd30 = getelementptr inbounds i8, ptr %literal28, i64 8
   %hi31 = load ptr, ptr %ptradd30, align 8
-  %26 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i64 %lo29, ptr %hi31)
+  %26 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i32 %lo29, ptr %hi31)
   %lo33 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
   %hi34 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
   %27 = call { ptr, i64 } @"std.collections.map$int$test.Foo$.HashMap.value_new_list"(ptr %map, i64 %lo33, ptr %hi34)

test/test_suite/stdlib/map_macos.c3t

@@ -140,20 +140,20 @@ entry:
   store %"any*" %2, ptr %varargslots, align 16
   %3 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 12, ptr %varargslots, i64 1)
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal, ptr align 8 @.__const, i32 16, i1 false)
-  %lo1 = load i64, ptr %literal, align 8
+  %lo1 = load i32, ptr %literal, align 8
   %ptradd2 = getelementptr inbounds i8, ptr %literal, i64 8
   %hi3 = load ptr, ptr %ptradd2, align 8
-  %4 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i64 %lo1, ptr %hi3)
+  %4 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo1, ptr %hi3)
   %ptradd5 = getelementptr inbounds i8, ptr %map, i64 32
   %5 = insertvalue %"any*" undef, ptr %ptradd5, 0
   %6 = insertvalue %"any*" %5, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   store %"any*" %6, ptr %varargslots4, align 16
   %7 = call i64 @std.io.printfn(ptr %retparam6, ptr @.str.1, i64 12, ptr %varargslots4, i64 1)
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal7, ptr align 8 @.__const.2, i32 16, i1 false)
-  %lo8 = load i64, ptr %literal7, align 8
+  %lo8 = load i32, ptr %literal7, align 8
   %ptradd9 = getelementptr inbounds i8, ptr %literal7, i64 8
   %hi10 = load ptr, ptr %ptradd9, align 8
-  %8 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i64 %lo8, ptr %hi10)
+  %8 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo8, ptr %hi10)
   %ptradd12 = getelementptr inbounds i8, ptr %map, i64 32
   %9 = insertvalue %"any*" undef, ptr %ptradd12, 0
   %10 = insertvalue %"any*" %9, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
@@ -187,10 +187,10 @@ after_check18:                                    ; preds = %entry, %after_check
   store %"any*" %24, ptr %varargslots23, align 16
   %25 = call i64 @std.io.printfn(ptr %retparam25, ptr @.str.6, i64 9, ptr %varargslots23, i64 1)
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal28, ptr align 8 @.__const.7, i32 16, i1 false)
-  %lo29 = load i64, ptr %literal28, align 8
+  %lo29 = load i32, ptr %literal28, align 8
   %ptradd30 = getelementptr inbounds i8, ptr %literal28, i64 8
   %hi31 = load ptr, ptr %ptradd30, align 8
-  %26 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i64 %lo29, ptr %hi31)
+  %26 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i32 %lo29, ptr %hi31)
   %lo33 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
   %hi34 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
   %27 = call { ptr, i64 } @"std.collections.map$int$test.Foo$.HashMap.value_new_list"(ptr %map, i64 %lo33, ptr %hi34)