c3c/test/test_suite/bitstruct/bitstruct_be.c3t

// #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::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::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
  %2 = insertvalue %variant undef, ptr %x, 0
  %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$int" to i64), 1
  %4 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
  store %variant %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 %variant undef, ptr %taddr, 0
  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$int" to i64), 1
  %9 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
  store %variant %8, ptr %9, align 16
  %10 = call i64 @std_io_printf(ptr %retparam, ptr @.str, i64 18, ptr %varargslots, i64 2)
  %not_err = icmp eq i64 %10, 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
  %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 = %voiderr6, %voiderr
  %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 %variant undef, ptr %d, 0
  %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"ct$char" to i64), 1
  %19 = getelementptr inbounds [1 x %variant], ptr %varargslots3, i64 0, i64 0
  store %variant %18, ptr %19, align 16
  %20 = call i64 @std_io_printf(ptr %retparam2, ptr @.str.1, i64 3, ptr %varargslots3, i64 1)
  %not_err4 = icmp eq i64 %20, 0
  br i1 %not_err4, label %after_check5, label %voiderr6

after_check5:                                     ; preds = %loop.body
  br label %voiderr6

voiderr6:                                         ; preds = %after_check5, %loop.body
  %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 i32 @std_io_println(ptr @.str.2) #2
  %23 = load ptr, ptr %z, align 8
  store ptr %23, ptr %.anon7, align 8
  store i64 0, ptr %.anon8, align 8
  br label %loop.cond9

loop.cond9:                                       ; preds = %voiderr17, %loop.exit
  %24 = load i64, ptr %.anon8, align 8
  %gt10 = icmp ugt i64 4, %24
  br i1 %gt10, label %loop.body11, label %loop.exit19

loop.body11:                                      ; preds = %loop.cond9
  %25 = load ptr, ptr %.anon7, align 8
  %26 = load i64, ptr %.anon8, align 8
  %27 = getelementptr inbounds [4 x i8], ptr %25, i64 0, i64 %26
  %28 = load i8, ptr %27, align 1
  store i8 %28, ptr %d12, align 1
  %29 = insertvalue %variant undef, ptr %d12, 0
  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$char" to i64), 1
  %31 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0
  store %variant %30, ptr %31, align 16
  %32 = call i64 @std_io_printf(ptr %retparam13, ptr @.str.3, i64 3, ptr %varargslots14, i64 1)
  %not_err15 = icmp eq i64 %32, 0
  br i1 %not_err15, label %after_check16, label %voiderr17

after_check16:                                    ; preds = %loop.body11
  br label %voiderr17

voiderr17:                                        ; preds = %after_check16, %loop.body11
  %33 = load i64, ptr %.anon8, align 8
  %add18 = add i64 %33, 1
  store i64 %add18, ptr %.anon8, align 8
  br label %loop.cond9

loop.exit19:                                      ; preds = %loop.cond9
  %34 = call i32 @std_io_println(ptr @.str.4) #2
  %35 = load i32, ptr %abc, align 4
  %36 = call i32 @llvm.bswap.i32(i32 %35)
  %37 = and i32 65535, %36
  %ztrunc = trunc i32 %37 to i16
  store i16 %ztrunc, ptr %taddr22, align 2
  %38 = insertvalue %variant undef, ptr %taddr22, 0
  %39 = insertvalue %variant %38, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
  %40 = getelementptr inbounds [1 x %variant], ptr %varargslots21, i64 0, i64 0
  store %variant %39, ptr %40, align 16
  %41 = call i64 @std_io_printfn(ptr %retparam20, ptr @.str.5, i64 10, ptr %varargslots21, i64 1)
  %not_err23 = icmp eq i64 %41, 0
  br i1 %not_err23, label %after_check24, label %voiderr25

after_check24:                                    ; preds = %loop.exit19
  br label %voiderr25

