c3c/test/test_suite/initializer_lists/subarrays.c3t

// #target: macos-x64

import std::io;
import std::core::mem;
import libc;
union Baz
{
    int x;
    double y;
}
struct Bar
{
    int x;
    int y;
}


Bar[] arrbar = { { 3, 4 }, { 8, 9 }};
int[] xd = { 1, 2 };
int* fofeo = &&(int[2]{ 3, 4 });

fn int main()
{
    Bar w = arrbar[1];
    libc::printf("%d\n", arrbar[1].x);
    int[] x = { 1, 2, 3 };
    int* y = &&(int[3]{ 123, 234, 567 });
    io::printn("Start:");
    libc::printf("X len: %d mid element %d\n", (int)(x.len), x[1]);
    libc::printf("Y mid element %d\n", y[1]);
    libc::printf("Fofeo second element %d\n", fofeo[1]);
    Baz ffe = { .x = 1 };
    int[1] azz = {};

    //var $foo = { 1, 2, 3 };
    bool xy = ! int[] { 1, 2, 3 };
    if (!xy) io::printn("Ok");
    Bar b = {};
    Baz z = {};
    int[] sub = {};
    Bar[] foo = {};
    Baz[3] baz = {};
    return 1;
}

/* #expect: subarrays.ll

%Bar = type { i32, i32 }
%"Bar[]" = type { ptr, i64 }
%"int[]" = type { ptr, i64 }
%"char[]" = type { ptr, i64 }
%File = type { ptr }
%Baz = type { double }

@"$ct.subarrays.Baz" = linkonce global %.introspect { i8 11, ptr null, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
@"$ct.subarrays.Bar" = linkonce global %.introspect { i8 10, ptr null, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
@.taddr = private global [2 x %Bar] [%Bar { i32 3, i32 4 }, %Bar { i32 8, i32 9 }], align 8
@subarrays.arrbar = local_unnamed_addr global %"Bar[]" { ptr @.taddr, i64 2 }, align 8
@.taddr.3 = private global [2 x i32] [i32 1, i32 2], align 4
@subarrays.xd = local_unnamed_addr global %"int[]" { ptr @.taddr.3, i64 2 }, align 8
@.taddr.4 = private global [2 x i32] [i32 3, i32 4], align 4
@subarrays.fofeo = local_unnamed_addr global ptr @.taddr.4, align 8
@.str = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
@.str.5 = private unnamed_addr constant [7 x i8] c"Start:\00", align 1
@.str.6 = private unnamed_addr constant [26 x i8] c"X len: %d mid element %d\0A\00", align 1
@.str.7 = private unnamed_addr constant [18 x i8] c"Y mid element %d\0A\00", align 1
@.str.8 = private unnamed_addr constant [25 x i8] c"Fofeo second element %d\0A\00", align 1
@.__const = private unnamed_addr constant { i32, [4 x i8] } { i32 1, [4 x i8] undef }, align 8
@.str.9 = private unnamed_addr constant [3 x i8] c"Ok\00", align 1

; Function Attrs: nounwind
define i32 @main() #0 {
entry:
  %w = alloca %Bar, align 4
  %x = alloca %"int[]", align 8
  %literal = alloca [3 x i32], align 4
  %y = alloca ptr, align 8
  %literal2 = alloca [3 x i32], align 4
  %x3 = alloca %"char[]", align 8
  %retparam = alloca i64, align 8
  %result = alloca %File, align 8
  %ffe = alloca %Baz, align 8
  %azz = alloca [1 x i32], align 4
  %xy = alloca i8, align 1
  %literal7 = alloca [3 x i32], align 4
  %x9 = alloca %"char[]", align 8
  %retparam10 = alloca i64, align 8
  %result11 = alloca %File, align 8
  %b = alloca %Bar, align 4
  %z = alloca %Baz, align 8
  %sub = alloca %"int[]", align 8
  %foo = alloca %"Bar[]", align 8
  %baz = alloca [3 x %Baz], align 16
  %0 = load ptr, ptr @subarrays.arrbar, align 8
  %ptroffset = getelementptr inbounds %Bar, ptr %0, i64 1
  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %w, ptr align 4 %ptroffset, i32 8, i1 false)
  %1 = load ptr, ptr @subarrays.arrbar, align 8
  %ptroffset1 = getelementptr inbounds %Bar, ptr %1, i64 1
  %2 = getelementptr inbounds %Bar, ptr %ptroffset1, i32 0, i32 0
  %3 = load i32, ptr %2, align 4
  %4 = call i32 (ptr, ...) @printf(ptr @.str, i32 %3)
  %5 = getelementptr inbounds [3 x i32], ptr %literal, i64 0, i64 0
  store i32 1, ptr %5, align 4
  %6 = getelementptr inbounds [3 x i32], ptr %literal, i64 0, i64 1
  store i32 2, ptr %6, align 4
  %7 = getelementptr inbounds [3 x i32], ptr %literal, i64 0, i64 2
  store i32 3, ptr %7, align 4
  %8 = insertvalue %"int[]" undef, ptr %literal, 0
  %9 = insertvalue %"int[]" %8, i64 3, 1
  store %"int[]" %9, ptr %x, align 8
  %10 = getelementptr inbounds [3 x i32], ptr %literal2, i64 0, i64 0
  store i32 123, ptr %10, align 4
  %11 = getelementptr inbounds [3 x i32], ptr %literal2, i64 0, i64 1
  store i32 234, ptr %11, align 4
  %12 = getelementptr inbounds [3 x i32], ptr %literal2, i64 0, i64 2
  store i32 567, ptr %12, align 4
  store ptr %literal2, ptr %y, align 8
  store %"char[]" { ptr @.str.5, i64 6 }, ptr %x3, align 8
  %13 = call ptr @std.io.stdout()
  store ptr %13, ptr %result, align 8
  %14 = load ptr, ptr %result, align 8
  %15 = getelementptr inbounds %"char[]", ptr %x3, i32 0, i32 0
  %lo = load ptr, ptr %15, align 8
  %16 = getelementptr inbounds %"char[]", ptr %x3, i32 0, i32 1
  %hi = load i64, ptr %16, align 8
  %17 = call i64 @std.io.File.printn(ptr %retparam, ptr %14, ptr %lo, i64 %hi)
  %18 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1
  %19 = load i64, ptr %18, align 8
  %trunc = trunc i64 %19 to i32
  %20 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0
  %21 = load ptr, ptr %20, align 8
  %ptroffset4 = getelementptr inbounds i32, ptr %21, i64 1
  %22 = load i32, ptr %ptroffset4, align 4
  %23 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %trunc, i32 %22)
  %24 = load ptr, ptr %y, align 8
  %ptroffset5 = getelementptr inbounds i32, ptr %24, i64 1
  %25 = load i32, ptr %ptroffset5, align 4
  %26 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %25)
  %27 = load ptr, ptr @subarrays.fofeo, align 8
  %ptroffset6 = getelementptr inbounds i32, ptr %27, i64 1
  %28 = load i32, ptr %ptroffset6, align 4
  %29 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %28)
  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %ffe, ptr align 8 @.__const, i32 8, i1 false)
  %30 = getelementptr inbounds [1 x i32], ptr %azz, i64 0, i64 0
  store i32 0, ptr %30, align 4
  %31 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 0
  store i32 1, ptr %31, align 4
  %32 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 1
  store i32 2, ptr %32, align 4
  %33 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 2
  store i32 3, ptr %33, align 4
  %34 = insertvalue %"int[]" undef, ptr %literal7, 0
  %35 = insertvalue %"int[]" %34, i64 3, 1
  %36 = extractvalue %"int[]" %35, 1
  %not = icmp eq i64 %36, 0
  %37 = zext i1 %not to i8
  store i8 %37, ptr %xy, align 1
  %38 = load i8, ptr %xy, align 1
  %39 = trunc i8 %38 to i1
  %not8 = xor i1 %39, true
  br i1 %not8, label %if.then, label %if.exit

if.then:                                          ; preds = %entry
  store %"char[]" { ptr @.str.9, i64 2 }, ptr %x9, align 8
  %40 = call ptr @std.io.stdout()
  store ptr %40, ptr %result11, align 8
  %41 = load ptr, ptr %result11, align 8
  %42 = getelementptr inbounds %"char[]", ptr %x9, i32 0, i32 0
  %lo12 = load ptr, ptr %42, align 8
  %43 = getelementptr inbounds %"char[]", ptr %x9, i32 0, i32 1
  %hi13 = load i64, ptr %43, align 8
  %44 = call i64 @std.io.File.printn(ptr %retparam10, ptr %41, ptr %lo12, i64 %hi13)
  br label %if.exit

if.exit:                                          ; preds = %if.then, %entry
  %45 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 0
  store i32 0, ptr %45, align 4
  %46 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1
  store i32 0, ptr %46, align 4
  call void @llvm.memset.p0.i64(ptr align 8 %z, i8 0, i64 8, i1 false)
  store %"int[]" zeroinitializer, ptr %sub, align 8
  store %"Bar[]" zeroinitializer, ptr %foo, align 8
  call void @llvm.memset.p0.i64(ptr align 16 %baz, i8 0, i64 24, i1 false)
  ret i32 1
}