Update tests for LLVM 19

test/test_suite/arrays/global_init.c3t

@@ -26,10 +26,10 @@ fn void main() {
 @test.c = local_unnamed_addr global i32 0, align 4
 @test.d = local_unnamed_addr global i32 0, align 4
 @test.abc = local_unnamed_addr global [3 x i32] zeroinitializer, align 4
-@test.b = local_unnamed_addr global ptr getelementptr (i8, ptr @test.a, i64 28), align 8
+@test.b = local_unnamed_addr global ptr getelementptr
-@test.bf = local_unnamed_addr global ptr getelementptr (i8, ptr @test.abc, i64 16), align 8
+@test.bf = local_unnamed_addr global ptr getelementptr
 @test.bf2 = local_unnamed_addr global ptr getelementptr inbounds (i8, ptr @test.abc, i64 8), align 8
-@test.bf3 = local_unnamed_addr global ptr getelementptr (i8, ptr @test.abc, i64 16), align 8
+@test.bf3 = local_unnamed_addr global ptr getelementptr
 @.taddr.9 = private global i32 42, align 4
 @.taddr.10 = private global i8 99, align 1
 @.taddr.11 = private global %"char[]" { ptr @.str, i64 3 }, align 8
@@ -43,7 +43,7 @@ entry:
   %taddr = alloca i32, align 4
   %taddr1 = alloca i8, align 1
   %taddr3 = alloca %"char[]", align 8
-  store ptr getelementptr (i8, ptr @test.abc, i64 28), ptr %bf34, align 8
+  store ptr getelementptr (i8, ptr
   store i32 42, ptr %taddr, align 4
   %0 = insertvalue %any undef, ptr %taddr, 0
   %1 = insertvalue %any %0, i64 ptrtoint (ptr @"$ct.int" to i64), 1

test/test_suite/concurrency/atomic_load_store_debug.c3t

@@ -40,14 +40,14 @@ entry:
   %value6 = alloca i32, align 4
   %varargslots = alloca [1 x %any], align 16
   %retparam = alloca i64, align 8
-  call void @llvm.dbg.declare(metadata ptr %a, metadata !10, metadata !DIExpression()), !dbg !12
+    !12
   store i32 111, ptr %a, align 4, !dbg !13
-  call void @llvm.dbg.declare(metadata ptr %x, metadata !14, metadata !DIExpression()), !dbg !15
+    !15
   store ptr %a, ptr %x1, align 8
   %0 = load ptr, ptr %x1, align 8, !dbg !16
   %1 = load atomic i32, ptr %0 seq_cst, align 4, !dbg !16
   store i32 %1, ptr %x, align 4, !dbg !16
-  call void @llvm.dbg.declare(metadata ptr %y, metadata !20, metadata !DIExpression()), !dbg !21
+    !21
   store ptr %a, ptr %x2, align 8
   %2 = load ptr, ptr %x2, align 8, !dbg !22
   %3 = load atomic volatile i32, ptr %2 monotonic, align 4, !dbg !22
@@ -80,9 +80,9 @@ entry:
   %.anon2 = alloca i32, align 4
   %.anon3 = alloca ptr, align 8
   store i32 %0, ptr %.anon, align 4
-  call void @llvm.dbg.declare(metadata ptr %.anon, metadata !43, metadata !DIExpression()), !dbg !44
+    !44
   store ptr %1, ptr %.anon1, align 8
-  call void @llvm.dbg.declare(metadata ptr %.anon1, metadata !45, metadata !DIExpression()), !dbg !44
+    !44
   %2 = load i32, ptr %.anon, align 4
   store i32 %2, ptr %.anon2, align 4
   %3 = load ptr, ptr %.anon1, align 8
@@ -90,16 +90,14 @@ entry:
   call void @test.main(), !dbg !46
   ret i32 0, !dbg !49
 }
-
+e
-declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
-
-; Function Attrs:
 declare i64 @std.io.printfn(ptr, ptr, i64, ptr, i64) #0
 
-declare i1 @llvm.expect.i1(i1, i1) #2
+declare i1 @llvm.expect.i1(i1, i1)
 
 !llvm.module.flags = !{!0, !1, !2, !3}
 !llvm.dbg.cu = !{!4}
+
 !0 = !{i32 2, !"Dwarf Version", i32 4}
 !1 = !{i32 2, !"Debug Info Version", i32 3}
 !2 = !{i32 2, !"frame-pointer", i32 2}

test/test_suite/debug_symbols/ct_foreach.c3t

@@ -19,7 +19,7 @@ fn void main() {
 define void @test.foo() #0 !dbg !6 {
 entry:
   %values = alloca [1 x i32], align 4
-  call void @llvm.dbg.declare(metadata ptr %values, metadata !10, metadata !DIExpression()), !dbg !15
+    !15
   store i32 0, ptr %values, align 4, !dbg !15
   store i32 0, ptr %values, align 4, !dbg !16
   ret void, !dbg !16

test/test_suite/debug_symbols/defer_macro.c3t

@@ -139,8 +139,8 @@ entry:
   %a = alloca i32, align 4
   %a.f = alloca i64, align 8
   store i32 %0, ptr %x, align 4
-  call void @llvm.dbg.declare(metadata ptr %x, metadata !20, metadata !DIExpression()), !dbg !21
+   !21
-  call void @llvm.dbg.declare(metadata ptr %a, metadata !22, metadata !DIExpression()), !dbg !23
+   !23
   %1 = load i32, ptr %x, align 4, !dbg !24
   store i32 %1, ptr %a, align 4, !dbg !24
   store i64 0, ptr %a.f, align 8, !dbg !24
@@ -169,9 +169,9 @@ entry:
   store ptr %0, ptr %args, align 8
   %ptradd = getelementptr inbounds i8, ptr %args, i64 8
   store i64 %1, ptr %ptradd, align 8
-  call void @llvm.dbg.declare(metadata ptr %args, metadata !46, metadata !DIExpression()), !dbg !47
+    !47
-  call void @llvm.dbg.declare(metadata ptr %asdf, metadata !48, metadata !DIExpression()), !dbg !53
+    !53
-  %2 = call { i32, ptr } @attach.to_scope() #4, !dbg !54
+  %2 = call { i32, ptr } @attach.to_scope()
   store { i32, ptr } %2, ptr %result, align 8
   %lo = load i32, ptr %result, align 8, !dbg !55
   %ptradd1 = getelementptr inbounds i8, ptr %result, i64 8, !dbg !55
@@ -195,14 +195,14 @@ entry:
   store i32 %0, ptr %attach, align 8
   %ptradd = getelementptr inbounds i8, ptr %attach, i64 8
   store ptr %1, ptr %ptradd, align 8
-  call void @llvm.dbg.declare(metadata ptr %attach, metadata !66, metadata !DIExpression()), !dbg !67
+    !67
   store i64 %2, ptr %flags, align 8
-  call void @llvm.dbg.declare(metadata ptr %flags, metadata !68, metadata !DIExpression()), !dbg !69
+    !69
   store ptr %3, ptr %name, align 8
   %ptradd1 = getelementptr inbounds i8, ptr %name, i64 8
   store i64 %4, ptr %ptradd1, align 8
-  call void @llvm.dbg.declare(metadata ptr %name, metadata !70, metadata !DIExpression()), !dbg !71
+    !71
-  %5 = call ptr @std.core.mem.calloc(i64 8) #4, !dbg !72
+  %5 = call ptr @std.core.mem.calloc(i64 8)
   ret ptr %5, !dbg !72
 }
 
@@ -223,14 +223,14 @@ entry:
   %error_var5 = alloca i64, align 8
   %error_var11 = alloca i64, align 8
   store <4 x float> %0, ptr %color, align 16
-  call void @llvm.dbg.declare(metadata ptr %color, metadata !84, metadata !DIExpression()), !dbg !85
+    !85
   %1 = load <4 x float>, ptr %color, align 16
   store <4 x float> %1, ptr %x, align 16
   %2 = call ptr @std.io.stdout(), !dbg !86
   store ptr %2, ptr %out, align 8
   %3 = load <4 x float>, ptr %x, align 16
   store <4 x float> %3, ptr %x1, align 16
-  call void @llvm.dbg.declare(metadata ptr %len, metadata !90, metadata !DIExpression()), !dbg !92
+    !92
   %4 = load ptr, ptr %out, align 8
   store ptr %4, ptr %out2, align 8
   %5 = load <4 x float>, ptr %x1, align 16
@@ -316,23 +316,23 @@ entry:
   %scratch1 = alloca ptr, align 8
   %asdf = alloca ptr, align 8
   store %"Arena*[]" zeroinitializer, ptr %conflicts, align 8
-  call void @llvm.dbg.declare(metadata ptr %scratch, metadata !107, metadata !DIExpression()), !dbg !117
+    !117
   %lo = load ptr, ptr %conflicts, align 8, !dbg !119
   %ptradd = getelementptr inbounds i8, ptr %conflicts, i64 8, !dbg !119
   %hi = load i64, ptr %ptradd, align 8, !dbg !119
   %0 = call { ptr, i64 } @arena_scratch_begin(ptr %lo, i64 %hi), !dbg !120
   store { ptr, i64 } %0, ptr %result, align 8
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %scratch, ptr align 8 %result, i32 16, i1 false)
-  call void @llvm.dbg.declare(metadata ptr %scratch1, metadata !121, metadata !DIExpression()), !dbg !122
+    !122
   %1 = load ptr, ptr %scratch, align 8, !dbg !123
   store ptr %1, ptr %scratch1, align 8, !dbg !123
