// #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::printn("");
	foreach (d : z) io::printf(" %x", d);
	io::printn("");
	io::printfn("abc.a = %x", abc.a);
	abc.a = 0x1234;
	abc.b = 0x5678;
	io::printfn("->abc.a = %x", abc.a);
	foreach (d : z) io::printf(" %x", d);
	io::printn("");

	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
  %2 = insertvalue %any undef, ptr %x, 0
  %3 = insertvalue %any %2, i64 ptrtoint (ptr @"$ct.int" to i64), 1
  store %any %3, ptr %varargslots, align 16
  %4 = load i32, ptr %x, align 4
  %5 = call i32 @llvm.bswap.i32(i32 %4)
  store i32 %5, ptr %taddr, align 4
  %6 = insertvalue %any undef, ptr %taddr, 0
  %7 = insertvalue %any %6, i64 ptrtoint (ptr @"$ct.int" to i64), 1
  %ptradd = getelementptr inbounds i8, ptr %varargslots, i64 16
  store %any %7, ptr %ptradd, align 16
  %8 = call i64 @std.io.printf(ptr %retparam, ptr @.str, i64 18, ptr %varargslots, i64 2)
  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
  %9 = load ptr, ptr %z2, align 8
  store ptr %9, ptr %.anon, align 8
  store i64 0, ptr %.anon1, align 8
  br label %loop.cond

loop.cond:                                        ; preds = %loop.body, %entry
  %10 = load i64, ptr %.anon1, align 8
  %gt = icmp ugt i64 4, %10
  br i1 %gt, label %loop.body, label %loop.exit

loop.body:                                        ; preds = %loop.cond
  %11 = load ptr, ptr %.anon, align 8
  %12 = load i64, ptr %.anon1, align 8
  %ptradd2 = getelementptr inbounds i8, ptr %11, i64 %12
  %13 = load i8, ptr %ptradd2, align 1
  store i8 %13, ptr %d, align 1
  %14 = insertvalue %any undef, ptr %d, 0
  %15 = insertvalue %any %14, i64 ptrtoint (ptr @"$ct.char" to i64), 1
  store %any %15, ptr %varargslots3, align 16
  %16 = call i64 @std.io.printf(ptr %retparam4, ptr @.str.1, i64 3, ptr %varargslots3, i64 1)
  %17 = load i64, ptr %.anon1, align 8
  %addnuw = add nuw i64 %17, 1
  store i64 %addnuw, ptr %.anon1, align 8
  br label %loop.cond

loop.exit:                                        ; preds = %loop.cond
  %18 = call ptr @std.io.stdout()
  %19 = call i64 @std.io.File.write(ptr %retparam6, ptr %18, ptr null, i64 0)
  %not_err = icmp eq i64 %19, 0
  %20 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
  br i1 %20, label %after_check, label %assign_optional

assign_optional:                                  ; preds = %loop.exit
  store i64 %19, ptr %error_var, align 8
  br label %guard_block

after_check:                                      ; preds = %loop.exit
  br label %noerr_block

guard_block:                                      ; preds = %assign_optional
  br label %voiderr

noerr_block:                                      ; preds = %after_check
  %21 = load i64, ptr %retparam6, align 8
  store i64 %21, ptr %len, align 8
  %22 = call i64 @std.io.File.write_byte(ptr %18, i8 zeroext 10)
  %not_err8 = icmp eq i64 %22, 0
  %23 = call i1 @llvm.expect.i1(i1 %not_err8, i1 true)
  br i1 %23, label %after_check10, label %assign_optional9

assign_optional9:                                 ; preds = %noerr_block
  store i64 %22, ptr %error_var7, align 8
  br label %guard_block11

after_check10:                                    ; preds = %noerr_block
  br label %noerr_block12

guard_block11:                                    ; preds = %assign_optional9
  br label %voiderr

noerr_block12:                                    ; preds = %after_check10
  %24 = call i64 @std.io.File.flush(ptr %18)
  %not_err14 = icmp eq i64 %24, 0
  %25 = call i1 @llvm.expect.i1(i1 %not_err14, i1 true)
  br i1 %25, label %after_check16, label %assign_optional15

assign_optional15:                                ; preds = %noerr_block12
  store i64 %24, ptr %error_var13, align 8
  br label %guard_block17

after_check16:                                    ; preds = %noerr_block12
  br label %noerr_block18

guard_block17:                                    ; preds = %assign_optional15
  br label %voiderr

noerr_block18:                                    ; preds = %after_check16
  %26 = load i64, ptr %len, align 8
  %add = add i64 %26, 1
  br label %voiderr

voiderr:                                          ; preds = %noerr_block18, %guard_block17, %guard_block11, %guard_block
  %27 = load ptr, ptr %z, align 8
  store ptr %27, ptr %.anon19, align 8
  store i64 0, ptr %.anon20, align 8
  br label %loop.cond21

