Add create_tag(). compile.wat create a thunk tagged Runnable

src/fix-driver/compile.wat

@@ -5,20 +5,23 @@
   (import "fixpoint" "attach_tree_ro_table_1" (func $attach_tree_ro_table_1 (param externref)))
   (import "fixpoint" "attach_blob_ro_mem_0" (func $attach_blob_ro_mem_0 (param externref)))
   (import "fixpoint" "size_ro_mem_0" (func $size_ro_mem_0 (result i32)))
+  (import "fixpoint" "create_blob_rw_mem_0" (func $create_blob_rw_mem_0 (param i32) (result externref)))
   (import "fixpoint" "create_tree_rw_table_0" (func $create_tree_rw_table_0 (param i32) (result externref)))
   (import "fixpoint" "create_tree_rw_table_1" (func $create_tree_rw_table_1 (param i32) (result externref)))
   (import "fixpoint" "create_tree_rw_table_2" (func $create_tree_rw_table_2 (param i32) (result externref)))
   (import "fixpoint" "create_tree_rw_table_3" (func $create_tree_rw_table_3 (param i32) (result externref)))
   (import "fixpoint" "create_thunk" (func $create_thunk (param externref) (result externref)))
   (import "fixpoint" "equality" (func $equality (param externref externref) (result i32)))
+  (import "fixpoint" "create_tag" (func $create_tag (param externref externref) (result externref)))
   (memory $ro_mem_0 (export "ro_mem_0") 0)
   (table $ro_table_0 (export "ro_table_0") 0 externref)
   (table $ro_table_1 (export "ro_table_1") 0 externref)
+  (memory (export "rw_mem_0") (data "Runnable"))
   (table $rw_table_0 (export "rw_table_0") 3 externref)
   (table $rw_table_1 (export "rw_table_1") 4 externref)
   (table $rw_table_2 (export "rw_table_2") 4 externref)
   (table $rw_table_3 (export "rw_table_3") 3 externref)
-  (func (export "_fixpoint_apply") (param $encode externref) (result externref) (local $r externref) (local $input externref) (local $procedure externref) (local $input_parallelism i32)
+  (func (export "_fixpoint_apply") (param $encode externref) (result externref) (local $r externref) (local $input externref) (local $procedure externref) (local $input_parallelism i32) (local $runnable externref)
         (call $attach_tree_ro_table_0 (local.get $encode))
         (local.set $r (table.get $ro_table_0 (i32.const 0)))
         (local.set $input (table.get $ro_table_0 (i32.const 2)))
@@ -29,6 +32,9 @@
         i32.shr_u
         local.set $input_parallelism
 
+        (call $create_blob_rw_mem_0 (i32.const 8))
+        local.set $runnable
+
         ;; get name for compile
         (call $attach_tree_ro_table_0 (table.get $ro_table_0 (i32.const 1)))
 
@@ -67,10 +73,11 @@
                 (table.set $rw_table_3 (i32.const 1) (table.get $ro_table_0 (i32.const 2)))
                 (call $create_thunk (call $create_tree_rw_table_3 (i32.const 3)))
                 )
-              (else
-                (call $create_thunk (call $create_tree_rw_table_2 (i32.const 4)))
+              (else (call $create_thunk (call $create_tree_rw_table_2 (i32.const 4)))
                 )
               )
+            local.get $runnable
+            call $create_tag
             )
           (else
             unreachable)

src/serialize/handle.hh

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <experimental/bits/simd.h>
+#include <immintrin.h>
+
+#include <cassert>
+
+enum class ContentType : uint8_t
+{
+  Tree,
+  Thunk,
+  Blob,
+  Tag
+};
+
+class Handle
+{
+protected:
+  __m256i content_ {};
+
+  Handle() = default;
+
+  Handle( const __m256i val )
+    : content_( val )
+  {}
+
+  const char* data() const { return reinterpret_cast<const char*>( &content_ ); }
+
+  uint8_t metadata() const { return _mm256_extract_epi8( content_, 31 ); }
+
+  Handle( uint64_t a, uint64_t b, uint64_t c, uint64_t d )
+    : content_( __m256i { int64_t( a ), int64_t( b ), int64_t( c ), int64_t( d ) } )
+  {}
+
+  Handle( const std::array<char, 32>& input ) { __builtin_memcpy( &content_, input.data(), 32 ); }
+
+public:
+  operator __m256i() const { return content_; }
+
+  Handle( std::string hash, size_t size, ContentType content_type )
+  {
+    assert( hash.size() == 32 );
+    hash[31] = static_cast<char>( 0x04 | static_cast<uint8_t>( content_type ) );
+    __builtin_memcpy( &content_, hash.data(), 32 );
+    content_[2] = size;
+  }
+
+  /* Construct a Handle out of literal blob content */
+  Handle( std::string_view literal_content )
+  {
+    assert( literal_content.size() < 32 );
+    // set the handle to literal
+    uint8_t metadata = 0x20 | literal_content.size();
+    __builtin_memcpy( (char*)&content_, literal_content.data(), literal_content.size() );
+    __builtin_memcpy( (char*)&content_ + 31, &metadata, 1 );
+  }
+
+  std::array<int64_t, 4> get_i64() const { return { content_[0], content_[1], content_[2], content_[3] }; }
+};

src/wasm2c/initcomposer.cc

@@ -192,6 +192,7 @@ class InitComposer
   void write_get_attached_tree();
   void write_get_attached_blob();
   void write_equality();
+  void write_create_tag();
 };
 
 void InitComposer::write_context()
@@ -389,6 +390,15 @@ void InitComposer::write_equality()
   result_ << "}\n" << endl;
 }
 
+void InitComposer::write_create_tag()
+{
+  result_ << "extern __m256i fixpoint_create_tag(__m256i, __m256i);" << endl;
+  result_ << "__m256i " << ExportName( "fixpoint", "create_tag" )
+          << "(struct w2c_fixpoint* instance, __m256i value, __m256i constructor) {" << endl;
+  result_ << "  return fixpoint_create_tag( value, constructor );" << endl;
+  result_ << "}\n" << endl;
+}
+
 string InitComposer::compose_header()
 {
   result_ = ostringstream();
@@ -411,6 +421,7 @@ string InitComposer::compose_header()
   write_get_attached_tree();
   write_get_attached_blob();
   write_equality();
+  write_create_tag();
 
   result_ << "void initProgram(void* ptr) {" << endl;
   result_ << "  " << state_info_type_name_ << "* instance = (" << state_info_type_name_ << "*)ptr;" << endl;