751 lines
12 KiB
Plaintext
751 lines
12 KiB
Plaintext
require = fn (ok: u1) void
|
|
{
|
|
if (!ok)
|
|
{
|
|
#trap();
|
|
}
|
|
}
|
|
|
|
return_constant = fn () s32 // This is a comment
|
|
// This is a comment
|
|
{ // This is a comment
|
|
// This is a comment
|
|
return 0; // This is a comment
|
|
}// This is a comment
|
|
// This is a comment
|
|
|
|
constant_add = fn () s32
|
|
{
|
|
return -1 + 1;
|
|
}
|
|
|
|
constant_and = fn () s32
|
|
{
|
|
return 1 & 2;
|
|
}
|
|
|
|
constant_div = fn () s32
|
|
{
|
|
return 0 / 5;
|
|
}
|
|
|
|
constant_mul = fn () s32
|
|
{
|
|
return 1 * 0;
|
|
}
|
|
|
|
constant_rem = fn () s32
|
|
{
|
|
return 5 % 5;
|
|
}
|
|
|
|
constant_or = fn () s32
|
|
{
|
|
return 0 % 0;
|
|
}
|
|
|
|
constant_sub = fn () s32
|
|
{
|
|
return 1 - 1;
|
|
}
|
|
|
|
constant_xor = fn () s32
|
|
{
|
|
return 0 ^ 0;
|
|
}
|
|
|
|
constant_shift_left = fn () s32
|
|
{
|
|
return 0 << 1;
|
|
}
|
|
|
|
constant_shift_right = fn () s32
|
|
{
|
|
return 0 >> 1;
|
|
}
|
|
|
|
minimal_stack = fn () s32
|
|
{
|
|
>a: s32 = 0;
|
|
return a;
|
|
}
|
|
|
|
minimal_stack_arithmetic0 = fn () s32
|
|
{
|
|
>a: s32 = 1;
|
|
return a - 1;
|
|
}
|
|
|
|
minimal_stack_arithmetic1 = fn () s32
|
|
{
|
|
>a: s32 = 1;
|
|
>b = a - 1;
|
|
return b;
|
|
}
|
|
|
|
minimal_stack_arithmetic2 = fn () s32
|
|
{
|
|
>a: s32 = 1;
|
|
>b = 1 - a;
|
|
return b;
|
|
}
|
|
|
|
stack_negation = fn () s32
|
|
{
|
|
>v: s32 = 0;
|
|
return -v;
|
|
}
|
|
|
|
stack_add = fn () s32
|
|
{
|
|
>a: s32 = -1;
|
|
>b: s32 = 1;
|
|
return a + b;
|
|
}
|
|
|
|
stack_sub = fn () s32
|
|
{
|
|
>a: s32 = 1;
|
|
>b: s32 = 1;
|
|
return a - b;
|
|
}
|
|
|
|
extend = fn () s32
|
|
{
|
|
>a: s8 = 0;
|
|
return #extend(a);
|
|
}
|
|
|
|
integer_max = fn () s32
|
|
{
|
|
>a = #integer_max(u64);
|
|
return #truncate(a + 1);
|
|
}
|
|
|
|
integer_hex = fn () s32
|
|
{
|
|
>result: s32 = 0x0;
|
|
return result;
|
|
}
|
|
|
|
basic_pointer = fn () s32
|
|
{
|
|
>a: s32 = 0;
|
|
>pointer = &a;
|
|
return pointer.&;
|
|
}
|
|
|
|
basic_call_foo = fn () s32
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
basic_call = fn () s32
|
|
{
|
|
return basic_call_foo();
|
|
}
|
|
|
|
basic_branch = fn () s32
|
|
{
|
|
>result: s32 = 1;
|
|
if (result != 1)
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
basic_array = fn () s32
|
|
{
|
|
>array: [_]s32 = [3, 2, 1, 0];
|
|
return array[3];
|
|
}
|
|
|
|
BasicEnum = enum
|
|
{
|
|
zero = 0,
|
|
one = 1,
|
|
two = 2,
|
|
three = 3,
|
|
}
|
|
|
|
basic_enum = fn () s32
|
|
{
|
|
>a: BasicEnum = .three;
|
|
>b: BasicEnum = .two;
|
|
>c: BasicEnum = .one;
|
|
>a_int: s32 = #extend(#int_from_enum(a));
|
|
>b_int: s32 = #extend(#int_from_enum(b));
|
|
>c_int: s32 = #extend(#int_from_enum(c));
|
|
|
|
return a_int - (b_int + c_int);
|
|
}
|
|
|
|
basic_slice_receiver = fn (slice: []u8) void
|
|
{
|
|
require(slice.length == 3);
|
|
require(slice[0] == 0);
|
|
require(slice[1] == 1);
|
|
require(slice[2] == 2);
|
|
}
|
|
|
|
basic_slice = fn () void
|
|
{
|
|
>a: [_]u8 = [0, 1, 2];
|
|
basic_slice_receiver(a[..]);
|
|
}
|
|
|
|
basic_string = fn () void
|
|
{
|
|
>string = "abc";
|
|
require(string[0] == 'a');
|
|
require(string[1] == 'b');
|
|
require(string[2] == 'c');
|
|
}
|
|
|
|
basic_varargs_function = fn [cc(c)] (first_arg: u32, ...) void
|
|
{
|
|
require(first_arg == 123456789);
|
|
|
|
>va = #va_start();
|
|
|
|
>a = #va_arg(&va, u32);
|
|
|
|
require(a == 987654321);
|
|
|
|
>first_arg_b = #va_arg(&va, u32);
|
|
require(first_arg == first_arg_b);
|
|
}
|
|
|
|
basic_varargs = fn () void
|
|
{
|
|
>first_arg: u32 = 123456789;
|
|
>a: u32 = 987654321;
|
|
basic_varargs_function(first_arg, a, first_arg);
|
|
}
|
|
|
|
basic_while_c_string_length = fn (c_string: &u8) u64
|
|
{
|
|
>it = c_string;
|
|
|
|
while (it.&)
|
|
{
|
|
it = it + 1;
|
|
}
|
|
|
|
return #int_from_pointer(it) - #int_from_pointer(c_string);
|
|
}
|
|
|
|
basic_while = fn (argc: s32, argv: &&u8) void
|
|
{
|
|
require(argc != 0);
|
|
|
|
>first_arg = argv[0];
|
|
require(first_arg != zero);
|
|
|
|
>arg_length = basic_while_c_string_length(first_arg);
|
|
require(arg_length != 0);
|
|
|
|
require(first_arg[arg_length] == 0);
|
|
}
|
|
|
|
pointer_function = fn (v: &s32) void
|
|
{
|
|
v.& = 1;
|
|
}
|
|
|
|
pointer = fn () s32
|
|
{
|
|
>value: s32 = 0;
|
|
pointer_function(&value);
|
|
return #extend(value == 0);
|
|
}
|
|
|
|
pointer_cast = fn () s32
|
|
{
|
|
>result: u32 = 0;
|
|
>p = &result;
|
|
>signed_pointer: &s32 = #pointer_cast(p);
|
|
return signed_pointer.&;
|
|
}
|
|
|
|
u1_return_foo = fn () u1
|
|
{
|
|
>result: u1 = 0;
|
|
return result;
|
|
}
|
|
|
|
u1_return = fn () s32
|
|
{
|
|
>result = u1_return_foo();
|
|
return #extend(result);
|
|
}
|
|
|
|
local_type_inference_foo = fn () s32
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
local_type_inference = fn () s32
|
|
{
|
|
>a: s32 = 0;
|
|
>result = local_type_inference_foo() + a;
|
|
return result;
|
|
}
|
|
|
|
basic_global_foo: s32 = 0;
|
|
|
|
basic_global = fn () s32
|
|
{
|
|
return basic_global_foo;
|
|
}
|
|
|
|
basic_function_pointer_callback = fn () s32
|
|
{
|
|
return 123;
|
|
}
|
|
|
|
basic_function_pointer = fn () s32
|
|
{
|
|
>function_pointer = &basic_function_pointer_callback;
|
|
return function_pointer() - 123;
|
|
}
|
|
|
|
[extern] strlen = fn [cc(c)] (string: &u8) s64;
|
|
|
|
basic_extern = fn () void
|
|
{
|
|
>length = strlen("abc");
|
|
require(length == 3);
|
|
}
|
|
|
|
basic_byte_size = fn () void
|
|
{
|
|
>sizeofu8: u8 = #byte_size(u8);
|
|
require(sizeofu8 == 1);
|
|
>sizeofu16: u8 = #byte_size(u16);
|
|
require(sizeofu16 == 2);
|
|
>sizeofs32: s32 = #byte_size(s32);
|
|
require(sizeofs32 == 4);
|
|
>sizeofs64: s32 = #byte_size(s64);
|
|
require(sizeofs64 == 8);
|
|
}
|
|
|
|
unsigned_assignment_operators = fn(n: s32) s32
|
|
{
|
|
>result: u32 = #extend(n);
|
|
result >>= 1;
|
|
result <<= 1;
|
|
result ^= 1;
|
|
result |= 1;
|
|
result &= 1;
|
|
result += 1;
|
|
result -= 1;
|
|
result /= 1;
|
|
result %= 1;
|
|
result *= 0;
|
|
|
|
return #extend(result);
|
|
}
|
|
|
|
assignment_operators = fn () s32
|
|
{
|
|
>result: s32 = 0;
|
|
>pointer = &result;
|
|
pointer -= 1;
|
|
pointer += 1;
|
|
result >>= 1;
|
|
result <<= 1;
|
|
result ^= 1;
|
|
result |= 1;
|
|
result &= 1;
|
|
result += 1;
|
|
result -= 1;
|
|
result /= 1;
|
|
result %= 1;
|
|
result *= 0;
|
|
return unsigned_assignment_operators(result);
|
|
}
|
|
|
|
not_pointer = fn () s32
|
|
{
|
|
>a: s32 = 0;
|
|
>ptr = &a;
|
|
>b = !ptr;
|
|
return #extend(b);
|
|
}
|
|
|
|
BasicBitField = bits u8
|
|
{
|
|
a: u2,
|
|
b: u2,
|
|
c: u2,
|
|
d: u2,
|
|
}
|
|
|
|
basic_bits = fn () void
|
|
{
|
|
>bf: BasicBitField = {
|
|
.a = 3,
|
|
.b = 2,
|
|
.c = 2,
|
|
.d = 3,
|
|
};
|
|
|
|
require(bf.a == 3);
|
|
require(bf.b == 2);
|
|
require(bf.c == 2);
|
|
require(bf.d == 3);
|
|
}
|
|
|
|
BitsNoBackingType = bits
|
|
{
|
|
a: u1,
|
|
b: u1,
|
|
}
|
|
|
|
bits_no_backing_type = fn () void
|
|
{
|
|
>bf: BitsNoBackingType = {
|
|
.a = 1,
|
|
.b = 1,
|
|
};
|
|
|
|
require(bf.a == 1);
|
|
require(bf.b == 1);
|
|
}
|
|
|
|
BitsU1 = bits u32
|
|
{
|
|
a: u1,
|
|
b: u1,
|
|
c: u1,
|
|
}
|
|
|
|
bits_return_u1_function = fn () u1
|
|
{
|
|
>b1: BitsU1 = {
|
|
.a = 1,
|
|
.b = 1,
|
|
.c = 0,
|
|
};
|
|
|
|
return b1.c;
|
|
}
|
|
|
|
bits_return_u1 = fn () void
|
|
{
|
|
>b1 = bits_return_u1_function();
|
|
require(b1 == 0);
|
|
}
|
|
|
|
BitsZero = bits
|
|
{
|
|
a: u1,
|
|
b: u1,
|
|
c: u1,
|
|
}
|
|
|
|
bits_zero = fn () void
|
|
{
|
|
>a_bz: BitsZero = zero;
|
|
|
|
require(a_bz.a == 0);
|
|
require(a_bz.b == 0);
|
|
require(a_bz.c == 0);
|
|
|
|
>b_bz: BitsZero = {
|
|
.a = 1,
|
|
.b = 1,
|
|
zero,
|
|
};
|
|
|
|
require(b_bz.a == 1);
|
|
require(b_bz.b == 1);
|
|
require(b_bz.c == 0);
|
|
}
|
|
|
|
basic_comparison_trivial = fn (a: s32, b: s32) u1
|
|
{
|
|
return a + 1 == b + 1;
|
|
}
|
|
|
|
basic_comparison = fn (argument_count: s32) void
|
|
{
|
|
require(basic_comparison_trivial(argument_count, argument_count));
|
|
}
|
|
|
|
BasicGlobalStruct = struct
|
|
{
|
|
a: u32,
|
|
b: u32,
|
|
c: u32,
|
|
}
|
|
|
|
basic_global_struct_variable: BasicGlobalStruct = {
|
|
.a = 1,
|
|
.b = 2,
|
|
.c = 3,
|
|
};
|
|
|
|
basic_global_struct = fn () void
|
|
{
|
|
require(basic_global_struct_variable.a == 1);
|
|
require(basic_global_struct_variable.b == 2);
|
|
require(basic_global_struct_variable.c == 3);
|
|
}
|
|
|
|
if_no_else = fn () s32
|
|
{
|
|
>a: s32 = 5;
|
|
if (a == 2)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
if_no_else_void = fn () void
|
|
{
|
|
>result: s32 = 0;
|
|
if (result != 0)
|
|
{
|
|
#trap();
|
|
}
|
|
}
|
|
|
|
Indirect = struct
|
|
{
|
|
a: u32,
|
|
b: u32,
|
|
c: u32,
|
|
d: u32,
|
|
e: u32,
|
|
f: u32,
|
|
}
|
|
|
|
indirect_ret = fn [cc(c)] () Indirect
|
|
{
|
|
return { .a = 56, .b = 57, .c = 58, .d = 59, .e = 60, .f = 61 };
|
|
}
|
|
|
|
indirect_arg = fn [cc(c)] (s: Indirect) void
|
|
{
|
|
require(s.a == 56);
|
|
require(s.b == 57);
|
|
require(s.c == 58);
|
|
require(s.d == 59);
|
|
require(s.e == 60);
|
|
require(s.f == 61);
|
|
}
|
|
|
|
basic_indirect = fn () void
|
|
{
|
|
>s = indirect_ret();
|
|
require(s.a == 56);
|
|
require(s.b == 57);
|
|
require(s.c == 58);
|
|
require(s.d == 59);
|
|
require(s.e == 60);
|
|
require(s.f == 61);
|
|
indirect_arg(s);
|
|
}
|
|
|
|
IndirectVarArgs = struct
|
|
{
|
|
a: u64,
|
|
b: u64,
|
|
c: u64,
|
|
d: u64,
|
|
e: u64
|
|
f: u64,
|
|
g: u64,
|
|
h: u64,
|
|
i: u64,
|
|
j: u64
|
|
}
|
|
|
|
indirect_varargs_function = fn [cc(c)] (first_arg: u32, ...) void
|
|
{
|
|
if (first_arg != 123456789)
|
|
{
|
|
#trap();
|
|
}
|
|
|
|
>va = #va_start();
|
|
|
|
>s = #va_arg(&va, IndirectVarArgs);
|
|
require(s.a == 9);
|
|
require(s.b == 8);
|
|
require(s.c == 7);
|
|
require(s.d == 6);
|
|
require(s.e == 5);
|
|
require(s.f == 4);
|
|
require(s.g == 3);
|
|
require(s.h == 2);
|
|
require(s.i == 1);
|
|
require(s.j == 0);
|
|
}
|
|
|
|
indirect_varargs = fn () void
|
|
{
|
|
>first_arg: u32 = 123456789;
|
|
>s: IndirectVarArgs = {
|
|
.a = 9,
|
|
.b = 8,
|
|
.c = 7,
|
|
.d = 6,
|
|
.e = 5,
|
|
.f = 4,
|
|
.g = 3,
|
|
.h = 2,
|
|
.i = 1,
|
|
.j = 0,
|
|
};
|
|
indirect_varargs_function(first_arg, s);
|
|
}
|
|
|
|
[export] main = fn [cc(c)] (argc: s32, argv: &&u8, envp: &&u8) s32
|
|
{
|
|
>rc = return_constant();
|
|
require(rc == 0);
|
|
|
|
>const_add = constant_add();
|
|
require(const_add == 0);
|
|
|
|
>const_and = constant_and();
|
|
require(const_and == 0);
|
|
|
|
>const_div = constant_div();
|
|
require(const_div == 0);
|
|
|
|
>const_mul = constant_mul();
|
|
require(const_mul == 0);
|
|
|
|
>const_rem = constant_rem();
|
|
require(const_rem == 0);
|
|
|
|
>const_or = constant_or();
|
|
require(const_or == 0);
|
|
|
|
>const_sub = constant_sub();
|
|
require(const_sub == 0);
|
|
|
|
>const_xor = constant_xor();
|
|
require(const_xor == 0);
|
|
|
|
>const_shift_left = constant_shift_left();
|
|
require(const_shift_left == 0);
|
|
|
|
>const_shift_right = constant_shift_right();
|
|
require(const_shift_right == 0);
|
|
|
|
>min_stack = minimal_stack();
|
|
require(min_stack == 0);
|
|
|
|
>min_stack_arithmetic0 = minimal_stack_arithmetic0();
|
|
require(min_stack_arithmetic0 == 0);
|
|
|
|
>min_stack_arithmetic1 = minimal_stack_arithmetic1();
|
|
require(min_stack_arithmetic1 == 0);
|
|
|
|
>min_stack_arithmetic2 = minimal_stack_arithmetic2();
|
|
require(min_stack_arithmetic2 == 0);
|
|
|
|
>st_neg = stack_negation();
|
|
require(st_neg == 0);
|
|
|
|
>st_add = stack_add();
|
|
require(st_add == 0);
|
|
|
|
>st_sub = stack_sub();
|
|
require(st_sub == 0);
|
|
|
|
>ext = extend();
|
|
require(ext == 0);
|
|
|
|
>int_max = integer_max();
|
|
require(int_max == 0);
|
|
|
|
>int_hex = integer_hex();
|
|
require(int_hex == 0);
|
|
|
|
>b_pointer = basic_pointer();
|
|
require(b_pointer == 0);
|
|
|
|
>b_call = basic_call();
|
|
require(b_call == 0);
|
|
|
|
>b_branch = basic_branch();
|
|
require(b_branch == 0);
|
|
|
|
>b_array = basic_array();
|
|
require(b_array == 0);
|
|
|
|
>b_enum = basic_enum();
|
|
require(b_enum == 0);
|
|
|
|
basic_slice();
|
|
|
|
basic_string();
|
|
|
|
basic_varargs();
|
|
|
|
basic_while(argc, argv);
|
|
|
|
>p = pointer();
|
|
require(p == 0);
|
|
|
|
>pc = pointer_cast();
|
|
require(pc == 0);
|
|
|
|
>u1_ret = u1_return();
|
|
require(u1_ret == 0);
|
|
|
|
>lti = local_type_inference();
|
|
require(lti == 0);
|
|
|
|
>bg = basic_global();
|
|
require(bg == 0);
|
|
|
|
>bfp = basic_function_pointer();
|
|
require(bfp == 0);
|
|
|
|
basic_extern();
|
|
|
|
basic_byte_size();
|
|
|
|
>assignment_ops = assignment_operators();
|
|
require(assignment_ops == 0);
|
|
|
|
>np = not_pointer();
|
|
require(np == 0);
|
|
|
|
basic_bits();
|
|
|
|
bits_no_backing_type();
|
|
|
|
bits_return_u1();
|
|
|
|
bits_zero();
|
|
|
|
basic_comparison(argc);
|
|
|
|
basic_global_struct();
|
|
|
|
>if_ne = if_no_else();
|
|
require(if_ne == 0);
|
|
|
|
if_no_else_void();
|
|
|
|
basic_indirect();
|
|
|
|
indirect_varargs();
|
|
|
|
return 0;
|
|
}
|