[msan] Strip __interceptor_ from reports

[melver]

Summary

Showing __interceptor_ as part of the function name in reports does not
make sense and is distracting.

Strip the interceptor function name before printing.

Depends on D151319

[vitalybuka]

compiler-rt/lib/msan/msan_report.cpp

272

It's always called with func, can you please rename "what" to function

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp

44

there is common_flags()->demangle flag which sometimes useful as last resort
it could be nice if it applies to DemangleFunctionName and StripFunctionName

[melver]

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp

44

https://reviews.llvm.org/D151411

compiler-rt/lib/msan/msan_report.cpp

 //===-- msan_report.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of MemorySanitizer.
 //
 // Error reporting.
 //===----------------------------------------------------------------------===//
 
+#include "msan_report.h"
+
 #include "msan.h"
 #include "msan_chained_origin_depot.h"
 #include "msan_origin.h"
-#include "msan_report.h"
 #include "sanitizer_common/sanitizer_allocator_internal.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_flags.h"
 #include "sanitizer_common/sanitizer_mutex.h"
 #include "sanitizer_common/sanitizer_report_decorator.h"
 #include "sanitizer_common/sanitizer_stackdepot.h"
+#include "sanitizer_common/sanitizer_stacktrace_printer.h"
 #include "sanitizer_common/sanitizer_symbolizer.h"
 
 using namespace __sanitizer;
 
 namespace __msan {
 
 class Decorator: public __sanitizer::SanitizerCommonDecorator {
  public:
for (int i = 0; i < origin_set.size(); ++i) {
     u32 o = origin_set.get(i);
     Printf("Origin %c (origin_id %x):\n", OriginSet::asChar(i), o);
     DescribeOrigin(o);
   }
 }
 
 void ReportUMRInsideAddressRange(const char *what, const void *start, uptr size,
                                  uptr offset) {
+  what = StripFunctionName(what);
   Decorator d;
   Printf("%s", d.Warning());
   Printf("%sUninitialized bytes in %s%s%s at offset %zu inside [%p, %zu)%s\n",
          d.Warning(), d.Name(), what, d.Warning(), offset, start, size,
          d.Default());
   if (__sanitizer::Verbosity())
     DescribeMemoryRange(start, size);
 }
 
 }  // namespace __msan

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.h

 #ifndef SANITIZER_STACKTRACE_PRINTER_H
 #define SANITIZER_STACKTRACE_PRINTER_H
 
 #include "sanitizer_common.h"
 #include "sanitizer_symbolizer.h"
 
 namespace __sanitizer {
 
+// Strips interceptor prefixes from function name.
+const char *StripFunctionName(const char *function);
+
 // Render the contents of "info" structure, which represents the contents of
 // stack frame "frame_no" and appends it to the "buffer". "format" is a
 // string with placeholders, which is copied to the output with
 // placeholders substituted with the contents of "info". For example,
 // format string
 //   "  frame %n: function %F at %S"
 // will be turned into
 //   "  frame 10: function foo::bar() at my/file.cc:10"

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp

 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_stacktrace_printer.h"
 #include "sanitizer_file.h"
 #include "sanitizer_fuchsia.h"
 
 namespace __sanitizer {
 
-// sanitizer_symbolizer_markup.cpp implements these differently.
-#if !SANITIZER_SYMBOLIZER_MARKUP
-
-// Strips interceptor prefixes from function name.
-static const char *StripFunctionName(const char *function) {
+const char *StripFunctionName(const char *function) {
   if (!function)
     return nullptr;
   auto try_strip = [function](const char *prefix) -> const char * {
     const uptr prefix_len = internal_strlen(prefix);
     if (!internal_strncmp(function, prefix, prefix_len))
       return function + prefix_len;
     return nullptr;
   };
   if (SANITIZER_APPLE) {
     if (const char *s = try_strip("wrap_"))
       return s;
   } else {
     if (const char *s = try_strip("__interceptor_"))
       return s;
   }
   return function;
 }
 
+// sanitizer_symbolizer_markup.cpp implements these differently.
+#if !SANITIZER_SYMBOLIZER_MARKUP
+
 static const char *DemangleFunctionName(const char *function) {
   if (!function) return nullptr;
 
   // NetBSD uses indirection for old threading functions for historical reasons
   // The mangled names are internal implementation detail and should not be
   // exposed even in backtraces.
 #if SANITIZER_NETBSD
   if (!internal_strcmp(function, "__libc_mutex_init"))
     return "pthread_mutex_init";
   if (!internal_strcmp(function, "__libc_mutex_lock"))
     return "pthread_mutex_lock";
   if (!internal_strcmp(function, "__libc_mutex_trylock"))

compiler-rt/test/msan/Linux/b64.cpp

if (strcmp(test, "NTOP_READ") == 0) {
     // Check NTOP reading
     size_t src_len = 80;
     char src[src_len];
     __msan_poison(src, src_len);
     size_t dst_len = ((src_len + 2) / 3) * 4 + 1;
     char dst[dst_len];
     int res = b64_ntop(reinterpret_cast<const unsigned char *>(src), src_len,
                        dst, dst_len);
-    // NTOP_READ: Uninitialized bytes in __interceptor___b64_ntop
+    // NTOP_READ: Uninitialized bytes in __b64_ntop
     return 0;
   }
 
   if (strcmp(test, "PTON_READ") == 0) {
     // Check PTON reading
     size_t src_len = 80;
     char src[src_len];
     strcpy(src, "junk longer than zero");
     // pretend it is uninitialized
     __msan_poison(src, src_len);
     unsigned char target[src_len];
     int res = b64_pton(src, target, src_len);
-    // PTON_READ: Uninitialized bytes in __interceptor___b64_pton
+    // PTON_READ: Uninitialized bytes in __b64_pton
     return 0;
   }
 
   return 0;
 }

compiler-rt/test/msan/Linux/sendmsg.cpp

#if defined(SENDMMSG)
 
   struct mmsghdr mmsg[2];
   mmsg[0].msg_hdr = msg0; // good
   mmsg[1].msg_hdr = msg; // poisoned
 #endif
 
 #if defined(SEND)
   sent = send(sockfd[0], buf, kBufSize, 0);
-  // SEND: Uninitialized bytes in __interceptor_send at offset 7 inside [{{.*}}, 10)
+  // SEND: Uninitialized bytes in send at offset 7 inside [{{.*}}, 10)
   assert(sent > 0);
 
   ret = recv(sockfd[1], rbuf, kRecvBufSize, 0);
   assert(ret == sent);
   assert(__msan_test_shadow(rbuf, kRecvBufSize) == sent);
 #elif defined(SENDTO)
   sent = sendto(sockfd[0], buf, kBufSize, 0, nullptr, 0);
-  // SENDTO: Uninitialized bytes in __interceptor_sendto at offset 7 inside [{{.*}}, 10)
+  // SENDTO: Uninitialized bytes in sendto at offset 7 inside [{{.*}}, 10)
   assert(sent > 0);
 
   struct sockaddr_storage ss;
   socklen_t sslen = sizeof(ss);
   ret = recvfrom(sockfd[1], rbuf, kRecvBufSize, 0, (struct sockaddr *)&ss,
                  &sslen);
   assert(ret == sent);
   assert(__msan_test_shadow(rbuf, kRecvBufSize) == sent);

compiler-rt/test/msan/fgets_fputs.cpp

if (argc == 1)
     test_fgets();
   else if (argc == 2)
     test_fputs();
   else
     test_puts();
   return 0;
 }
 
-// CHECK-FPUTS: Uninitialized bytes in __interceptor_fputs at offset 0 inside
-// CHECK-PUTS: Uninitialized bytes in __interceptor_puts at offset 0 inside
+// CHECK-FPUTS: Uninitialized bytes in fputs at offset 0 inside
+// CHECK-PUTS: Uninitialized bytes in puts at offset 0 inside

compiler-rt/test/msan/fread_fwrite.cpp

 int main(int argc, char *argv[]) {
   if (argc > 1)
     test_fread();
   else
     test_fwrite();
   return 0;
 }
 
-// CHECK: Uninitialized bytes in __interceptor_fwrite at offset 0 inside
+// CHECK: Uninitialized bytes in fwrite at offset 0 inside

compiler-rt/test/msan/getaddrinfo-positive.cpp

 volatile int z;
 
 int main(void) {
   struct addrinfo *ai;
   struct addrinfo hint;
   int res = getaddrinfo("localhost", NULL, NULL, &ai);
   if (ai) z = 1; // OK
   res = getaddrinfo("localhost", NULL, &hint, &ai);
-  // CHECK: Uninitialized bytes in __interceptor_getaddrinfo at offset 0 inside [0x{{.*}}, 48)
+  // CHECK: Uninitialized bytes in getaddrinfo at offset 0 inside [0x{{.*}}, 48)
   // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
   // CHECK: #0 {{.*}} in main {{.*}}getaddrinfo-positive.cpp:[[@LINE-3]]
   return 0;
 }

compiler-rt/test/msan/scoped-interceptors.cpp

if (strcmp(argv[1], "--reenable-checks") == 0)
     __msan_scoped_enable_interceptor_checks();
 
   char uninit[7];
   switch (argv[2][0]) {
     case '0': {
       char *copy = strndup(uninit, sizeof(uninit));  // BOOM
       free(copy);
       break;
-      // CASE-0: Uninitialized bytes in __interceptor_strndup
+      // CASE-0: Uninitialized bytes in strndup
     }
     case '1': {
       puts(uninit);  // BOOM
       puts(uninit);  // Ensure previous call did not enable interceptor checks.
       break;
-      // CASE-1: Uninitialized bytes in __interceptor_puts
+      // CASE-1: Uninitialized bytes in puts
     }
     case '2': {
       int cmp = memcmp(uninit, uninit, sizeof(uninit));  // BOOM
       break;
       // CASE-2: Uninitialized bytes in MemcmpInterceptorCommon
     }
     case '3': {
       size_t len = strlen(uninit);  // BOOM
       break;
-      // CASE-3: Uninitialized bytes in __interceptor_strlen
+      // CASE-3: Uninitialized bytes in strlen
     }
     default: assert(0);
   }
   // DISABLED-NOT: Uninitialized bytes
   return 0;
 }
 

compiler-rt/test/msan/strndup.cpp

 
 int main(int argc, char **argv) {
   char kString[4] = "abc";
   __msan_poison(kString + 2, 1);
   char *copy = strndup(kString, 4); // BOOM
   assert(__msan_test_shadow(copy, 4) == 2); // Poisoning is preserved.
   free(copy);
   return 0;
-  // ON: Uninitialized bytes in __interceptor_{{(__)?}}strndup at offset 2 inside [{{.*}}, 4)
+  // ON: Uninitialized bytes in {{(__)?}}strndup at offset 2 inside [{{.*}}, 4)
   // ON: MemorySanitizer: use-of-uninitialized-value
   // ON: #0 {{.*}}main {{.*}}strndup.cpp:[[@LINE-6]]
   // ON-LABEL: SUMMARY
   // ON: {{.*}}strndup.cpp:[[@LINE-8]]
   // OFF-NOT: MemorySanitizer
 }