loop.cond21:                                      ; preds = %loop.body23, %voiderr
  %28 = load i64, ptr %.anon20, align 8
  %gt22 = icmp ugt i64 4, %28
  br i1 %gt22, label %loop.body23, label %loop.exit31

loop.body23:                                      ; preds = %loop.cond21
  %29 = load ptr, ptr %.anon19, align 8
  %30 = load i64, ptr %.anon20, align 8
  %ptradd25 = getelementptr inbounds i8, ptr %29, i64 %30
  %31 = load i8, ptr %ptradd25, align 1
  store i8 %31, ptr %d24, align 1
  %32 = insertvalue %any undef, ptr %d24, 0
  %33 = insertvalue %any %32, i64 ptrtoint (ptr @"$ct.char" to i64), 1
  store %any %33, ptr %varargslots26, align 16
  %34 = call i64 @std.io.printf(ptr %retparam27, ptr @.str.2, i64 3, ptr %varargslots26, i64 1)
  %35 = load i64, ptr %.anon20, align 8
  %addnuw30 = add nuw i64 %35, 1
  store i64 %addnuw30, ptr %.anon20, align 8
  br label %loop.cond21

loop.exit31:                                      ; preds = %loop.cond21
  %36 = call ptr @std.io.stdout()
  %37 = call i64 @std.io.File.write(ptr %retparam35, ptr %36, ptr null, i64 0)
  %not_err36 = icmp eq i64 %37, 0
  %38 = call i1 @llvm.expect.i1(i1 %not_err36, i1 true)
  br i1 %38, label %after_check38, label %assign_optional37

assign_optional37:                                ; preds = %loop.exit31
  store i64 %37, ptr %error_var33, align 8
  br label %guard_block39

after_check38:                                    ; preds = %loop.exit31
  br label %noerr_block40

guard_block39:                                    ; preds = %assign_optional37
  br label %voiderr54

noerr_block40:                                    ; preds = %after_check38
  %39 = load i64, ptr %retparam35, align 8
  store i64 %39, ptr %len32, align 8
  %40 = call i64 @std.io.File.write_byte(ptr %36, i8 zeroext 10)
  %not_err42 = icmp eq i64 %40, 0
  %41 = call i1 @llvm.expect.i1(i1 %not_err42, i1 true)
  br i1 %41, label %after_check44, label %assign_optional43

assign_optional43:                                ; preds = %noerr_block40
  store i64 %40, ptr %error_var41, align 8
  br label %guard_block45

after_check44:                                    ; preds = %noerr_block40
  br label %noerr_block46

guard_block45:                                    ; preds = %assign_optional43
  br label %voiderr54

noerr_block46:                                    ; preds = %after_check44
  %42 = call i64 @std.io.File.flush(ptr %36)
  %not_err48 = icmp eq i64 %42, 0
  %43 = call i1 @llvm.expect.i1(i1 %not_err48, i1 true)
  br i1 %43, label %after_check50, label %assign_optional49

assign_optional49:                                ; preds = %noerr_block46
  store i64 %42, ptr %error_var47, align 8
  br label %guard_block51

after_check50:                                    ; preds = %noerr_block46
  br label %noerr_block52

guard_block51:                                    ; preds = %assign_optional49
  br label %voiderr54

noerr_block52:                                    ; preds = %after_check50
  %44 = load i64, ptr %len32, align 8
  %add53 = add i64 %44, 1
  br label %voiderr54

voiderr54:                                        ; preds = %noerr_block52, %guard_block51, %guard_block45, %guard_block39
  %45 = load i32, ptr %abc, align 4
  %46 = call i32 @llvm.bswap.i32(i32 %45)
  %47 = and i32 65535, %46
  %trunc = trunc i32 %47 to i16
  store i16 %trunc, ptr %taddr56, align 2
  %48 = insertvalue %any undef, ptr %taddr56, 0
  %49 = insertvalue %any %48, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
  store %any %49, ptr %varargslots55, align 16
  %50 = call i64 @std.io.printfn(ptr %retparam57, ptr @.str.3, i64 10, ptr %varargslots55, i64 1)
  %51 = load i32, ptr %abc, align 4
  %52 = call i32 @llvm.bswap.i32(i32 %51)
  %53 = and i32 %52, -65536
  %54 = or i32 %53, 4660
  %55 = call i32 @llvm.bswap.i32(i32 %54)
  store i32 %55, ptr %abc, align 4
  %56 = load i32, ptr %abc, align 4
  %57 = call i32 @llvm.bswap.i32(i32 %56)
  %58 = and i32 %57, 65535
  %59 = or i32 %58, 1450704896
  %60 = call i32 @llvm.bswap.i32(i32 %59)
  store i32 %60, ptr %abc, align 4
  %61 = load i32, ptr %abc, align 4
  %62 = call i32 @llvm.bswap.i32(i32 %61)
  %63 = and i32 65535, %62
  %trunc61 = trunc i32 %63 to i16
  store i16 %trunc61, ptr %taddr62, align 2
  %64 = insertvalue %any undef, ptr %taddr62, 0
  %65 = insertvalue %any %64, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
  store %any %65, ptr %varargslots60, align 16
  %66 = call i64 @std.io.printfn(ptr %retparam63, ptr @.str.4, i64 12, ptr %varargslots60, i64 1)
  %67 = load ptr, ptr %z, align 8
  store ptr %67, ptr %.anon66, align 8
  store i64 0, ptr %.anon67, align 8
  br label %loop.cond68