voiderr25:                                        ; preds = %after_check24, %loop.exit19
  %42 = load i32, ptr %abc, align 4
  %43 = call i32 @llvm.bswap.i32(i32 %42)
  %44 = and i32 %43, -65536
  %45 = or i32 %44, 4660
  %46 = call i32 @llvm.bswap.i32(i32 %45)
  store i32 %46, ptr %abc, align 4
  %47 = load i32, ptr %abc, align 4
  %48 = call i32 @llvm.bswap.i32(i32 %47)
  %49 = and i32 %48, 65535
  %50 = or i32 %49, 1450704896
  %51 = call i32 @llvm.bswap.i32(i32 %50)
  store i32 %51, ptr %abc, align 4
  %52 = load i32, ptr %abc, align 4
  %53 = call i32 @llvm.bswap.i32(i32 %52)
  %54 = and i32 65535, %53
  %ztrunc28 = trunc i32 %54 to i16
  store i16 %ztrunc28, ptr %taddr29, align 2
  %55 = insertvalue %variant undef, ptr %taddr29, 0
  %56 = insertvalue %variant %55, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
  %57 = getelementptr inbounds [1 x %variant], ptr %varargslots27, i64 0, i64 0
  store %variant %56, ptr %57, align 16
  %58 = call i64 @std_io_printfn(ptr %retparam26, ptr @.str.6, i64 12, ptr %varargslots27, i64 1)
  %not_err30 = icmp eq i64 %58, 0
  br i1 %not_err30, label %after_check31, label %voiderr32

after_check31:                                    ; preds = %voiderr25
  br label %voiderr32

voiderr32:                                        ; preds = %after_check31, %voiderr25
  %59 = load ptr, ptr %z, align 8
  store ptr %59, ptr %.anon33, align 8
  store i64 0, ptr %.anon34, align 8
  br label %loop.cond35

loop.cond35:                                      ; preds = %voiderr43, %voiderr32
  %60 = load i64, ptr %.anon34, align 8
  %gt36 = icmp ugt i64 4, %60
  br i1 %gt36, label %loop.body37, label %loop.exit45

loop.body37:                                      ; preds = %loop.cond35
  %61 = load ptr, ptr %.anon33, align 8
  %62 = load i64, ptr %.anon34, align 8
  %63 = getelementptr inbounds [4 x i8], ptr %61, i64 0, i64 %62
  %64 = load i8, ptr %63, align 1
  store i8 %64, ptr %d38, align 1
  %65 = insertvalue %variant undef, ptr %d38, 0
  %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$char" to i64), 1
  %67 = getelementptr inbounds [1 x %variant], ptr %varargslots40, i64 0, i64 0
  store %variant %66, ptr %67, align 16
  %68 = call i64 @std_io_printf(ptr %retparam39, ptr @.str.7, i64 3, ptr %varargslots40, i64 1)
  %not_err41 = icmp eq i64 %68, 0
  br i1 %not_err41, label %after_check42, label %voiderr43

after_check42:                                    ; preds = %loop.body37
  br label %voiderr43

voiderr43:                                        ; preds = %after_check42, %loop.body37
  %69 = load i64, ptr %.anon34, align 8
  %add44 = add i64 %69, 1
  store i64 %add44, ptr %.anon34, align 8
  br label %loop.cond35

loop.exit45:                                      ; preds = %loop.cond35
  %70 = call i32 @std_io_println(ptr @.str.8) #2
  store i32 0, ptr %y, align 4
  %71 = load i32, ptr %y, align 4
  store i32 123, ptr %y, align 4
  %72 = insertvalue %variant undef, ptr %y, 0
  %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"ct$int" to i64), 1
  %74 = getelementptr inbounds [2 x %variant], ptr %varargslots47, i64 0, i64 0
  store %variant %73, ptr %74, align 16
  %75 = load i32, ptr %y, align 4
  store i32 %75, ptr %taddr48, align 4
  %76 = insertvalue %variant undef, ptr %taddr48, 0
  %77 = insertvalue %variant %76, i64 ptrtoint (ptr @"ct$int" to i64), 1
  %78 = getelementptr inbounds [2 x %variant], ptr %varargslots47, i64 0, i64 1
  store %variant %77, ptr %78, align 16
  %79 = call i64 @std_io_printf(ptr %retparam46, ptr @.str.9, i64 18, ptr %varargslots47, i64 2)
  %not_err49 = icmp eq i64 %79, 0
  br i1 %not_err49, label %after_check50, label %voiderr51

after_check50:                                    ; preds = %loop.exit45
  br label %voiderr51

voiderr51:                                        ; preds = %after_check50, %loop.exit45
  ret void
}