kit

123_spec_demo.toy (7280B)

---

 type Word = i64;
 type Fn1 = fn(Word): Word;
 
 record Node;
 
 record Pair {
   a: Word,
   b: Word,
 }
 
 record @[.packed] Header {
   tag: u8,
   len: u32,
 }
 
 record AlignedPair {
   first @[.align(16)]: i32,
   second: i32,
 }
 
 record Node {
   value: Word,
   next: *Node,
 }
 
 tuple Range {
   Word,
   Word,
 }
 
 enum Mode: i32 {
   .cold = 1,
   .warm = 2,
   .hot = 3,
 }
 
 extern fn imported_word(x: Word): Word;
 extern var @[.threadlocal, .tls_model(.local_exec)] imported_tls: i32;
 extern let imported_table: *u8;
 
 pub let answer: i32 = 42;
 pub let pi: f64 = 3.0;
 pub let msg: [6]u8 = "hi\n\x21\0\0";
 pub let numbers: [4]Word = [1, 2];
 pub var @[.common] tentative: Word;
 
 pub let pair_global: Pair = Pair { a: 4, b: 5 };
 pub let range_global: Range = Range { 10, 20 };
 pub var answer_ptr: *i32 = &answer;
 
 pub fn @[.bind(.weak), .visibility(.hidden), .section(".text.hot"), .hot,
          .stack_align(16), .target_features(""), .callconv(.target_c)]
 decorated(x @[.signext]: i8): i64 @[.zeroext] {
   return x as i64;
 }
 
 pub alias decorated_alias = decorated;
 
 fn add1(x: Word): Word {
   return x + 1;
 }
 
 fn tail_add1(x: Word): Word {
   return tail add1(x);
 }
 
 fn apply(fp: *Fn1, x: Word): Word {
   return fp(x);
 }
 
 fn restrict_first(p: restrict *Word): Word {
   return p[0];
 }
 
 fn borrowed(p @[.byref, .readonly, .noalias, .nonnull,
                 .dereferenceable(16)]: *Pair): Word {
   return p.a + p.b;
 }
 
 fn sum_var(n: Word, ...): Word {
   var ap: va_list;
   @va_start(ap);
   var cp: va_list;
   @va_copy(cp, ap);
   let first: Word = @va_arg<Word>(cp);
   @va_end(cp);
 
   var i: Word = 0;
   var total: Word = 0;
   while i < n {
     total = total + @va_arg<Word>(ap);
     i = i + 1;
   }
   @va_end(ap);
   return total + first;
 }
 
 fn static_next(): Word {
   var @[.static] id: Word = 40;
   id = id + 1;
   return id;
 }
 
 fn aggregate_demo(): Word {
   let p: Pair = Pair { a: 10 };
   var q: Pair = {};
   q.a = p.a;
   q.b = pair_global.b;
 
   let r: Range = Range { 3, 7 };
   let xs: [4]Word = [1, 2];
   let zeros: [3]Word = [];
   return q.a + q.b + r.0 + r.1 + xs[0] + xs[1] + zeros[2] +
          @add_overflow<Word>(40, 2).value +
          (@add_overflow<Word>(1, 1).overflow as Word) + @offsetof<Pair>(b) +
          @offsetof<Range>(1) + @sizeof<Header>() + @alignof<AlignedPair>();
 }
 
 fn enum_demo(mode: Mode): Word {
   let selected: Word = switch mode {
     .cold {
       1
     }
     .warm {
       2
     }
     .hot {
       3
     }
   };
 
   switch @[.branch_chain, .jump_table] mode {
     .cold {
       return selected + 10;
     }
     .warm, .hot {
       return selected + 20;
     }
   }
 
   return 0;
 }
 
 fn control_demo(limit: Word): Word {
   var i: Word = 0;
   var sum: Word = 0;
 
 outer: while i < limit {
     i = i + 1;
     if i == 2 {
       continue outer;
     }
     switch i {
       5 {
         break outer;
       }
       default {
       }
     }
     sum = sum + i;
   }
 
   let branch: Word = if sum > 5 {
     let base = sum;
     base + 1
   } else {
     0
   };
 
   var j: Word = 0;
   let found: Word = search: while<Word> j < 10 {
     if j == 4 {
       break search j;
     }
     j = j + 1;
     continue search;
   } else {
     -1
   };
 
   return branch + found;
 }
 
 fn memory_demo(n: usize): Word {
   let src: *Word = @alloca<Word>(2, 8);
   let dst: *Word = @alloca<Word>(2, 8);
   let tmp: *Word = @alloca<Word>(2, 8);
   src[0] = 20;
   src[1] = 22;
   @memset(dst, 0, n, 8, .volatile);
   @memcpy(dst, src, n, 8);
   @memmove(tmp, dst, n, 8);
   return restrict_first(tmp);
 }
 
 fn atomic_demo(): Word {
   var x: Word = 0;
   @atomic_store<Word>(&x, 40, .seq_cst, access(.align(8)));
   @atomic_rmw<Word>(.add, &x, 2, .seq_cst, access(.align(8)));
   let now: Word = @atomic_load<Word>(&x, .seq_cst, access(.align(8)));
   let cas = @atomic_cmpxchg<Word>(&x, now, 43, .seq_cst, .relaxed, .strong,
                                   access(.align(8)));
   @atomic_fence(.seq_cst);
   let legal: bool = @atomic_is_legal<Word>(.seq_cst, access(.align(8)));
   let lockfree: bool = @atomic_is_lock_free<Word>(access(.align(8)));
   // rv32 i64 atomics are legal via runtime shim but not lock-free.
   if legal and (lockfree or !lockfree) and cas.ok {
     return x - 1;
   }
   return 0;
 }
 
 fn intrinsic_demo(): Word {
   var x: Word = 7;
   let p: *Word = @assume_aligned<*Word>(&x, 8);
   @prefetch(p);
   let ov = @add_overflow<Word>(40, 2);
   let bits: Word = @bitget(@bitset(0, 3, 4, 4), 4, 4);
   let conv: Word = @float_to_sint<Word>(
       @sint_to_float<f64>(40, .default) +
       @uint_to_float<f64>(2, .nearest_even) + 0.75,
       .toward_zero);
   let ptr_roundtrip: *Word = @int_to_ptr<*Word>(@ptr_to_int<Word>(p));
   if ptr_roundtrip == NULL as *Word {
     return 0;
   }
   if ov.value != 42 {
     return 0;
   }
   if bits != 3 {
     return 0;
   }
   if conv != 42 {
     return 0;
   }
   if @popcount(x) != 3 {
     return 0;
   }
   if @ctz(8) != 3 {
     return 0;
   }
   if @clz(1) == 0 {
     return 0;
   }
   if @expect(1, 1) != 1 {
     return 0;
   }
   if @bswap(1 as Word) == 0 {
     return 0;
   }
   if (@fma(2.0, 3.0, 4.0) as Word) != 10 {
     return 0;
   }
   return 42;
 }
 
 fn target_demo(): Word {
   let arch_value: Word = switch @target_arch() {
     .x64 {
       1
     }
     .arm64 {
       2
     }
     .rv64 {
       3
     }
     default {
       4
     }
   };
   let cc_ok: bool = @supports_callconv(.target_c);
   let weak_known: bool = @supports_symbol_feature(.weak);
   let align_known: bool = @has_backend_feature(.unaligned_memory) or
                           @has_backend_feature(.strict_alignment);
   if (arch_value != 0) and cc_ok and (weak_known or !weak_known) and
      (align_known or !align_known) {
     return 1;
   }
   return 0;
 }
 
 fn label_demo(idx: isize): Word {
   label zero;
   label one;
   label done;
 
   let @[.static] dispatch: [2]*void = [
     @labeladdr(zero),
     @labeladdr(one),
   ];
 
   var out: Word = 0;
   goto *dispatch[idx] within (zero, one, done);
 
 zero:
   out = 11;
   goto *@labeladdr(done) within (done);
 one:
   out = 42;
 done:
   return out;
 }
 
 fn __user_main(): Word {
   let fp: *Fn1 = &add1;
   var local_pair: Pair = Pair { a: 12, b: 30 };
   var node: Node = Node { value: 8 };
   node.next = &node;
 
   tentative = numbers[0] + numbers[1];
 
   let mode: Mode = .warm;
   let addrspace_null: *addrspace(1) i32 = NULL as *addrspace(1) i32;
   let pointer_check: Word = if addrspace_null == NULL as *addrspace(1) i32 {
     1
   } else {
     0
   };
 
   if tail_add1(1) != 2 {
     return 1;
   }
   if apply(fp, 2) != 3 {
     return 2;
   }
   if borrowed(&local_pair) != 42 {
     return 3;
   }
   if node.next.value != 8 {
     return 4;
   }
   if decorated(5 as i8) != 5 {
     return 5;
   }
   if static_next() != 41 {
     return 6;
   }
   if static_next() != 42 {
     return 7;
   }
   if aggregate_demo() != 107 {
     return 8;
   }
   if enum_demo(mode) != 22 {
     return 9;
   }
   if control_demo(8) != 13 {
     return 10;
   }
   if memory_demo(16) != 20 {
     return 11;
   }
   if atomic_demo() != 42 {
     return 12;
   }
   if intrinsic_demo() != 42 {
     return 13;
   }
   if target_demo() != 1 {
     return 14;
   }
   if label_demo(1) != 42 {
     return 15;
   }
   if sum_var(3, 5 as Word, 6 as Word, 7 as Word) != 23 {
     return 16;
   }
   if (answer_ptr.* as Word) != 42 {
     return 17;
   }
   if pointer_check != 1 {
     return 18;
   }
 
   return 42;
 }
 
 fn main(): i32 { return __user_main() as i32; }