loop.cond68:                                      ; preds = %loop.body70, %voiderr54
  %68 = load i64, ptr %.anon67, align 8
  %gt69 = icmp ugt i64 4, %68
  br i1 %gt69, label %loop.body70, label %loop.exit78

loop.body70:                                      ; preds = %loop.cond68
  %69 = load ptr, ptr %.anon66, align 8
  %70 = load i64, ptr %.anon67, align 8
  %ptradd72 = getelementptr inbounds i8, ptr %69, i64 %70
  %71 = load i8, ptr %ptradd72, align 1
  store i8 %71, ptr %d71, align 1
  %72 = insertvalue %any undef, ptr %d71, 0
  %73 = insertvalue %any %72, i64 ptrtoint (ptr @"$ct.char" to i64), 1
  store %any %73, ptr %varargslots73, align 16
  %74 = call i64 @std.io.printf(ptr %retparam74, ptr @.str.5, i64 3, ptr %varargslots73, i64 1)
  %75 = load i64, ptr %.anon67, align 8
  %addnuw77 = add nuw i64 %75, 1
  store i64 %addnuw77, ptr %.anon67, align 8
  br label %loop.cond68

loop.exit78:                                      ; preds = %loop.cond68
  %76 = call ptr @std.io.stdout()
  %77 = call i64 @std.io.File.write(ptr %retparam82, ptr %76, ptr null, i64 0)
  %not_err83 = icmp eq i64 %77, 0
  %78 = call i1 @llvm.expect.i1(i1 %not_err83, i1 true)
  br i1 %78, label %after_check85, label %assign_optional84

assign_optional84:                                ; preds = %loop.exit78
  store i64 %77, ptr %error_var80, align 8
  br label %guard_block86

after_check85:                                    ; preds = %loop.exit78
  br label %noerr_block87

guard_block86:                                    ; preds = %assign_optional84
  br label %voiderr101

noerr_block87:                                    ; preds = %after_check85
  %79 = load i64, ptr %retparam82, align 8
  store i64 %79, ptr %len79, align 8
  %80 = call i64 @std.io.File.write_byte(ptr %76, i8 zeroext 10)
  %not_err89 = icmp eq i64 %80, 0
  %81 = call i1 @llvm.expect.i1(i1 %not_err89, i1 true)
  br i1 %81, label %after_check91, label %assign_optional90

assign_optional90:                                ; preds = %noerr_block87
  store i64 %80, ptr %error_var88, align 8
  br label %guard_block92

after_check91:                                    ; preds = %noerr_block87
  br label %noerr_block93

guard_block92:                                    ; preds = %assign_optional90
  br label %voiderr101

noerr_block93:                                    ; preds = %after_check91
  %82 = call i64 @std.io.File.flush(ptr %76)
  %not_err95 = icmp eq i64 %82, 0
  %83 = call i1 @llvm.expect.i1(i1 %not_err95, i1 true)
  br i1 %83, label %after_check97, label %assign_optional96

assign_optional96:                                ; preds = %noerr_block93
  store i64 %82, ptr %error_var94, align 8
  br label %guard_block98

after_check97:                                    ; preds = %noerr_block93
  br label %noerr_block99

guard_block98:                                    ; preds = %assign_optional96
  br label %voiderr101

noerr_block99:                                    ; preds = %after_check97
  %84 = load i64, ptr %len79, align 8
  %add100 = add i64 %84, 1
  br label %voiderr101

voiderr101:                                       ; preds = %noerr_block99, %guard_block98, %guard_block92, %guard_block86
  store i32 0, ptr %y, align 4
  %85 = load i32, ptr %y, align 4
  store i32 123, ptr %y, align 4
  %86 = insertvalue %any undef, ptr %y, 0
  %87 = insertvalue %any %86, i64 ptrtoint (ptr @"$ct.int" to i64), 1
  store %any %87, ptr %varargslots102, align 16
  %88 = load i32, ptr %y, align 4
  store i32 %88, ptr %taddr103, align 4
  %89 = insertvalue %any undef, ptr %taddr103, 0
  %90 = insertvalue %any %89, i64 ptrtoint (ptr @"$ct.int" to i64), 1
  %ptradd104 = getelementptr inbounds i8, ptr %varargslots102, i64 16
  store %any %90, ptr %ptradd104, align 16
  %91 = call i64 @std.io.printf(ptr %retparam105, ptr @.str.6, i64 18, ptr %varargslots102, i64 2)
  ret void
}