0.5.3: Single-module not respected. Fix issue with compiler defined types. Fix optimization levels for projects. Use GEP i8 on offsets. Optimize foreach on len 1 arrays. Move panic blocks last. Fix generic module wildcard imports. Deprecate init_temp / init_new. Fix issue with macro vaarg and untyped lists. Fix extern const globals.

test/test_suite/pointers/array_pointer_decay.c3t

@@ -32,47 +32,46 @@ entry:
   %xx = alloca ptr, align 8
   %yy = alloca ptr, align 8
   %zz = alloca ptr, align 8
-  %0 = getelementptr inbounds [3 x i32], ptr %x, i64 0, i64 0
-  store i32 0, ptr %0, align 4
-  %1 = getelementptr inbounds [3 x i32], ptr %x, i64 0, i64 1
-  store i32 0, ptr %1, align 4
-  %2 = getelementptr inbounds [3 x i32], ptr %x, i64 0, i64 2
-  store i32 0, ptr %2, align 4
+  store i32 0, ptr %x, align 4
+  %ptradd = getelementptr inbounds i8, ptr %x, i64 4
+  store i32 0, ptr %ptradd, align 4
+  %ptradd1 = getelementptr inbounds i8, ptr %x, i64 8
+  store i32 0, ptr %ptradd1, align 4
   store ptr %x, ptr %y, align 8
-  %3 = load ptr, ptr %y, align 8
-  store ptr %3, ptr %z, align 8
+  %0 = load ptr, ptr %y, align 8
+  store ptr %0, ptr %z, align 8
+  %1 = load ptr, ptr %y, align 8
+  %2 = insertvalue %"int[]" undef, ptr %1, 0
+  %3 = insertvalue %"int[]" %2, i64 3, 1
+  store %"int[]" %3, ptr %sub, align 8
   %4 = load ptr, ptr %y, align 8
-  %5 = insertvalue %"int[]" undef, ptr %4, 0
-  %6 = insertvalue %"int[]" %5, i64 3, 1
-  store %"int[]" %6, ptr %sub, align 8
-  %7 = load ptr, ptr %y, align 8
-  %ptroffset = getelementptr inbounds [3 x i32], ptr %7, i64 1
-  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %y1, ptr align 4 %ptroffset, i32 12, i1 false)
-  %8 = load ptr, ptr %z, align 8
-  %ptroffset1 = getelementptr inbounds i32, ptr %8, i64 1
-  %9 = load i32, ptr %ptroffset1, align 4
-  store i32 %9, ptr %z1, align 4
-  %ptroffset2 = getelementptr [3 x i32], ptr %x, i64 1
-  store ptr %ptroffset2, ptr %xx, align 8
-  %10 = load ptr, ptr %xx, align 8
-  store ptr %10, ptr %yy, align 8
-  %11 = load ptr, ptr %yy, align 8
-  %ptroffset3 = getelementptr [3 x i32], ptr %11, i64 -1
-  store ptr %ptroffset3, ptr %zz, align 8
-  %12 = load ptr, ptr %y, align 8
-  %13 = getelementptr inbounds [3 x i32], ptr %12, i64 0, i64 1
-  %14 = load ptr, ptr %y, align 8
-  %15 = load ptr, ptr %z, align 8
-  %16 = load ptr, ptr %zz, align 8
-  %17 = load ptr, ptr %xx, align 8
-  call void (ptr, ...) @printf(ptr @.str, ptr %14, ptr %15, ptr %16, ptr %13, ptr %17)
-  %18 = getelementptr inbounds [3 x i32], ptr %x, i64 0, i64 1
-  store i32 123, ptr %18, align 4
-  %19 = getelementptr inbounds [3 x i32], ptr %x, i64 0, i64 1
-  %20 = load ptr, ptr %z, align 8
-  %ptroffset4 = getelementptr inbounds i32, ptr %20, i64 1
-  %21 = load i32, ptr %19, align 4
-  %22 = load i32, ptr %ptroffset4, align 4
-  call void (ptr, ...) @printf(ptr @.str.1, i32 %21, i32 %22)
+  %ptradd2 = getelementptr inbounds i8, ptr %4, i64 12
+  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %y1, ptr align 4 %ptradd2, i32 12, i1 false)
+  %5 = load ptr, ptr %z, align 8
+  %ptradd3 = getelementptr inbounds i8, ptr %5, i64 4
+  %6 = load i32, ptr %ptradd3, align 4
+  store i32 %6, ptr %z1, align 4
+  %ptradd_any = getelementptr i8, ptr %x, i64 12
+  store ptr %ptradd_any, ptr %xx, align 8
+  %7 = load ptr, ptr %xx, align 8
+  store ptr %7, ptr %yy, align 8
+  %8 = load ptr, ptr %yy, align 8
+  %ptradd_any4 = getelementptr i8, ptr %8, i64 -12
+  store ptr %ptradd_any4, ptr %zz, align 8
+  %9 = load ptr, ptr %y, align 8
+  %ptradd5 = getelementptr inbounds i8, ptr %9, i64 4
+  %10 = load ptr, ptr %y, align 8
+  %11 = load ptr, ptr %z, align 8
+  %12 = load ptr, ptr %zz, align 8
+  %13 = load ptr, ptr %xx, align 8
+  call void (ptr, ...) @printf(ptr @.str, ptr %10, ptr %11, ptr %12, ptr %ptradd5, ptr %13)
+  %ptradd6 = getelementptr inbounds i8, ptr %x, i64 4
+  store i32 123, ptr %ptradd6, align 4
+  %ptradd7 = getelementptr inbounds i8, ptr %x, i64 4
+  %14 = load ptr, ptr %z, align 8
+  %ptradd8 = getelementptr inbounds i8, ptr %14, i64 4
+  %15 = load i32, ptr %ptradd7, align 4
+  %16 = load i32, ptr %ptradd8, align 4
+  call void (ptr, ...) @printf(ptr @.str.1, i32 %15, i32 %16)
   ret void
 }