-  call void @llvm.dbg.declare(metadata ptr %asdf, metadata !125, metadata !DIExpression()), !dbg !127
+    !127
   store ptr null, ptr %asdf, align 8, !dbg !127
   %2 = load ptr, ptr %asdf, align 8, !dbg !128
   %lo2 = load ptr, ptr %scratch, align 8, !dbg !129
   %ptradd3 = getelementptr inbounds i8, ptr %scratch, i64 8, !dbg !129
   %hi4 = load i64, ptr %ptradd3, align 8, !dbg !129
-  call void @arena_scratch_end(ptr %lo2, i64 %hi4) #4, !dbg !131
+  call void @arena_scratch_end(ptr %lo2, i64 %hi4)
   ret ptr %2, !dbg !131
 }
 
@@ -369,19 +369,19 @@ entry:
   %len18 = alloca i64, align 8
   store ptr null, ptr %.cachedtype, align 8
   store i32 %0, ptr %.anon, align 4
-  call void @llvm.dbg.declare(metadata ptr %.anon, metadata !136, metadata !DIExpression()), !dbg !137
+    !137
   store ptr %1, ptr %.anon1, align 8
-  call void @llvm.dbg.declare(metadata ptr %.anon1, metadata !138, metadata !DIExpression()), !dbg !137
+    !137
   %2 = load i32, ptr %.anon, align 4
   store i32 %2, ptr %argc, align 4
   %3 = load ptr, ptr %.anon1, align 8
   store ptr %3, ptr %argv, align 8
