// #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
  %4 = getelementptr inbounds [2 x %"any*"], ptr %varargslots, i64 0, i64 0
  store %"any*" %3, ptr %4, align 16
  %5 = load i32, ptr %x, align 4
  %6 = call i32 @llvm.bswap.i32(i32 %5)
  store i32 %6, ptr %taddr, align 4
  %7 = insertvalue %"any*" undef, ptr %taddr, 0
  %8 = insertvalue %"any*" %7, i64 ptrtoint (ptr @"$ct.int" to i64), 1
  %9 = getelementptr inbounds [2 x %"any*"], ptr %varargslots, i64 0, i64 1
  store %"any*" %8, ptr %9, align 16
  %10 = 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
  %11 = load ptr, ptr %z2, align 8
  store ptr %11, ptr %.anon, align 8
  store i64 0, ptr %.anon1, align 8
  br label %loop.cond

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

loop.body:                                        ; preds = %loop.cond
  %13 = load ptr, ptr %.anon, align 8
  %14 = load i64, ptr %.anon1, align 8
  %15 = getelementptr inbounds [4 x i8], ptr %13, i64 0, i64 %14
  %16 = load i8, ptr %15, align 1
  store i8 %16, ptr %d, align 1
  %17 = insertvalue %"any*" undef, ptr %d, 0
  %18 = insertvalue %"any*" %17, i64 ptrtoint (ptr @"$ct.char" to i64), 1
  %19 = getelementptr inbounds [1 x %"any*"], ptr %varargslots2, i64 0, i64 0
  store %"any*" %18, ptr %19, align 16
  %20 = call i64 @std.io.printf(ptr %retparam3, ptr @.str.1, i64 3, ptr %varargslots2, i64 1)
  %21 = load i64, ptr %.anon1, align 8
  %add = add i64 %21, 1
  store i64 %add, ptr %.anon1, align 8
  br label %loop.cond

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

assign_optional:                                  ; preds = %loop.exit
  store i64 %23, 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
  %25 = load i64, ptr %retparam5, align 8
  store i64 %25, ptr %len, align 8
  %26 = call i64 @std.io.File.write_byte(ptr %22, i8 zeroext 10)
  %not_err7 = icmp eq i64 %26, 0
  %27 = call i1 @llvm.expect.i1(i1 %not_err7, i1 true)
  br i1 %27, label %after_check9, label %assign_optional8

assign_optional8:                                 ; preds = %noerr_block
  store i64 %26, ptr %error_var6, align 8
  br label %guard_block10

after_check9:                                     ; preds = %noerr_block
  br label %noerr_block11

guard_block10:                                    ; preds = %assign_optional8
  br label %voiderr

noerr_block11:                                    ; preds = %after_check9
  %28 = call i64 @std.io.File.flush(ptr %22)
  %not_err13 = icmp eq i64 %28, 0
  %29 = call i1 @llvm.expect.i1(i1 %not_err13, i1 true)
  br i1 %29, label %after_check15, label %assign_optional14

assign_optional14:                                ; preds = %noerr_block11
  store i64 %28, ptr %error_var12, align 8
  br label %guard_block16

after_check15:                                    ; preds = %noerr_block11
  br label %noerr_block17

guard_block16:                                    ; preds = %assign_optional14
  br label %voiderr

noerr_block17:                                    ; preds = %after_check15
  %30 = load i64, ptr %len, align 8
  %add18 = add i64 %30, 1
  br label %voiderr

voiderr:                                          ; preds = %noerr_block17, %guard_block16, %guard_block10, %guard_block
  %31 = load ptr, ptr %z, align 8
  store ptr %31, ptr %.anon19, align 8
  store i64 0, ptr %.anon20, align 8
  br label %loop.cond21

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

loop.body23:                                      ; preds = %loop.cond21
  %33 = load ptr, ptr %.anon19, align 8
  %34 = load i64, ptr %.anon20, align 8
  %35 = getelementptr inbounds [4 x i8], ptr %33, i64 0, i64 %34
  %36 = load i8, ptr %35, align 1
  store i8 %36, ptr %d24, align 1
  %37 = insertvalue %"any*" undef, ptr %d24, 0
  %38 = insertvalue %"any*" %37, i64 ptrtoint (ptr @"$ct.char" to i64), 1
  %39 = getelementptr inbounds [1 x %"any*"], ptr %varargslots25, i64 0, i64 0
  store %"any*" %38, ptr %39, align 16
  %40 = call i64 @std.io.printf(ptr %retparam26, ptr @.str.2, i64 3, ptr %varargslots25, i64 1)
  %41 = load i64, ptr %.anon20, align 8
  %add29 = add i64 %41, 1
  store i64 %add29, ptr %.anon20, align 8
  br label %loop.cond21

