[Sanitizer] Add interceptor for wctomb

[labath]

Summary

This is required to avoid msan false positives for code using this
function (although generally one should avoid using this function in
favor of wcrtomb).

The interceptor and test code have been based on wcrtomb, with obvious
modifications.

[vitalybuka]

lib/msan/tests/msan_test.cc

2126 ↗

(On Diff #191312)

Please also create sanitizer_common lit tests just to make sure that function still works

lib/sanitizer_common/sanitizer_common_interceptors.inc

3549 ↗

(On Diff #191312)

I don't like that we add another FIXME here
Could you try to make something similar to https://reviews.llvm.org/rL211153

3552 ↗

(On Diff #191312)

write_cnt is not needed

[labath]

• add sanitizer_common test
• fix the "write to freed memory" issue by redirecting the function call to a local buffer. To know the size of the buffer I need to allocate, I needed to add a new "platform limits" constant for the value of MB_LEN_MAX (another option would be to use some upper bound which is large enough for all reasonable platforms, such as 32).

I'm very new to the sanitizer world, so I'm not sure I'm doing everything
correctly. Please let me know if I have done something wrong.

[vitalybuka]

lib/sanitizer_common/sanitizer_common_interceptors.inc

3549 ↗

(On Diff #191312)

could you avoid heap here?
with check local_dest[64] or any value large enough

[vitalybuka]

you may add CHECK_LE(res, sizeof(local_dst))

option would be to use some upper bound which is large enough for all
reasonable platforms, such as 32).

yes, this will be better, without heap

[labath]

avoid heap allocations by using a stack buffer of fixed size which "should be enough for everyone".

[labath]

Vitaly, Evgenii, do you have any more comments about this?

[vitalybuka]

LGTM

compiler-rt/trunk/lib/msan/tests/msan_test.cc

TEST(MemorySanitizer, wcrtomb) {
   char buff[10];
   mbstate_t mbs;
   memset(&mbs, 0, sizeof(mbs));
   size_t res = wcrtomb(buff, x, &mbs);
   EXPECT_EQ(res, (size_t)1);
   EXPECT_EQ(buff[0], 'a');
 }
 
+TEST(MemorySanitizer, wctomb) {
+  wchar_t x = L'a';
+  char buff[10];
+  wctomb(nullptr, x);
+  int res = wctomb(buff, x);
+  EXPECT_EQ(res, 1);
+  EXPECT_EQ(buff[0], 'a');
+  EXPECT_POISONED(buff[1]);
+}
+
 TEST(MemorySanitizer, wmemset) {
     wchar_t x[25];
     break_optimization(x);
     EXPECT_POISONED(x[0]);
     wmemset(x, L'A', 10);
     EXPECT_EQ(x[0], L'A');
     EXPECT_EQ(x[9], L'A');
     EXPECT_POISONED(x[10]);

compiler-rt/trunk/lib/sanitizer_common/sanitizer_common_interceptors.inc

INTERCEPTOR(SIZE_T, wcrtomb, char *dest, wchar_t src, void *ps) {
   return res;
 }
 
 #define INIT_WCRTOMB COMMON_INTERCEPT_FUNCTION(wcrtomb);
 #else
 #define INIT_WCRTOMB
 #endif
 
+#if SANITIZER_INTERCEPT_WCTOMB
+INTERCEPTOR(int, wctomb, char *dest, wchar_t src) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, wctomb, dest, src);
+  if (!dest)
+    return REAL(wctomb)(dest, src);
+
+  char local_dest[32];
+  int res = REAL(wctomb)(local_dest, src);
+  if (res != -1) {
+    CHECK_LE(res, sizeof(local_dest));
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dest, res);
+    REAL(memcpy)(dest, local_dest, res);
+  }
+  return res;
+}
+
+#define INIT_WCTOMB COMMON_INTERCEPT_FUNCTION(wctomb);
+#else
+#define INIT_WCTOMB
+#endif
+
 #if SANITIZER_INTERCEPT_TCGETATTR
 INTERCEPTOR(int, tcgetattr, int fd, void *termios_p) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, tcgetattr, fd, termios_p);
   // FIXME: under ASan the call below may write to freed memory and corrupt
   // its metadata. See
   // https://github.com/google/sanitizers/issues/321.
   int res = REAL(tcgetattr)(fd, termios_p);
static void InitializeCommonInterceptors() {
   INIT_GETCWD;
   INIT_GET_CURRENT_DIR_NAME;
   INIT_STRTOIMAX;
   INIT_MBSTOWCS;
   INIT_MBSNRTOWCS;
   INIT_WCSTOMBS;
   INIT_WCSNRTOMBS;
   INIT_WCRTOMB;
+  INIT_WCTOMB;
   INIT_TCGETATTR;
   INIT_REALPATH;
   INIT_CANONICALIZE_FILE_NAME;
   INIT_CONFSTR;
   INIT_SCHED_GETAFFINITY;
   INIT_SCHED_GETPARAM;
   INIT_STRERROR;
   INIT_STRERROR_R;

compiler-rt/trunk/lib/sanitizer_common/sanitizer_platform_interceptors.h

 #define SANITIZER_INTERCEPT_WCSXFRM SI_POSIX
 #define SANITIZER_INTERCEPT___WCSXFRM_L SI_LINUX
 #define SANITIZER_INTERCEPT_WCSNRTOMBS                                        \
   (SI_FREEBSD || SI_NETBSD || SI_OPENBSD || SI_MAC || SI_LINUX_NOT_ANDROID || \
   SI_SOLARIS)
 #define SANITIZER_INTERCEPT_WCRTOMB                                           \
   (SI_FREEBSD || SI_NETBSD || SI_OPENBSD || SI_MAC || SI_LINUX_NOT_ANDROID || \
   SI_SOLARIS)
+#define SANITIZER_INTERCEPT_WCTOMB                                           \
+  (SI_FREEBSD || SI_NETBSD || SI_OPENBSD || SI_MAC || SI_LINUX_NOT_ANDROID || \
+  SI_SOLARIS)
 #define SANITIZER_INTERCEPT_TCGETATTR SI_LINUX_NOT_ANDROID || SI_SOLARIS
 #define SANITIZER_INTERCEPT_REALPATH SI_POSIX
 #define SANITIZER_INTERCEPT_CANONICALIZE_FILE_NAME \
   (SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_CONFSTR                                           \
   (SI_FREEBSD || SI_NETBSD || SI_OPENBSD || SI_MAC || SI_LINUX_NOT_ANDROID || \
   SI_SOLARIS)
 #define SANITIZER_INTERCEPT_SCHED_GETAFFINITY SI_LINUX_NOT_ANDROID

compiler-rt/trunk/test/sanitizer_common/TestCases/wctomb.c

+// RUN: %clang %s -o %t && %run %t 2>&1
+
+#include <assert.h>
+#include <stdlib.h>
+
+int main(int argc, char **argv) {
+  char buff[10];
+  wchar_t x = L'a';
+  wctomb(NULL, x);
+  int res = wctomb(buff, x);
+  assert(res == 1);
+  assert(buff[0] == 'a');
+  return 0;
+}