test/test_suite/pointers/pointer_index.c3t

@@ -30,49 +30,47 @@ entry:
   %b = alloca i32, align 4
   %c = alloca i32, align 4
   %d = alloca i32, align 4
-  %ptroffset = getelementptr inbounds i32, ptr %0, i64 0
-  %1 = load i32, ptr %ptroffset, align 4
+  %1 = load i32, ptr %0, align 4
   store i32 %1, ptr %a, align 4
   %2 = load i32, ptr %0, align 4
   store i32 %2, ptr %b, align 4
-  %ptroffset1 = getelementptr inbounds i32, ptr %0, i64 1
-  %3 = load i32, ptr %ptroffset1, align 4
+  %ptradd = getelementptr inbounds i8, ptr %0, i64 4
+  %3 = load i32, ptr %ptradd, align 4
   store i32 %3, ptr %c, align 4
-  %ptroffset2 = getelementptr inbounds i32, ptr %0, i64 -1
-  %4 = load i32, ptr %ptroffset2, align 4
+  %ptradd1 = getelementptr inbounds i8, ptr %0, i64 -4
+  %4 = load i32, ptr %ptradd1, align 4
   store i32 %4, ptr %d, align 4
   ret void
 }
 
-
+; Function Attrs:
 define void @pointer_index.test2(ptr %0) #0 {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   %c = alloca i8, align 1
-  %ptroffset = getelementptr inbounds i8, ptr %0, i64 0
-  %1 = load i8, ptr %ptroffset, align 1
+  %1 = load i8, ptr %0, align 1
   store i8 %1, ptr %a, align 1
   %2 = load i8, ptr %0, align 1
   store i8 %2, ptr %b, align 1
-  %ptroffset1 = getelementptr inbounds i8, ptr %0, i64 1
-  %3 = load i8, ptr %ptroffset1, align 1
+  %ptradd = getelementptr inbounds i8, ptr %0, i64 1
+  %3 = load i8, ptr %ptradd, align 1
   store i8 %3, ptr %c, align 1
   ret void
 }
 
+; Function Attrs:
 define void @pointer_index.test3(ptr %0) #0 {
 entry:
   %a = alloca i64, align 8
   %b = alloca i64, align 8
   %c = alloca i64, align 8
-  %ptroffset = getelementptr inbounds i64, ptr %0, i64 0
-  %1 = load i64, ptr %ptroffset, align 8
+  %1 = load i64, ptr %0, align 8
   store i64 %1, ptr %a, align 8
   %2 = load i64, ptr %0, align 8
   store i64 %2, ptr %b, align 8