-  call void @llvm.dbg.declare(metadata ptr %list, metadata !139, metadata !DIExpression()), !dbg !142
+    !142
   %4 = load i32, ptr %argc, align 4
   store i32 %4, ptr %argc2, align 4
   %5 = load ptr, ptr %argv, align 8
   store ptr %5, ptr %argv3, align 8
-  call void @llvm.dbg.declare(metadata ptr %list5, metadata !143, metadata !DIExpression()), !dbg !145
+    !145
   %6 = load i32, ptr %argc2, align 4, !dbg !147
   %sext = sext i32 %6 to i64, !dbg !147
   store i64 %sext, ptr %elements, align 8
@@ -473,7 +473,7 @@ panic_block:                                      ; preds = %assign_optional
 
 noerr_block:                                      ; preds = %expr_block.exit
   store %"char[][]" %28, ptr %list5, align 8, !dbg !151
-  call void @llvm.dbg.declare(metadata ptr %i, metadata !165, metadata !DIExpression()), !dbg !167
+    !167
   store i32 0, ptr %i, align 4, !dbg !168
   br label %loop.cond, !dbg !168
 
@@ -484,14 +484,14 @@ loop.cond:                                        ; preds = %loop.exit, %noerr_b
   br i1 %lt, label %loop.body, label %loop.exit26, !dbg !169
 
 loop.body:                                        ; preds = %loop.cond
-  call void @llvm.dbg.declare(metadata ptr %arg, metadata !171, metadata !DIExpression()), !dbg !173
+    !173
   %34 = load ptr, ptr %argv3, align 8, !dbg !174
   %35 = load i32, ptr %i, align 4, !dbg !175
   %sext14 = sext i32 %35 to i64, !dbg !175
   %ptroffset = getelementptr inbounds [8 x i8], ptr %34, i64 %sext14, !dbg !175
   %36 = load ptr, ptr %ptroffset, align 8, !dbg !175
   store ptr %36, ptr %arg, align 8, !dbg !175
-  call void @llvm.dbg.declare(metadata ptr %len, metadata !176, metadata !DIExpression()), !dbg !177
+    !177
   store i64 0, ptr %len, align 8, !dbg !178
   %37 = load ptr, ptr %list5, align 8, !dbg !179
   %38 = load i32, ptr %i, align 4, !dbg !180
