// #target: macos-x64
module test;
import std::io;

bitstruct Test : int @bigendian
{
	ushort a : 0..15;
	ushort b : 16..31;
}

bitstruct Test2 : char[4] @bigendian
{
	ushort a : 0..15;
	ushort b : 16..31;
}

fn void main()
{
	IntBE x;
	x.val = 123;

	io::printf("BE 123 => %d (%d)\n", (int)x, x.val);
	Test abc = { .a = 0x1234, .b = 0x5678 };
	Test2 abc2 = { .a = 0x1234, .b = 0x5678 };
	char[4]* z = (char[4]*)&abc;
	char[4]* z2 = (char[4]*)&abc2;
	foreach (d : z2) io::printf(" %x", d);
	io::println("");
	foreach (d : z) io::printf(" %x", d);
	io::println("");
	io::printfln("abc.a = %x", abc.a);
	abc.a = 0x1234;
	abc.b = 0x5678;
	io::printfln("->abc.a = %x", abc.a);
	foreach (d : z) io::printf(" %x", d);
	io::println("");

	IntLE y;
	y.val = 123;
	io::printf("LE 123 => %d (%d)\n", (int)y, y.val);

}

/* #expect: test.ll

  %0 = load i32, ptr %x, align 4
  %1 = call i32 @llvm.bswap.i32(i32 %0)
  store i32 2063597568, ptr %x, align 4
  store %"char[]" { ptr @.str, i64 18 }, ptr %taddr, align 8
  %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0
  %lo = load ptr, ptr %2, align 8
  %3 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1
  %hi = load i64, ptr %3, align 8
  %4 = insertvalue %variant undef, ptr %x, 0
  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$int" to i64), 1
  %6 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
  store %variant %5, ptr %6, align 16
  %7 = load i32, ptr %x, align 4
  %8 = call i32 @llvm.bswap.i32(i32 %7)
  store i32 %8, ptr %taddr1, align 4
  %9 = insertvalue %variant undef, ptr %taddr1, 0
  %10 = insertvalue %variant %9, i64 ptrtoint (ptr @"ct$int" to i64), 1
  %11 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
  store %variant %10, ptr %11, align 16
  %12 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1
  store i64 2, ptr %12, align 8
  %13 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0
  store ptr %varargslots, ptr %13, align 8
  %14 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0
  %lo2 = load ptr, ptr %14, align 8
  %15 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1
  %hi3 = load i64, ptr %15, align 8
  %16 = call i64 @std_io_printf(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3)
  %not_err = icmp eq i64 %16, 0
  br i1 %not_err, label %after_check, label %voiderr

after_check:                                      ; preds = %entry
  br label %voiderr

voiderr:                                          ; preds = %after_check, %entry
  store i32 873625686, ptr %abc, align 4
  store [4 x i8] c"\124Vx", ptr %abc2, align 1
  store ptr %abc, ptr %z, align 8
  store ptr %abc2, ptr %z2, align 8
  %17 = load ptr, ptr %z2, align 8
  store ptr %17, ptr %.anon, align 8
  store i64 0, ptr %.anon4, align 8
  br label %loop.cond

loop.cond:                                        ; preds = %voiderr15, %voiderr
  %18 = load i64, ptr %.anon4, align 8
  %gt = icmp ugt i64 4, %18
  br i1 %gt, label %loop.body, label %loop.exit

loop.body:                                        ; preds = %loop.cond
  %19 = load ptr, ptr %.anon, align 8
  %20 = load i64, ptr %.anon4, align 8
  %21 = getelementptr inbounds [4 x i8], ptr %19, i64 0, i64 %20
  %22 = load i8, ptr %21, align 1
  store i8 %22, ptr %d, align 1
  store %"char[]" { ptr @.str.1, i64 3 }, ptr %taddr6, align 8
  %23 = getelementptr inbounds { ptr, i64 }, ptr %taddr6, i32 0, i32 0
  %lo7 = load ptr, ptr %23, align 8
  %24 = getelementptr inbounds { ptr, i64 }, ptr %taddr6, i32 0, i32 1
  %hi8 = load i64, ptr %24, align 8
  %25 = insertvalue %variant undef, ptr %d, 0
  %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$char" to i64), 1
  %27 = getelementptr inbounds [1 x %variant], ptr %varargslots10, i64 0, i64 0
  store %variant %26, ptr %27, align 16
  %28 = getelementptr inbounds %"variant[]", ptr %vararg9, i32 0, i32 1
  store i64 1, ptr %28, align 8
  %29 = getelementptr inbounds %"variant[]", ptr %vararg9, i32 0, i32 0
  store ptr %varargslots10, ptr %29, align 8
  %30 = getelementptr inbounds { ptr, i64 }, ptr %vararg9, i32 0, i32 0
  %lo11 = load ptr, ptr %30, align 8
  %31 = getelementptr inbounds { ptr, i64 }, ptr %vararg9, i32 0, i32 1
  %hi12 = load i64, ptr %31, align 8
  %32 = call i64 @std_io_printf(ptr %retparam5, ptr %lo7, i64 %hi8, ptr %lo11, i64 %hi12)
  %not_err13 = icmp eq i64 %32, 0
  br i1 %not_err13, label %after_check14, label %voiderr15

after_check14:                                    ; preds = %loop.body
  br label %voiderr15

voiderr15:                                        ; preds = %after_check14, %loop.body
  %33 = load i64, ptr %.anon4, align 8
  %add = add i64 %33, 1
  store i64 %add, ptr %.anon4, align 8
  br label %loop.cond

loop.exit:                                        ; preds = %loop.cond
  %34 = call i32 @std_io_println(ptr @.str.2) #2
  %35 = load ptr, ptr %z, align 8
  store ptr %35, ptr %.anon16, align 8
  store i64 0, ptr %.anon17, align 8
  br label %loop.cond18

loop.cond18:                                      ; preds = %voiderr32, %loop.exit
  %36 = load i64, ptr %.anon17, align 8
  %gt19 = icmp ugt i64 4, %36
  br i1 %gt19, label %loop.body20, label %loop.exit34

loop.body20:                                      ; preds = %loop.cond18
  %37 = load ptr, ptr %.anon16, align 8
  %38 = load i64, ptr %.anon17, align 8
  %39 = getelementptr inbounds [4 x i8], ptr %37, i64 0, i64 %38
  %40 = load i8, ptr %39, align 1
  store i8 %40, ptr %d21, align 1
  store %"char[]" { ptr @.str.3, i64 3 }, ptr %taddr23, align 8
  %41 = getelementptr inbounds { ptr, i64 }, ptr %taddr23, i32 0, i32 0
  %lo24 = load ptr, ptr %41, align 8
  %42 = getelementptr inbounds { ptr, i64 }, ptr %taddr23, i32 0, i32 1
  %hi25 = load i64, ptr %42, align 8
  %43 = insertvalue %variant undef, ptr %d21, 0
  %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"ct$char" to i64), 1
  %45 = getelementptr inbounds [1 x %variant], ptr %varargslots27, i64 0, i64 0
  store %variant %44, ptr %45, align 16
  %46 = getelementptr inbounds %"variant[]", ptr %vararg26, i32 0, i32 1
  store i64 1, ptr %46, align 8
  %47 = getelementptr inbounds %"variant[]", ptr %vararg26, i32 0, i32 0
  store ptr %varargslots27, ptr %47, align 8
  %48 = getelementptr inbounds { ptr, i64 }, ptr %vararg26, i32 0, i32 0
  %lo28 = load ptr, ptr %48, align 8
  %49 = getelementptr inbounds { ptr, i64 }, ptr %vararg26, i32 0, i32 1
  %hi29 = load i64, ptr %49, align 8
  %50 = call i64 @std_io_printf(ptr %retparam22, ptr %lo24, i64 %hi25, ptr %lo28, i64 %hi29)
  %not_err30 = icmp eq i64 %50, 0
  br i1 %not_err30, label %after_check31, label %voiderr32

after_check31:                                    ; preds = %loop.body20
  br label %voiderr32

voiderr32:                                        ; preds = %after_check31, %loop.body20
  %51 = load i64, ptr %.anon17, align 8
  %add33 = add i64 %51, 1
  store i64 %add33, ptr %.anon17, align 8
  br label %loop.cond18

loop.exit34:                                      ; preds = %loop.cond18
  %52 = call i32 @std_io_println(ptr @.str.4) #2
  store %"char[]" { ptr @.str.5, i64 10 }, ptr %taddr36, align 8
  %53 = getelementptr inbounds { ptr, i64 }, ptr %taddr36, i32 0, i32 0
  %lo37 = load ptr, ptr %53, align 8
  %54 = getelementptr inbounds { ptr, i64 }, ptr %taddr36, i32 0, i32 1
  %hi38 = load i64, ptr %54, align 8
  %55 = load i32, ptr %abc, align 4
  %56 = call i32 @llvm.bswap.i32(i32 %55)
  %57 = and i32 65535, %56
  %ztrunc = trunc i32 %57 to i16
  store i16 %ztrunc, ptr %taddr41, align 2
  %58 = insertvalue %variant undef, ptr %taddr41, 0
  %59 = insertvalue %variant %58, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
  %60 = getelementptr inbounds [1 x %variant], ptr %varargslots40, i64 0, i64 0
  store %variant %59, ptr %60, align 16
  %61 = getelementptr inbounds %"variant[]", ptr %vararg39, i32 0, i32 1
  store i64 1, ptr %61, align 8
  %62 = getelementptr inbounds %"variant[]", ptr %vararg39, i32 0, i32 0
  store ptr %varargslots40, ptr %62, align 8
  %63 = getelementptr inbounds { ptr, i64 }, ptr %vararg39, i32 0, i32 0
  %lo42 = load ptr, ptr %63, align 8
  %64 = getelementptr inbounds { ptr, i64 }, ptr %vararg39, i32 0, i32 1
  %hi43 = load i64, ptr %64, align 8
  %65 = call i64 @std_io_printfln(ptr %retparam35, ptr %lo37, i64 %hi38, ptr %lo42, i64 %hi43)
  %not_err44 = icmp eq i64 %65, 0
  br i1 %not_err44, label %after_check45, label %voiderr46

after_check45:                                    ; preds = %loop.exit34
  br label %voiderr46

voiderr46:                                        ; preds = %after_check45, %loop.exit34
  %66 = load i32, ptr %abc, align 4
  %67 = call i32 @llvm.bswap.i32(i32 %66)
  %68 = and i32 %67, -65536
  %69 = or i32 %68, 4660
  %70 = call i32 @llvm.bswap.i32(i32 %69)
  store i32 %70, ptr %abc, align 4
  %71 = load i32, ptr %abc, align 4
  %72 = call i32 @llvm.bswap.i32(i32 %71)
  %73 = and i32 %72, 65535
  %74 = or i32 %73, 1450704896
  %75 = call i32 @llvm.bswap.i32(i32 %74)
  store i32 %75, ptr %abc, align 4
  store %"char[]" { ptr @.str.6, i64 12 }, ptr %taddr48, align 8
  %76 = getelementptr inbounds { ptr, i64 }, ptr %taddr48, i32 0, i32 0
  %lo49 = load ptr, ptr %76, align 8
  %77 = getelementptr inbounds { ptr, i64 }, ptr %taddr48, i32 0, i32 1
  %hi50 = load i64, ptr %77, align 8
  %78 = load i32, ptr %abc, align 4
  %79 = call i32 @llvm.bswap.i32(i32 %78)
  %80 = and i32 65535, %79
  %ztrunc53 = trunc i32 %80 to i16
  store i16 %ztrunc53, ptr %taddr54, align 2
  %81 = insertvalue %variant undef, ptr %taddr54, 0
  %82 = insertvalue %variant %81, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
  %83 = getelementptr inbounds [1 x %variant], ptr %varargslots52, i64 0, i64 0
  store %variant %82, ptr %83, align 16
  %84 = getelementptr inbounds %"variant[]", ptr %vararg51, i32 0, i32 1
  store i64 1, ptr %84, align 8
  %85 = getelementptr inbounds %"variant[]", ptr %vararg51, i32 0, i32 0
  store ptr %varargslots52, ptr %85, align 8
  %86 = getelementptr inbounds { ptr, i64 }, ptr %vararg51, i32 0, i32 0
  %lo55 = load ptr, ptr %86, align 8
  %87 = getelementptr inbounds { ptr, i64 }, ptr %vararg51, i32 0, i32 1
  %hi56 = load i64, ptr %87, align 8
  %88 = call i64 @std_io_printfln(ptr %retparam47, ptr %lo49, i64 %hi50, ptr %lo55, i64 %hi56)
  %not_err57 = icmp eq i64 %88, 0
  br i1 %not_err57, label %after_check58, label %voiderr59

after_check58:                                    ; preds = %voiderr46
  br label %voiderr59

voiderr59:                                        ; preds = %after_check58, %voiderr46
  %89 = load ptr, ptr %z, align 8
  store ptr %89, ptr %.anon60, align 8
  store i64 0, ptr %.anon61, align 8
  br label %loop.cond62

loop.cond62:                                      ; preds = %voiderr76, %voiderr59
  %90 = load i64, ptr %.anon61, align 8
  %gt63 = icmp ugt i64 4, %90
  br i1 %gt63, label %loop.body64, label %loop.exit78

loop.body64:                                      ; preds = %loop.cond62
  %91 = load ptr, ptr %.anon60, align 8
  %92 = load i64, ptr %.anon61, align 8
  %93 = getelementptr inbounds [4 x i8], ptr %91, i64 0, i64 %92
  %94 = load i8, ptr %93, align 1
  store i8 %94, ptr %d65, align 1
  store %"char[]" { ptr @.str.7, i64 3 }, ptr %taddr67, align 8
  %95 = getelementptr inbounds { ptr, i64 }, ptr %taddr67, i32 0, i32 0
  %lo68 = load ptr, ptr %95, align 8
  %96 = getelementptr inbounds { ptr, i64 }, ptr %taddr67, i32 0, i32 1
  %hi69 = load i64, ptr %96, align 8
  %97 = insertvalue %variant undef, ptr %d65, 0
  %98 = insertvalue %variant %97, i64 ptrtoint (ptr @"ct$char" to i64), 1
  %99 = getelementptr inbounds [1 x %variant], ptr %varargslots71, i64 0, i64 0
  store %variant %98, ptr %99, align 16
  %100 = getelementptr inbounds %"variant[]", ptr %vararg70, i32 0, i32 1
  store i64 1, ptr %100, align 8
  %101 = getelementptr inbounds %"variant[]", ptr %vararg70, i32 0, i32 0
  store ptr %varargslots71, ptr %101, align 8
  %102 = getelementptr inbounds { ptr, i64 }, ptr %vararg70, i32 0, i32 0
  %lo72 = load ptr, ptr %102, align 8
  %103 = getelementptr inbounds { ptr, i64 }, ptr %vararg70, i32 0, i32 1
  %hi73 = load i64, ptr %103, align 8
  %104 = call i64 @std_io_printf(ptr %retparam66, ptr %lo68, i64 %hi69, ptr %lo72, i64 %hi73)
  %not_err74 = icmp eq i64 %104, 0
  br i1 %not_err74, label %after_check75, label %voiderr76

after_check75:                                    ; preds = %loop.body64
  br label %voiderr76

voiderr76:                                        ; preds = %after_check75, %loop.body64
  %105 = load i64, ptr %.anon61, align 8
  %add77 = add i64 %105, 1
  store i64 %add77, ptr %.anon61, align 8
  br label %loop.cond62

loop.exit78:                                      ; preds = %loop.cond62
  %106 = call i32 @std_io_println(ptr @.str.8) #2
  store i32 0, ptr %y, align 4
  %107 = load i32, ptr %y, align 4
  store i32 123, ptr %y, align 4
  store %"char[]" { ptr @.str.9, i64 18 }, ptr %taddr80, align 8
  %108 = getelementptr inbounds { ptr, i64 }, ptr %taddr80, i32 0, i32 0
  %lo81 = load ptr, ptr %108, align 8
  %109 = getelementptr inbounds { ptr, i64 }, ptr %taddr80, i32 0, i32 1
  %hi82 = load i64, ptr %109, align 8
  %110 = insertvalue %variant undef, ptr %y, 0
  %111 = insertvalue %variant %110, i64 ptrtoint (ptr @"ct$int" to i64), 1
  %112 = getelementptr inbounds [2 x %variant], ptr %varargslots84, i64 0, i64 0
  store %variant %111, ptr %112, align 16
  %113 = load i32, ptr %y, align 4
  store i32 %113, ptr %taddr85, align 4
  %114 = insertvalue %variant undef, ptr %taddr85, 0
  %115 = insertvalue %variant %114, i64 ptrtoint (ptr @"ct$int" to i64), 1
  %116 = getelementptr inbounds [2 x %variant], ptr %varargslots84, i64 0, i64 1
  store %variant %115, ptr %116, align 16
  %117 = getelementptr inbounds %"variant[]", ptr %vararg83, i32 0, i32 1
  store i64 2, ptr %117, align 8
  %118 = getelementptr inbounds %"variant[]", ptr %vararg83, i32 0, i32 0
  store ptr %varargslots84, ptr %118, align 8
  %119 = getelementptr inbounds { ptr, i64 }, ptr %vararg83, i32 0, i32 0
  %lo86 = load ptr, ptr %119, align 8
  %120 = getelementptr inbounds { ptr, i64 }, ptr %vararg83, i32 0, i32 1
  %hi87 = load i64, ptr %120, align 8
  %121 = call i64 @std_io_printf(ptr %retparam79, ptr %lo81, i64 %hi82, ptr %lo86, i64 %hi87)
  %not_err88 = icmp eq i64 %121, 0
  br i1 %not_err88, label %after_check89, label %voiderr90

after_check89:                                    ; preds = %loop.exit78
  br label %voiderr90

voiderr90:                                        ; preds = %after_check89, %loop.exit78
  ret void
}