-  %ptroffset1 = getelementptr inbounds i64, ptr %0, i64 1
-  %3 = load i64, ptr %ptroffset1, align 8
+  %ptradd = getelementptr inbounds i8, ptr %0, i64 8
+  %3 = load i64, ptr %ptradd, align 8
   store i64 %3, ptr %c, align 8
   ret void
 }

test/test_suite/pointers/subarray_variant_to_ptr.c3t

@@ -36,34 +36,33 @@ entry:
   %z = alloca %"any*", align 8
   %w = alloca ptr, align 8
   store i64 %0, ptr %z, align 8
-  %ptroffset = getelementptr inbounds ptr, ptr %z, i64 1
-  store ptr %1, ptr %ptroffset, align 8
-  %2 = getelementptr inbounds %"any*", ptr %z, i32 0, i32 0
-  %3 = load ptr, ptr %2, align 8
-  store ptr %3, ptr %w, align 8
-  %4 = load ptr, ptr %w, align 8
-  %5 = load i32, ptr %4, align 4
-  call void (ptr, ...) @printf(ptr @.str, i32 %5)
+  %ptradd = getelementptr inbounds i8, ptr %z, i64 8
+  store ptr %1, ptr %ptradd, align 8
+  %2 = load ptr, ptr %z, align 8
+  store ptr %2, ptr %w, align 8
+  %3 = load ptr, ptr %w, align 8
+  %4 = load i32, ptr %3, align 4
+  call void (ptr, ...) @printf(ptr @.str, i32 %4)
   ret void
 }
 
-
+; Function Attrs:
 define void @foo.test2(ptr %0, i64 %1) #0 {
 entry:
   %z = alloca %"int[]", align 8
   %w = alloca ptr, align 8
   store ptr %0, ptr %z, align 8
-  %ptroffset = getelementptr inbounds i64, ptr %z, i64 1
-  store i64 %1, ptr %ptroffset, align 8
-  %2 = getelementptr inbounds %"int[]", ptr %z, i32 0, i32 0
-  %3 = load ptr, ptr %2, align 8
-  store ptr %3, ptr %w, align 8
-  %4 = load ptr, ptr %w, align 8
-  %5 = load i32, ptr %4, align 4
-  call void (ptr, ...) @printf(ptr @.str.1, i32 %5)
+  %ptradd = getelementptr inbounds i8, ptr %z, i64 8
+  store i64 %1, ptr %ptradd, align 8
+  %2 = load ptr, ptr %z, align 8
+  store ptr %2, ptr %w, align 8
+  %3 = load ptr, ptr %w, align 8
+  %4 = load i32, ptr %3, align 4
+  call void (ptr, ...) @printf(ptr @.str.1, i32 %4)
   ret void
 }
 
+; Function Attrs:
 define void @foo.main() #0 {
 entry:
   %x = alloca i32, align 4
@@ -76,14 +75,12 @@ entry:
   %0 = insertvalue %"any*" undef, ptr %x, 0
   %1 = insertvalue %"any*" %0, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   store %"any*" %1, ptr %taddr, align 8
-  %2 = getelementptr inbounds { i64, ptr }, ptr %taddr, i32 0, i32 0
-  %lo = load i64, ptr %2, align 8
-  %3 = getelementptr inbounds { i64, ptr }, ptr %taddr, i32 0, i32 1
-  %hi = load ptr, ptr %3, align 8
+  %lo = load i64, ptr %taddr, align 8
+  %ptradd = getelementptr inbounds i8, ptr %taddr, i64 8
+  %hi = load ptr, ptr %ptradd, align 8
   call void @foo.test1(i64 %lo, ptr %hi)
-  %4 = getelementptr inbounds [2 x i32], ptr %w, i64 0, i64 0
-  %5 = insertvalue %"int[]" undef, ptr %4, 0
-  %6 = insertvalue %"int[]" %5, i64 2, 1
-  call void @foo.test2(ptr %4, i64 2)
+  %2 = insertvalue %"int[]" undef, ptr %w, 0
+  %3 = insertvalue %"int[]" %2, i64 2, 1
+  call void @foo.test2(ptr %w, i64 2)
   ret void
 }