koffi 1.0.0 → 1.0.3

package/src/{call_x86.cc → abi_x86.cc}

@@ -82,11 +82,8 @@ bool AnalyseFunction(InstanceData *instance, FunctionInfo *func)
     return true;
 }
 
-Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, const Napi::CallbackInfo &info)
+Napi::Value CallData::Execute(const Napi::CallbackInfo &info)
 {
-    Napi::Env env = info.Env();
-    CallData call(env, instance, func);
-
     // Sanity checks
     if (info.Length() < (uint32_t)func->parameters.len) {
         ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len, info.Length());
@@ -98,14 +95,14 @@ Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, cons
     uint32_t *fast_ptr = nullptr;
 
     // Pass return value in register or through memory
-    if (RG_UNLIKELY(!call.AllocStack(func->args_size, 16, &args_ptr)))
+    if (RG_UNLIKELY(!AllocStack(func->args_size, 16, &args_ptr)))
         return env.Null();
     if (func->convention == CallConvention::Fastcall) {
         fast_ptr = args_ptr;
         args_ptr += 4;
     }
     if (!func->ret.trivial) {
-        if (RG_UNLIKELY(!call.AllocHeap(func->ret.type->size, 16, &return_ptr)))
+        if (RG_UNLIKELY(!AllocHeap(func->ret.type->size, 16, &return_ptr)))
             return env.Null();
         *((func->ret.fast ? fast_ptr : args_ptr)++) = (uint32_t)return_ptr;
     }
@@ -178,7 +175,7 @@ Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, cons
             case PrimitiveKind::String: {
                 const char *str;
                 if (RG_LIKELY(value.IsString())) {
-                    str = call.PushString(value);
+                    str = PushString(value);
                     if (RG_UNLIKELY(!str))
                         return env.Null();
                 } else if (IsNullOrUndefined(value)) {
@@ -190,6 +187,21 @@ Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, cons
 
                 *(const char **)((param.fast ? fast_ptr : args_ptr)++) = str;
             } break;
+            case PrimitiveKind::String16: {
+                const char16_t *str16;
+                if (RG_LIKELY(value.IsString())) {
+                    str16 = PushString16(value);
+                    if (RG_UNLIKELY(!str16))
+                        return env.Null();
+                } else if (IsNullOrUndefined(value)) {
+                    str16 = nullptr;
+                } else {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), i + 1);
+                    return env.Null();
+                }
+
+                *(const char16_t **)((param.fast ? fast_ptr : args_ptr)++) = str16;
+            } break;
             case PrimitiveKind::Pointer: {
                 uint8_t *ptr;
 
@@ -198,11 +210,11 @@ Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, cons
                 } else if (IsObject(value) && param.type->ref->primitive == PrimitiveKind::Record) {
                     Napi::Object obj = value.As<Napi::Object>();
 
-                    if (RG_UNLIKELY(!call.AllocHeap(param.type->ref->size, 16, &ptr)))
+                    if (RG_UNLIKELY(!AllocHeap(param.type->ref->size, 16, &ptr)))
                         return env.Null();
 
                     if (param.directions & 1) {
-                        if (!call.PushObject(obj, param.type->ref, ptr))
+                        if (!PushObject(obj, param.type->ref, ptr))
                             return env.Null();
                     } else {
                         memset(ptr, 0, param.type->size);
@@ -231,11 +243,11 @@ Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, cons
 
                 if (param.fast) {
                     uint8_t *ptr = (uint8_t *)(fast_ptr++);
-                    if (!call.PushObject(obj, param.type, ptr))
+                    if (!PushObject(obj, param.type, ptr))
                         return env.Null();
                 } else {
                     uint8_t *ptr = (uint8_t *)AlignUp(args_ptr, param.type->align);
-                    if (!call.PushObject(obj, param.type, ptr))
+                    if (!PushObject(obj, param.type, ptr))
                         return env.Null();
                     args_ptr = (uint32_t *)AlignUp(ptr + param.type->size, 4);
                 }
@@ -244,70 +256,76 @@ Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, cons
     }
 
     if (instance->debug) {
-        call.DumpDebug();
+        DumpDebug();
     }
 
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
-            auto ret = (func->convention == CallConvention::Fastcall ? ForwardCallR ## Suffix(func->func, call.GetSP()) \
-                                                                     : ForwardCall ## Suffix(func->func, call.GetSP())); \
+            auto ret = (func->convention == CallConvention::Fastcall ? ForwardCallR ## Suffix(func->func, GetSP()) \
+                                                                     : ForwardCall ## Suffix(func->func, GetSP())); \
             PopOutArguments(out_objects); \
             return ret; \
         })()
 
     // Execute and convert return value
     switch (func->ret.type->primitive) {
+        case PrimitiveKind::Void: {
+            PERFORM_CALL(G);
+            return env.Null();
+        } break;
+        case PrimitiveKind::Bool: {
+            uint32_t rax = (uint32_t)PERFORM_CALL(G);
+            return Napi::Boolean::New(env, rax);
+        } break;
+        case PrimitiveKind::Int8:
+        case PrimitiveKind::UInt8:
+        case PrimitiveKind::Int16:
+        case PrimitiveKind::UInt16:
+        case PrimitiveKind::Int32:
+        case PrimitiveKind::UInt32: {
+            uint32_t rax = (uint32_t)PERFORM_CALL(G);
+            return Napi::Number::New(env, (double)rax);
+        } break;
+        case PrimitiveKind::Int64: {
+            uint64_t ret = PERFORM_CALL(G);
+            return Napi::BigInt::New(env, (int64_t)ret);
+        } break;
+        case PrimitiveKind::UInt64: {
+            uint64_t ret = PERFORM_CALL(G);
+            return Napi::BigInt::New(env, ret);
+        } break;
         case PrimitiveKind::Float32: {
             float f = PERFORM_CALL(F);
-
             return Napi::Number::New(env, (double)f);
         } break;
-
         case PrimitiveKind::Float64: {
             double d = PERFORM_CALL(D);
-
             return Napi::Number::New(env, d);
         } break;
+        case PrimitiveKind::String: {
+            uint32_t rax = (uint32_t)PERFORM_CALL(G);
+            return Napi::String::New(env, (const char *)rax);
+        } break;
+        case PrimitiveKind::String16: {
+            uint32_t rax = (uint32_t)PERFORM_CALL(G);
+            return Napi::String::New(env, (const char16_t *)rax);
+        } break;
+        case PrimitiveKind::Pointer: {
+            uint32_t rax = (uint32_t)PERFORM_CALL(G);
+            void *ptr = (void *)rax;
+
+            Napi::External<void> external = Napi::External<void>::New(env, ptr);
+            SetValueTag(instance, external, func->ret.type);
+
+            return external;
+        } break;
+
+        case PrimitiveKind::Record: {
+            uint64_t ret = PERFORM_CALL(G);
+            const uint8_t *ptr = return_ptr ? return_ptr : (const uint8_t *)&ret;
 
-        default: {
-            // We can't directly use the struct as a return value, because not all platforms
-            // treat it the same: it is trivial only on Windows (see AnalyseFunction).
-            uint64_t raw = PERFORM_CALL(G);
-            struct {
-                uint32_t rax;
-                uint32_t rdx;
-            } ret;
-            memcpy(&ret, &raw, RG_SIZE(raw));
-
-            switch (func->ret.type->primitive) {
-                case PrimitiveKind::Void: return env.Null();
-                case PrimitiveKind::Bool: return Napi::Boolean::New(env, ret.rax);
-                case PrimitiveKind::Int8: return Napi::Number::New(env, (double)ret.rax);
-                case PrimitiveKind::UInt8: return Napi::Number::New(env, (double)ret.rax);
-                case PrimitiveKind::Int16: return Napi::Number::New(env, (double)ret.rax);
-                case PrimitiveKind::UInt16: return Napi::Number::New(env, (double)ret.rax);
-                case PrimitiveKind::Int32: return Napi::Number::New(env, (double)ret.rax);
-                case PrimitiveKind::UInt32: return Napi::Number::New(env, (double)ret.rax);
-                case PrimitiveKind::Int64: return Napi::BigInt::New(env, (int64_t)raw);
-                case PrimitiveKind::UInt64: return Napi::BigInt::New(env, raw);
-                case PrimitiveKind::Float32: { RG_UNREACHABLE(); } break;
-                case PrimitiveKind::Float64: { RG_UNREACHABLE(); } break;
-                case PrimitiveKind::String: return Napi::String::New(env, (const char *)ret.rax);
-                case PrimitiveKind::Pointer: {
-                    void *ptr = (void *)ret.rax;
-
-                    Napi::External<void> external = Napi::External<void>::New(env, ptr);
-                    SetValueTag(instance, external, func->ret.type);
-
-                    return external;
-                } break;
-
-                case PrimitiveKind::Record: {
-                    const uint8_t *ptr = return_ptr ? return_ptr : (const uint8_t *)&ret;
-                    Napi::Object obj = PopObject(env, ptr, func->ret.type);
-                    return obj;
-                } break;
-            }
+            Napi::Object obj = PopObject(env, ptr, func->ret.type);
+            return obj;
         } break;
     }
 

package/src/call.cc

@@ -0,0 +1,228 @@
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+#include "vendor/libcc/libcc.hh"
+#include "call.hh"
+#include "ffi.hh"
+#include "util.hh"
+
+#include <napi.h>
+
+namespace RG {
+
+CallData::CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func)
+    : env(env), instance(instance), func(func),
+      stack_mem(&instance->stack_mem), heap_mem(&instance->heap_mem),
+      old_stack_mem(instance->stack_mem), old_heap_mem(instance->heap_mem)
+{
+    RG_ASSERT(AlignUp(stack_mem->ptr, 16) == stack_mem->ptr);
+    RG_ASSERT(AlignUp(stack_mem->end(), 16) == stack_mem->end());
+}
+
+CallData::~CallData()
+{
+    instance->stack_mem = old_stack_mem;
+    instance->heap_mem = old_heap_mem;
+}
+
+const char *CallData::PushString(const Napi::Value &value)
+{
+    RG_ASSERT(value.IsString());
+
+    Napi::Env env = value.Env();
+
+    Span<char> buf;
+    size_t len = 0;
+    napi_status status;
+
+    buf.ptr = (char *)heap_mem->ptr;
+    buf.len = std::max((Size)0, heap_mem->len - Kibibytes(32));
+
+    status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
+    RG_ASSERT(status == napi_ok);
+
+    len++;
+
+    if (RG_LIKELY(len < (size_t)buf.len)) {
+        heap_mem->ptr += (Size)len;
+        heap_mem->len -= (Size)len;
+    } else {
+        status = napi_get_value_string_utf8(env, value, nullptr, 0, &len);
+        RG_ASSERT(status == napi_ok);
+
+        len++;
+
+        buf.ptr = (char *)Allocator::Allocate(&big_alloc, (Size)len);
+        buf.len = (Size)len;
+
+        status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
+        RG_ASSERT(status == napi_ok);
+    }
+
+    return buf.ptr;
+}
+
+const char16_t *CallData::PushString16(const Napi::Value &value)
+{
+    RG_ASSERT(value.IsString());
+
+    Napi::Env env = value.Env();
+
+    Span<char16_t> buf;
+    size_t len = 0;
+    napi_status status;
+
+    buf.ptr = (char16_t *)heap_mem->ptr;
+    buf.len = std::max((Size)0, heap_mem->len - Kibibytes(32)) / 2;
+
+    status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
+    RG_ASSERT(status == napi_ok);
+
+    len++;
+
+    if (RG_LIKELY(len < (size_t)buf.len)) {
+        heap_mem->ptr += (Size)len * 2;
+        heap_mem->len -= (Size)len * 2;
+    } else {
+        status = napi_get_value_string_utf16(env, value, nullptr, 0, &len);
+        RG_ASSERT(status == napi_ok);
+
+        len++;
+
+        buf.ptr = (char16_t *)Allocator::Allocate(&big_alloc, (Size)len * 2);
+        buf.len = (Size)len;
+
+        status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
+        RG_ASSERT(status == napi_ok);
+    }
+
+    return buf.ptr;
+}
+
+bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest)
+{
+    Napi::Env env = obj.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    RG_ASSERT(IsObject(obj));
+    RG_ASSERT(type->primitive == PrimitiveKind::Record);
+
+    for (const RecordMember &member: type->members) {
+        Napi::Value value = obj.Get(member.name);
+
+        if (RG_UNLIKELY(value.IsUndefined())) {
+            ThrowError<Napi::TypeError>(env, "Missing expected object property '%1'", member.name);
+            return false;
+        }
+
+        dest = AlignUp(dest, member.align);
+
+        switch (member.type->primitive) {
+            case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+
+            case PrimitiveKind::Bool: {
+                if (RG_UNLIKELY(!value.IsBoolean())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected boolean", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                bool b = value.As<Napi::Boolean>();
+                *(bool *)dest = b;
+            } break;
+
+            case PrimitiveKind::Int8:
+            case PrimitiveKind::UInt8:
+            case PrimitiveKind::Int16:
+            case PrimitiveKind::UInt16:
+            case PrimitiveKind::Int32:
+            case PrimitiveKind::UInt32:
+            case PrimitiveKind::Int64:
+            case PrimitiveKind::UInt64: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                int64_t v = CopyNumber<int64_t>(value);
+                memcpy(dest, &v, member.type->size); // Little Endian
+            } break;
+            case PrimitiveKind::Float32: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                float f = CopyNumber<float>(value);
+                memcpy(dest, &f, 4);
+            } break;
+            case PrimitiveKind::Float64: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                double d = CopyNumber<double>(value);
+                memcpy(dest, &d, 8);
+            } break;
+            case PrimitiveKind::String: {
+                if (RG_UNLIKELY(!value.IsString())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected string", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                const char *str = PushString(value);
+                if (RG_UNLIKELY(!str))
+                    return false;
+                *(const char **)dest = str;
+            } break;
+            case PrimitiveKind::String16: {
+                if (RG_UNLIKELY(!value.IsString())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected string", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                const char16_t *str16 = PushString16(value);
+                if (RG_UNLIKELY(!str16))
+                    return false;
+                *(const char16_t **)dest = str16;
+            } break;
+            case PrimitiveKind::Pointer: {
+                if (RG_UNLIKELY(!CheckValueTag(instance, value, member.type))) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected %3", GetValueType(instance, value), member.name, member.type->name);
+                    return false;
+                }
+
+                Napi::External external = value.As<Napi::External<void>>();
+                void *ptr = external.Data();
+                *(void **)dest = ptr;
+            } break;
+
+            case PrimitiveKind::Record: {
+                if (RG_UNLIKELY(!IsObject(value))) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected object", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                Napi::Object obj = value.As<Napi::Object>();
+                if (!PushObject(obj, member.type, dest))
+                    return false;
+            } break;
+        }
+
+        dest += member.type->size;
+    }
+
+    return true;
+}
+
+}

