Use utf conversions from minipal

src/coreclr/nativeaot/Runtime/eventpipe/CMakeLists.txt

@@ -9,15 +9,26 @@ set(AOT_EVENTPIPE_SHIM_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
 
 set (CONTAINER_SOURCES "")
 set (CONTAINER_HEADERS "")
+set (MINIPAL_SOURCES "")
+set (MINIPAL_HEADERS "")
 set (EVENTPIPE_SOURCES "")
 set (EVENTPIPE_HEADERS "")
 set (GEN_EVENTPIPE_SOURCES "")
 
 set (SHARED_CONTAINERS_SOURCE_PATH "${CLR_SRC_NATIVE_DIR}/containers")
 set (SHARED_EVENTPIPE_SOURCE_PATH "${CLR_SRC_NATIVE_DIR}/eventpipe")
+set (SHARED_MINIPAL_SOURCE_PATH "${CLR_SRC_NATIVE_DIR}/minipal")
 include (${SHARED_EVENTPIPE_SOURCE_PATH}/eventpipe.cmake)
 include (${SHARED_CONTAINERS_SOURCE_PATH}/containers.cmake)
 
+list(APPEND MINIPAL_SOURCES
+  utf8.c
+)
+
+list(APPEND MINIPAL_HEADERS
+  utf8.h
+)
+
 if(CLR_CMAKE_HOST_WIN32)
   list(APPEND SHARED_DIAGNOSTIC_SERVER_SOURCES
       ds-ipc-pal-namedpipe.c
@@ -50,6 +61,8 @@ list(APPEND EVENTPIPE_HEADERS
 
 addprefix(CONTAINER_SOURCES ${SHARED_CONTAINERS_SOURCE_PATH} "${SHARED_CONTAINER_SOURCES}")
 addprefix(CONTAINER_HEADERS ${SHARED_CONTAINERS_SOURCE_PATH} "${SHARED_CONTAINER_HEADERS}")
+addprefix(MINIPAL_SOURCES ${SHARED_MINIPAL_SOURCE_PATH} "${MINIPAL_SOURCES}")
+addprefix(MINIPAL_HEADERS ${SHARED_MINIPAL_SOURCE_PATH} "${MINIPAL_HEADERS}")
 
 addprefix(EVENTPIPE_SOURCES ${SHARED_EVENTPIPE_SOURCE_PATH} "${EVENTPIPE_SOURCES}")
 addprefix(EVENTPIPE_HEADERS ${SHARED_EVENTPIPE_SOURCE_PATH} "${EVENTPIPE_HEADERS}")
@@ -125,6 +138,8 @@ list(APPEND EVENTPIPE_SOURCES
   ${GEN_EVENTPIPE_SOURCES}
   ${CONTAINER_SOURCES}
   ${CONTAINER_HEADERS}
+  ${MINIPAL_SOURCES}
+  ${MINIPAL_HEADERS}
 )
 
 list(APPEND AOT_EVENTPIPE_DISABLED_SOURCES

src/coreclr/nativeaot/Runtime/eventpipe/ep-rt-aot.h

@@ -11,6 +11,8 @@
 #include <pthread.h>
 #endif
 
+#include <minipal/utf8.h>
+
 #include <eventpipe/ep-rt-config.h>
 #ifdef ENABLE_PERFTRACING
 #include <eventpipe/ep-thread.h>
@@ -1375,6 +1377,8 @@ ep_rt_utf8_string_replace (
     return false;
 }
 
+#define MINIPAL_MB_NO_REPLACE_INVALID_CHARS 0x00000008
+
 static
 ep_char16_t *
 ep_rt_utf8_to_utf16le_string (
@@ -1386,22 +1390,23 @@ ep_rt_utf8_to_utf16le_string (
     if (!str)
         return NULL;
 
-    // Shipping criteria: no EVENTPIPE-NATIVEAOT-TODO left in the codebase
-    // Implementation would just use strlen and malloc to make a new buffer, and would then copy the string chars one by one.
-    // Assumes that only ASCII is used for ep_char8_t
-    size_t len_utf8 = strlen(str);
-    ep_char16_t *str_utf16 = reinterpret_cast<ep_char16_t *>(malloc ((len_utf8 + 1) * sizeof (ep_char16_t)));
-    if (!str_utf16)
+    int32_t flags = MINIPAL_MB_NO_REPLACE_INVALID_CHARS;
+
+    ep_char16_t* lpDestStr = NULL;
+
+    if (static_cast<int>(len) < 0)
+        len = (size_t)strlen(str) + 1;
+
+    size_t ret = (size_t)minipal_get_length_utf8_to_utf16 (str, len, flags);
+
+    if (ret <= 0)
         return NULL;
 
-    for (size_t i = 0; i < len_utf8; i++)
-    {
-        EP_ASSERT(isascii(str[i]));
-         str_utf16[i] = str[i];
-    }
+    lpDestStr = reinterpret_cast<ep_char16_t *>(malloc((ret + 1) * sizeof(ep_char16_t)));
+    ret = (size_t)minipal_convert_utf8_to_utf16 (str, len, reinterpret_cast<CHAR16_T*>(lpDestStr), ret, flags);
+    lpDestStr[ret] = '\0';
 
-    str_utf16[len_utf8] = 0;
-    return str_utf16;
+    return lpDestStr;
 }
 
 static
@@ -1450,27 +1455,28 @@ ep_rt_utf16_to_utf8_string (
     size_t len)
 {
     STATIC_CONTRACT_NOTHROW;
-
     if (!str)
         return NULL;
-
-    // shipping criteria: no EVENTPIPE-NATIVEAOT-TODO left in the codebase
-    // Simple implementation to create a utf8 string from a utf16 one
-    size_t len_utf16 = len;
-    if(len_utf16 == (size_t)-1)
-        len_utf16 = ep_rt_utf16_string_len (str);
 
-    ep_char8_t *str_utf8 = reinterpret_cast<ep_char8_t *>(malloc ((len_utf16 + 1) * sizeof (ep_char8_t)));
-    if (!str_utf8)
-        return NULL;
+    ep_char8_t* lpDestStr = NULL;
+    if (static_cast<int>(len) < 0) {
+        len = 0;
+        while (str[len])
+            len++;
 
-    for (size_t i = 0; i < len_utf16; i++)
-    {
-         str_utf8[i] = (char)str[i];
+        len++;
     }
 
-    str_utf8[len_utf16] = 0;
-    return str_utf8;
+    size_t ret = (size_t)minipal_get_length_utf16_to_utf8 (reinterpret_cast<const CHAR16_T *>(str), len, 0);
+
+    if (ret <= 0)
+        return NULL;
+
+    lpDestStr = reinterpret_cast<ep_char8_t *>(malloc((ret + 1) * sizeof(ep_char8_t)));
+    ret = (size_t)minipal_convert_utf16_to_utf8 (reinterpret_cast<const CHAR16_T*>(str), len, lpDestStr, ret, 0);
+    lpDestStr[ret] = '\0';
+
+    return lpDestStr;
 }
 
 static

src/native/minipal/utf8.c

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#pragma warning(disable:4244)
+
 #include <minipal/utf8.h>
 
 #include <errno.h>