loop.exit30:                                      ; preds = %loop.cond21
  %42 = call ptr @std.io.stdout()
  %43 = call i64 @std.io.File.write(ptr %retparam34, ptr %42, ptr null, i64 0)
  %not_err35 = icmp eq i64 %43, 0
  %44 = call i1 @llvm.expect.i1(i1 %not_err35, i1 true)
  br i1 %44, label %after_check37, label %assign_optional36

assign_optional36:                                ; preds = %loop.exit30
  store i64 %43, ptr %error_var32, align 8
  br label %guard_block38

after_check37:                                    ; preds = %loop.exit30
  br label %noerr_block39

guard_block38:                                    ; preds = %assign_optional36
  br label %voiderr53

noerr_block39:                                    ; preds = %after_check37
  %45 = load i64, ptr %retparam34, align 8
  store i64 %45, ptr %len31, align 8
  %46 = call i64 @std.io.File.write_byte(ptr %42, i8 zeroext 10)
  %not_err41 = icmp eq i64 %46, 0
  %47 = call i1 @llvm.expect.i1(i1 %not_err41, i1 true)
  br i1 %47, label %after_check43, label %assign_optional42

assign_optional42:                                ; preds = %noerr_block39
  store i64 %46, ptr %error_var40, align 8
  br label %guard_block44

after_check43:                                    ; preds = %noerr_block39
  br label %noerr_block45

guard_block44:                                    ; preds = %assign_optional42
  br label %voiderr53

noerr_block45:                                    ; preds = %after_check43
  %48 = call i64 @std.io.File.flush(ptr %42)
  %not_err47 = icmp eq i64 %48, 0
  %49 = call i1 @llvm.expect.i1(i1 %not_err47, i1 true)
  br i1 %49, label %after_check49, label %assign_optional48

assign_optional48:                                ; preds = %noerr_block45
  store i64 %48, ptr %error_var46, align 8
  br label %guard_block50

after_check49:                                    ; preds = %noerr_block45
  br label %noerr_block51

guard_block50:                                    ; preds = %assign_optional48
  br label %voiderr53

noerr_block51:                                    ; preds = %after_check49
  %50 = load i64, ptr %len31, align 8
  %add52 = add i64 %50, 1
  br label %voiderr53

voiderr53:                                        ; preds = %noerr_block51, %guard_block50, %guard_block44, %guard_block38
  %51 = load i32, ptr %abc, align 4
  %52 = call i32 @llvm.bswap.i32(i32 %51)
  %53 = and i32 65535, %52
  %trunc = trunc i32 %53 to i16
  store i16 %trunc, ptr %taddr55, align 2
  %54 = insertvalue %"any*" undef, ptr %taddr55, 0
  %55 = insertvalue %"any*" %54, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
  %56 = getelementptr inbounds [1 x %"any*"], ptr %varargslots54, i64 0, i64 0
  store %"any*" %55, ptr %56, align 16
  %57 = call i64 @std.io.printfn(ptr %retparam56, ptr @.str.3, i64 10, ptr %varargslots54, i64 1)
  %58 = load i32, ptr %abc, align 4
  %59 = call i32 @llvm.bswap.i32(i32 %58)
  %60 = and i32 %59, -65536
  %61 = or i32 %60, 4660
  %62 = call i32 @llvm.bswap.i32(i32 %61)
  store i32 %62, ptr %abc, align 4
  %63 = load i32, ptr %abc, align 4
  %64 = call i32 @llvm.bswap.i32(i32 %63)
  %65 = and i32 %64, 65535
  %66 = or i32 %65, 1450704896
  %67 = call i32 @llvm.bswap.i32(i32 %66)
  store i32 %67, ptr %abc, align 4
  %68 = load i32, ptr %abc, align 4
  %69 = call i32 @llvm.bswap.i32(i32 %68)
  %70 = and i32 65535, %69
  %trunc60 = trunc i32 %70 to i16
  store i16 %trunc60, ptr %taddr61, align 2
  %71 = insertvalue %"any*" undef, ptr %taddr61, 0
  %72 = insertvalue %"any*" %71, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
  %73 = getelementptr inbounds [1 x %"any*"], ptr %varargslots59, i64 0, i64 0
  store %"any*" %72, ptr %73, align 16
  %74 = call i64 @std.io.printfn(ptr %retparam62, ptr @.str.4, i64 12, ptr %varargslots59, i64 1)
  %75 = load ptr, ptr %z, align 8
  store ptr %75, ptr %.anon65, align 8
  store i64 0, ptr %.anon66, align 8
  br label %loop.cond67