package/src/call.hh

@@ -14,15 +14,107 @@
 #pragma once
 
 #include "vendor/libcc/libcc.hh"
+#include "ffi.hh"
+#include "util.hh"
 
 #include <napi.h>
 
 namespace RG {
 
-struct InstanceData;
-struct FunctionInfo;
-
 bool AnalyseFunction(InstanceData *instance, FunctionInfo *func);
-Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, const Napi::CallbackInfo &info);
+
+class CallData {
+    Napi::Env env;
+    InstanceData *instance;
+    const FunctionInfo *func;
+
+    Span<uint8_t> *stack_mem;
+    Span<uint8_t> *heap_mem;
+    BlockAllocator big_alloc;
+
+    Span<uint8_t> old_stack_mem;
+    Span<uint8_t> old_heap_mem;
+
+public:
+    CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func);
+    ~CallData();
+
+    Span<uint8_t> GetStack() const
+    {
+        uint8_t *sp = stack_mem->end();
+        Size len = old_stack_mem.end() - sp;
+
+        return MakeSpan(sp, len);
+    }
+    uint8_t *GetSP() const { return stack_mem->end(); };
+
+    Span<uint8_t> GetHeap() const
+    {
+        uint8_t *ptr = old_heap_mem.ptr;
+        Size len = heap_mem->ptr - ptr;
+
+        return MakeSpan(ptr, len);
+    }
+
+    template <typename T = void>
+    bool AllocStack(Size size, Size align, T **out_ptr = nullptr);
+    template <typename T = void>
+    bool AllocHeap(Size size, Size align, T **out_ptr = nullptr);
+
+    const char *PushString(const Napi::Value &value);
+    const char16_t *PushString16(const Napi::Value &value);
+    bool PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest);
+
+    void DumpDebug() const;
+
+    Napi::Value Execute(const Napi::CallbackInfo &info);
+};
+
+template <typename T>
+bool CallData::AllocStack(Size size, Size align, T **out_ptr)
+{
+    uint8_t *ptr = AlignDown(stack_mem->end() - size, align);
+    Size delta = stack_mem->end() - ptr;
+
+    if (RG_UNLIKELY(stack_mem->len < delta)) {
+        ThrowError<Napi::Error>(env, "FFI call is taking up too much memory");
+        return false;
+    }
+
+    if (instance->debug) {
+        memset(ptr, 0, delta);
+    }
+
+    stack_mem->len -= delta;
+
+    if (out_ptr) {
+        *out_ptr = (T *)ptr;
+    }
+    return true;
+}
+
+template <typename T>
+bool CallData::AllocHeap(Size size, Size align, T **out_ptr)
+{
+    uint8_t *ptr = AlignUp(heap_mem->ptr, align);
+    Size delta = size + (ptr - heap_mem->ptr);
+
+    if (RG_UNLIKELY(delta > heap_mem->len)) {
+        ThrowError<Napi::Error>(env, "FFI call is taking up too much memory");
+        return false;
+    }
+
+    if (instance->debug) {
+        memset(heap_mem->ptr, 0, (size_t)delta);
+    }
+
+    heap_mem->ptr += delta;
+    heap_mem->len -= delta;
+
+    if (out_ptr) {
+        *out_ptr = (T *)ptr;
+    }
+    return true;
+}
 
 }