@@ -500,7 +500,7 @@ loop.body:                                        ; preds = %loop.cond
   %39 = load ptr, ptr %arg, align 8, !dbg !181
   %40 = load ptr, ptr %arg, align 8
   store ptr %40, ptr %ptr, align 8
-  call void @llvm.dbg.declare(metadata ptr %len18, metadata !182, metadata !DIExpression()), !dbg !184
+    !184
   store i64 0, ptr %len18, align 8, !dbg !186
   br label %loop.cond19, !dbg !187
 
@@ -538,23 +538,23 @@ loop.exit26:                                      ; preds = %loop.cond
   %49 = call i32 @test.main(ptr %lo, i64 %hi), !dbg !196
   store i32 %49, ptr %blockret, align 4, !dbg !196
   %50 = load ptr, ptr %list, align 8, !dbg !197
-  call void @std.core.mem.free(ptr %50) #4, !dbg !199
+  call void @std.core.mem.free(ptr %50)
   br label %expr_block.exit28, !dbg !199
 
 expr_block.exit28:                                ; preds = %loop.exit26
   %51 = load i32, ptr %blockret, align 4, !dbg !199
   ret i32 %51, !dbg !199
 }
-declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
 declare { i32, ptr } @attach.to_scope() #0
 declare ptr @std.core.mem.calloc(i64) #0
 declare ptr @std.io.stdout() #0
 declare i64 @std.io.fprintf(ptr, i64, ptr, ptr, i64, ptr byval(%"any[]") align 8) #0
-declare i1 @llvm.expect.i1(i1, i1) #2
+declare i1 @llvm.expect.i1(i1, i1)
 declare i64 @std.io.File.write_byte(ptr, i8 zeroext) #0
 declare i64 @std.io.File.flush(ptr) #0
 declare { ptr, i64 } @arena_scratch_begin(ptr, i64) #0
-declare void @llvm.memcpy.p0.p0.i32(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i32, i1 immarg) #3
+declare void @llvm.memcpy.p0.p0.i32(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i32, i1 immarg)
 declare void @arena_scratch_end(ptr, i64) #0
 define weak_odr ptr @.dyn_search(ptr %0, ptr %1) unnamed_addr {
 entry:

test/test_suite/debug_symbols/foreach.c3t

@@ -22,26 +22,28 @@ entry:
   store ptr %0, ptr %args, align 8
   %ptradd = getelementptr inbounds i8, ptr %args, i64 8
   store i64 %1, ptr %ptradd, align 8
-  call void @llvm.dbg.declare(metadata ptr %args, metadata !23, metadata !DIExpression()), !dbg !24
+    !24
-  call void @llvm.dbg.declare(metadata ptr %.anon, metadata !25, metadata !DIExpression()), !dbg !27
+    !27
   %ptradd1 = getelementptr inbounds i8, ptr %args, i64 8, !dbg !27
   %2 = load i64, ptr %ptradd1, align 8, !dbg !27
   store i64 %2, ptr %.anon, align 8, !dbg !27
-  call void @llvm.dbg.declare(metadata ptr %.anon2, metadata !25, metadata !DIExpression()), !dbg !27
+    !27
   store i64 0, ptr %.anon2, align 8, !dbg !27
   br label %loop.cond, !dbg !27
+
 loop.cond:                                        ; preds = %loop.body, %entry
   %3 = load i64, ptr %.anon2, align 8, !dbg !27
   %4 = load i64, ptr %.anon, align 8, !dbg !27
   %lt = icmp ult i64 %3, %4, !dbg !27
   br i1 %lt, label %loop.body, label %loop.exit, !dbg !27
+
 loop.body:                                        ; preds = %loop.cond
-  call void @llvm.dbg.declare(metadata ptr %a, metadata !28, metadata !DIExpression()), !dbg !30
+    !30
   %5 = load ptr, ptr %args, align 8, !dbg !31
   %6 = load i64, ptr %.anon2, align 8, !dbg !31
   %ptroffset = getelementptr inbounds [16 x i8], ptr %5, i64 %6, !dbg !31
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %a, ptr align 8 %ptroffset, i32 16, i1 false), !dbg !31
-  call void @llvm.dbg.declare(metadata ptr %x, metadata !32, metadata !DIExpression()), !dbg !35
+    !35
   %ptradd3 = getelementptr inbounds i8, ptr %a, i64 8, !dbg !36
   %7 = load i64, ptr %ptradd3, align 8, !dbg !36
   %trunc = trunc i64 %7 to i32, !dbg !36