loop.cond67:                                      ; preds = %loop.body69, %voiderr53
  %76 = load i64, ptr %.anon66, align 8
  %gt68 = icmp ugt i64 4, %76
  br i1 %gt68, label %loop.body69, label %loop.exit76

loop.body69:                                      ; preds = %loop.cond67
  %77 = load ptr, ptr %.anon65, align 8
  %78 = load i64, ptr %.anon66, align 8
  %79 = getelementptr inbounds [4 x i8], ptr %77, i64 0, i64 %78
  %80 = load i8, ptr %79, align 1
  store i8 %80, ptr %d70, align 1
  %81 = insertvalue %"any*" undef, ptr %d70, 0
  %82 = insertvalue %"any*" %81, i64 ptrtoint (ptr @"$ct.char" to i64), 1
  %83 = getelementptr inbounds [1 x %"any*"], ptr %varargslots71, i64 0, i64 0
  store %"any*" %82, ptr %83, align 16
  %84 = call i64 @std.io.printf(ptr %retparam72, ptr @.str.5, i64 3, ptr %varargslots71, i64 1)
  %85 = load i64, ptr %.anon66, align 8
  %add75 = add i64 %85, 1
  store i64 %add75, ptr %.anon66, align 8
  br label %loop.cond67

loop.exit76:                                      ; preds = %loop.cond67
  %86 = call ptr @std.io.stdout()
  %87 = call i64 @std.io.File.write(ptr %retparam80, ptr %86, ptr null, i64 0)
  %not_err81 = icmp eq i64 %87, 0
  %88 = call i1 @llvm.expect.i1(i1 %not_err81, i1 true)
  br i1 %88, label %after_check83, label %assign_optional82

assign_optional82:                                ; preds = %loop.exit76
  store i64 %87, ptr %error_var78, align 8
  br label %guard_block84

after_check83:                                    ; preds = %loop.exit76
  br label %noerr_block85

guard_block84:                                    ; preds = %assign_optional82
  br label %voiderr99

noerr_block85:                                    ; preds = %after_check83
  %89 = load i64, ptr %retparam80, align 8
  store i64 %89, ptr %len77, align 8
  %90 = call i64 @std.io.File.write_byte(ptr %86, i8 zeroext 10)
  %not_err87 = icmp eq i64 %90, 0
  %91 = call i1 @llvm.expect.i1(i1 %not_err87, i1 true)
  br i1 %91, label %after_check89, label %assign_optional88

assign_optional88:                                ; preds = %noerr_block85
  store i64 %90, ptr %error_var86, align 8
  br label %guard_block90

after_check89:                                    ; preds = %noerr_block85
  br label %noerr_block91

guard_block90:                                    ; preds = %assign_optional88
  br label %voiderr99

noerr_block91:                                    ; preds = %after_check89
  %92 = call i64 @std.io.File.flush(ptr %86)
  %not_err93 = icmp eq i64 %92, 0
  %93 = call i1 @llvm.expect.i1(i1 %not_err93, i1 true)
  br i1 %93, label %after_check95, label %assign_optional94

assign_optional94:                                ; preds = %noerr_block91
  store i64 %92, ptr %error_var92, align 8
  br label %guard_block96

after_check95:                                    ; preds = %noerr_block91
  br label %noerr_block97

guard_block96:                                    ; preds = %assign_optional94
  br label %voiderr99

noerr_block97:                                    ; preds = %after_check95
  %94 = load i64, ptr %len77, align 8
  %add98 = add i64 %94, 1
  br label %voiderr99

voiderr99:                                        ; preds = %noerr_block97, %guard_block96, %guard_block90, %guard_block84
  store i32 0, ptr %y, align 4
  %95 = load i32, ptr %y, align 4
  store i32 123, ptr %y, align 4
  %96 = insertvalue %"any*" undef, ptr %y, 0
  %97 = insertvalue %"any*" %96, i64 ptrtoint (ptr @"$ct.int" to i64), 1
  %98 = getelementptr inbounds [2 x %"any*"], ptr %varargslots100, i64 0, i64 0
  store %"any*" %97, ptr %98, align 16
  %99 = load i32, ptr %y, align 4
  store i32 %99, ptr %taddr101, align 4
  %100 = insertvalue %"any*" undef, ptr %taddr101, 0
  %101 = insertvalue %"any*" %100, i64 ptrtoint (ptr @"$ct.int" to i64), 1
  %102 = getelementptr inbounds [2 x %"any*"], ptr %varargslots100, i64 0, i64 1
  store %"any*" %101, ptr %102, align 16
  %103 = call i64 @std.io.printf(ptr %retparam102, ptr @.str.6, i64 18, ptr %varargslots100, i64 2)
  ret void
}