package/src/ffi.cc

@@ -247,7 +247,8 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
     InstanceData *instance = env.GetInstanceData<InstanceData>();
     FunctionInfo *func = (FunctionInfo *)info.Data();
 
-    return TranslateCall(instance, func, info);
+    CallData call(env, instance, func);
+    return call.Execute(info);
 }
 
 static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
@@ -299,7 +300,8 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
     if (!AnalyseFunction(instance, &func))
         return env.Null();
 
-    return TranslateCall(instance, &func, info);
+    CallData call(env, instance, &func);
+    return call.Execute(info);
 }
 
 static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value ret,
@@ -319,7 +321,7 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
     }
 #endif
 
-    func->name = DuplicateString(std::string(name).c_str(), &instance->str_alloc).ptr;
+    func->name = DuplicateString(name.ToString().Utf8Value().c_str(), &instance->str_alloc).ptr;
 
     func->ret.type = ResolveType(instance, ret);
     if (!func->ret.type)
@@ -573,6 +575,8 @@ static Napi::Object InitBaseTypes(Napi::Env env)
     RegisterPrimitiveType(instance, "char", PrimitiveKind::Int8, 1, 1);
     RegisterPrimitiveType(instance, "uchar", PrimitiveKind::UInt8, 1, 1);
     RegisterPrimitiveType(instance, "unsigned char", PrimitiveKind::UInt8, 1, 1);
