// #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 %varargslots3, i64 0, i64 0
  store %any %18, ptr %19, align 16
  %20 = call i64 @std.io.printf(ptr %retparam2, ptr @.str.1, i64 3, ptr %varargslots3, 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()
  store ptr %22, ptr %result, align 8
  %23 = load ptr, ptr %result, align 8
  %24 = call i64 @std.io.File.printn(ptr %retparam4, ptr %23, ptr null, i64 0)
  %25 = load ptr, ptr %z, align 8
  store ptr %25, ptr %.anon5, align 8
  store i64 0, ptr %.anon6, align 8
  br label %loop.cond7

loop.cond7:                                       ; preds = %loop.body9, %loop.exit
  %26 = load i64, ptr %.anon6, align 8
  %gt8 = icmp ugt i64 4, %26
  br i1 %gt8, label %loop.body9, label %loop.exit14

loop.body9:                                       ; preds = %loop.cond7
  %27 = load ptr, ptr %.anon5, align 8
  %28 = load i64, ptr %.anon6, align 8
  %29 = getelementptr inbounds [4 x i8], ptr %27, i64 0, i64 %28
  %30 = load i8, ptr %29, align 1
  store i8 %30, ptr %d10, align 1
  %31 = insertvalue %any undef, ptr %d10, 0
  %32 = insertvalue %any %31, i64 ptrtoint (ptr @"$ct.char" to i64), 1
  %33 = getelementptr inbounds [1 x %any], ptr %varargslots12, i64 0, i64 0
  store %any %32, ptr %33, align 16
  %34 = call i64 @std.io.printf(ptr %retparam11, ptr @.str.2, i64 3, ptr %varargslots12, i64 1)
  %35 = load i64, ptr %.anon6, align 8
  %add13 = add i64 %35, 1
  store i64 %add13, ptr %.anon6, align 8
  br label %loop.cond7

loop.exit14:                                      ; preds = %loop.cond7
  %36 = call ptr @std.io.stdout()
  store ptr %36, ptr %result16, align 8
  %37 = load ptr, ptr %result16, align 8
  %38 = call i64 @std.io.File.printn(ptr %retparam15, ptr %37, ptr null, i64 0)
  %39 = load i32, ptr %abc, align 4
  %40 = call i32 @llvm.bswap.i32(i32 %39)
  %41 = and i32 65535, %40
  %trunc = trunc i32 %41 to i16
  store i16 %trunc, ptr %taddr19, align 2
  %42 = insertvalue %any undef, ptr %taddr19, 0
  %43 = insertvalue %any %42, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
  %44 = getelementptr inbounds [1 x %any], ptr %varargslots18, i64 0, i64 0
  store %any %43, ptr %44, align 16
  %45 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.3, i64 10, ptr %varargslots18, i64 1)
  %46 = load i32, ptr %abc, align 4
  %47 = call i32 @llvm.bswap.i32(i32 %46)
  %48 = and i32 %47, -65536
  %49 = or i32 %48, 4660
  %50 = call i32 @llvm.bswap.i32(i32 %49)
  store i32 %50, ptr %abc, align 4
  %51 = load i32, ptr %abc, align 4
  %52 = call i32 @llvm.bswap.i32(i32 %51)
  %53 = and i32 %52, 65535
  %54 = or i32 %53, 1450704896
  %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 65535, %57
  %trunc22 = trunc i32 %58 to i16
  store i16 %trunc22, ptr %taddr23, align 2
  %59 = insertvalue %any undef, ptr %taddr23, 0
  %60 = insertvalue %any %59, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
  %61 = getelementptr inbounds [1 x %any], ptr %varargslots21, i64 0, i64 0
  store %any %60, ptr %61, align 16
  %62 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.4, i64 12, ptr %varargslots21, i64 1)
  %63 = load ptr, ptr %z, align 8
  store ptr %63, ptr %.anon24, align 8
  store i64 0, ptr %.anon25, align 8
  br label %loop.cond26

loop.cond26:                                      ; preds = %loop.body28, %loop.exit14
  %64 = load i64, ptr %.anon25, align 8
  %gt27 = icmp ugt i64 4, %64
  br i1 %gt27, label %loop.body28, label %loop.exit33

loop.body28:                                      ; preds = %loop.cond26
  %65 = load ptr, ptr %.anon24, align 8
  %66 = load i64, ptr %.anon25, align 8
  %67 = getelementptr inbounds [4 x i8], ptr %65, i64 0, i64 %66
  %68 = load i8, ptr %67, align 1
  store i8 %68, ptr %d29, align 1
  %69 = insertvalue %any undef, ptr %d29, 0
  %70 = insertvalue %any %69, i64 ptrtoint (ptr @"$ct.char" to i64), 1
  %71 = getelementptr inbounds [1 x %any], ptr %varargslots31, i64 0, i64 0
  store %any %70, ptr %71, align 16
  %72 = call i64 @std.io.printf(ptr %retparam30, ptr @.str.5, i64 3, ptr %varargslots31, i64 1)
  %73 = load i64, ptr %.anon25, align 8
  %add32 = add i64 %73, 1
  store i64 %add32, ptr %.anon25, align 8
  br label %loop.cond26

loop.exit33:                                      ; preds = %loop.cond26
  %74 = call ptr @std.io.stdout()
  store ptr %74, ptr %result35, align 8
  %75 = load ptr, ptr %result35, align 8
  %76 = call i64 @std.io.File.printn(ptr %retparam34, ptr %75, ptr null, i64 0)
  store i32 0, ptr %y, align 4
  %77 = load i32, ptr %y, align 4
  store i32 123, ptr %y, align 4
  %78 = insertvalue %any undef, ptr %y, 0
  %79 = insertvalue %any %78, i64 ptrtoint (ptr @"$ct.int" to i64), 1
  %80 = getelementptr inbounds [2 x %any], ptr %varargslots37, i64 0, i64 0
  store %any %79, ptr %80, align 16
  %81 = load i32, ptr %y, align 4
  store i32 %81, ptr %taddr38, align 4
  %82 = insertvalue %any undef, ptr %taddr38, 0
  %83 = insertvalue %any %82, i64 ptrtoint (ptr @"$ct.int" to i64), 1
  %84 = getelementptr inbounds [2 x %any], ptr %varargslots37, i64 0, i64 1
  store %any %83, ptr %84, align 16
  %85 = call i64 @std.io.printf(ptr %retparam36, ptr @.str.6, i64 18, ptr %varargslots37, i64 2)
  ret void
}