+    RegisterPrimitiveType(instance, "char16", PrimitiveKind::Int16, 2, 2);
+    RegisterPrimitiveType(instance, "char16_t", PrimitiveKind::Int16, 2, 2);
     RegisterPrimitiveType(instance, "int16", PrimitiveKind::Int16, 2, 2);
     RegisterPrimitiveType(instance, "int16_t", PrimitiveKind::Int16, 2, 2);
     RegisterPrimitiveType(instance, "uint16", PrimitiveKind::UInt16, 2, 2);
@@ -603,6 +607,7 @@ static Napi::Object InitBaseTypes(Napi::Env env)
     RegisterPrimitiveType(instance, "float", PrimitiveKind::Float32, 4, alignof(float));
     RegisterPrimitiveType(instance, "double", PrimitiveKind::Float64, 8, alignof(double));
     RegisterPrimitiveType(instance, "string", PrimitiveKind::String, RG_SIZE(void *), alignof(void *));
+    RegisterPrimitiveType(instance, "string16", PrimitiveKind::String16, RG_SIZE(void *), alignof(void *));
 
     Napi::Object types = Napi::Object::New(env);
     for (TypeInfo &type: instance->types) {

package/src/ffi.hh

@@ -39,6 +39,7 @@ enum class PrimitiveKind {
     Float32,
     Float64,
     String,
+    String16,
 
     Pointer,
 
@@ -59,6 +60,7 @@ static const char *const PrimitiveKindNames[] = {
     "Float32",
     "Float64",
     "String",
+    "String16",
 
     "Pointer",