[msan] Remove StackTrace::tag

[vitalybuka]

Summary

The current implementation makes all sanitizers to track this value,
however even for msan this information constructed from this tag is
redundant and obvious from the stack itself.

There is simple way to implement this msan-only, but I does not look useful.

[eugenis]

Hmm, I really like this info.

As a data point, we had user feedback that bug classification in hwasan (use-after-free vs overflow vs other kinds) is very useful even though it is pretty obvious if you think about how tags work - but that's extra work for the users, and requires better understanding of the tool.

[vitalybuka]

In D110880#3034795, @eugenis wrote:

Hmm, I really like this info.

As a data point, we had user feedback that bug classification in hwasan (use-after-free vs overflow vs other kinds) is very useful even though it is pretty obvious if you think about how tags work - but that's extra work for the users, and requires better understanding of the tool.

Tags are more complicated, but when stack has malloc() frame it's very obvious, up to the point that reporting code can print this parsing the stack.

[vitalybuka]

missing tests

[vitalybuka]

documentation

clang/docs/MemorySanitizer.rst

.. code-block:: console
     WARNING: MemorySanitizer: use-of-uninitialized-value
         #0 0x7f7893912f0b in main umr2.cc:7
         #1 0x7f789249b76c in __libc_start_main libc-start.c:226
 
       Uninitialized value was stored to memory at
         #0 0x7f78938b5c25 in __msan_chain_origin msan.cc:484
         #1 0x7f7893912ecd in main umr2.cc:6
 
-      Uninitialized value was created by a heap allocation
+      Uninitialized value was created
         #0 0x7f7893901cbd in operator new[](unsigned long) msan_new_delete.cc:44
         #1 0x7f7893912e06 in main umr2.cc:4
 
 By default, MemorySanitizer collects both allocation points and all
 intermediate stores the uninitialized value went through.  Origin
 tracking has proved to be very useful for debugging MemorySanitizer
 reports. It slows down program execution by a factor of 1.5x-2x on top
 of the usual MemorySanitizer slowdown and increases memory overhead.

compiler-rt/lib/msan/msan.h

 // Unpoison first n function arguments.
 void UnpoisonParam(uptr n);
 void UnpoisonThreadLocalState();
 
 // Returns a "chained" origin id, pointing to the given stack trace followed by
 // the previous origin id.
 u32 ChainOrigin(u32 id, StackTrace *stack);
 
-const int STACK_TRACE_TAG_POISON = StackTrace::TAG_CUSTOM + 1;
-
 #define GET_MALLOC_STACK_TRACE                                            \
   BufferedStackTrace stack;                                               \
   if (__msan_get_track_origins() && msan_inited)                          \
     stack.Unwind(StackTrace::GetCurrentPc(), GET_CURRENT_FRAME(),         \
                  nullptr, common_flags()->fast_unwind_on_malloc,          \
                  common_flags()->malloc_context_size)
 
 // For platforms which support slow unwinder only, we restrict the store context

compiler-rt/lib/msan/msan.cpp

 }
 
 u32 ChainOrigin(u32 id, StackTrace *stack) {
   MsanThread *t = GetCurrentThread();
   if (t && t->InSignalHandler())
     return id;
 
   Origin o = Origin::FromRawId(id);
-  stack->tag = StackTrace::TAG_UNKNOWN;
   Origin chained = Origin::CreateChainedOrigin(o, stack);
   return chained.raw_id();
 }
 
 } // namespace __msan
 
 void __sanitizer::BufferedStackTrace::UnwindImpl(
     uptr pc, uptr bp, void *context, bool request_fast, u32 max_depth) {

compiler-rt/lib/msan/msan_allocator.cpp

static void *MsanAllocate(StackTrace *stack, uptr size, uptr alignment,
   Metadata *meta =
       reinterpret_cast<Metadata *>(allocator.GetMetaData(allocated));
   meta->requested_size = size;
   if (zeroise) {
     __msan_clear_and_unpoison(allocated, size);
   } else if (flags()->poison_in_malloc) {
     __msan_poison(allocated, size);
     if (__msan_get_track_origins()) {
-      stack->tag = StackTrace::TAG_ALLOC;
       Origin o = Origin::CreateHeapOrigin(stack);
       __msan_set_origin(allocated, size, o.raw_id());
     }
   }
   MSAN_MALLOC_HOOK(allocated, size);
   return allocated;
 }
 
 void MsanDeallocate(StackTrace *stack, void *p) {
   CHECK(p);
   MSAN_FREE_HOOK(p);
   Metadata *meta = reinterpret_cast<Metadata *>(allocator.GetMetaData(p));
   uptr size = meta->requested_size;
   meta->requested_size = 0;
   // This memory will not be reused by anyone else, so we are free to keep it
   // poisoned.
   if (flags()->poison_in_free) {
     __msan_poison(p, size);
     if (__msan_get_track_origins()) {
-      stack->tag = StackTrace::TAG_DEALLOC;
       Origin o = Origin::CreateHeapOrigin(stack);
       __msan_set_origin(p, size, o.raw_id());
     }
   }
   MsanThread *t = GetCurrentThread();
   if (t) {
     AllocatorCache *cache = GetAllocatorCache(&t->malloc_storage());
     allocator.Deallocate(cache, p);
static void *MsanReallocate(StackTrace *stack, void *old_p, uptr new_size,
   Metadata *meta = reinterpret_cast<Metadata*>(allocator.GetMetaData(old_p));
   uptr old_size = meta->requested_size;
   uptr actually_allocated_size = allocator.GetActuallyAllocatedSize(old_p);
   if (new_size <= actually_allocated_size) {
     // We are not reallocating here.
     meta->requested_size = new_size;
     if (new_size > old_size) {
       if (flags()->poison_in_malloc) {
-        stack->tag = StackTrace::TAG_ALLOC;
         PoisonMemory((char *)old_p + old_size, new_size - old_size, stack);
       }
     }
     return old_p;
   }
   uptr memcpy_size = Min(new_size, old_size);
   void *new_p = MsanAllocate(stack, new_size, alignment, false /*zeroise*/);
   if (new_p) {

compiler-rt/lib/msan/msan_interceptors.cpp

if (UNLIKELY(!msan_inited))
     // Hack: dlsym calls malloc before REAL(malloc) is retrieved from dlsym.
     return AllocateFromLocalPool(size);
   return msan_malloc(size, &stack);
 }
 
 void __msan_allocated_memory(const void *data, uptr size) {
   GET_MALLOC_STACK_TRACE;
   if (flags()->poison_in_malloc) {
-    stack.tag = STACK_TRACE_TAG_POISON;
     PoisonMemory(data, size, &stack);
   }
 }
 
 void __msan_copy_shadow(void *dest, const void *src, uptr n) {
   GET_STORE_STACK_TRACE;
   MoveShadowAndOrigin(dest, src, n, &stack);
 }
 
 void __sanitizer_dtor_callback(const void *data, uptr size) {
   GET_MALLOC_STACK_TRACE;
   if (flags()->poison_in_dtor) {
-    stack.tag = STACK_TRACE_TAG_POISON;
     PoisonMemory(data, size, &stack);
   }
 }
 
 template <class Mmap>
 static void *mmap_interceptor(Mmap real_mmap, void *addr, SIZE_T length,
                               int prot, int flags, int fd, OFF64_T offset) {
   SIZE_T rounded_length = RoundUpTo(length, GetPageSize());

compiler-rt/lib/msan/msan_report.cpp

while (o.isChainedOrigin()) {
     stack.Print();
   }
   if (o.isStackOrigin()) {
     uptr pc;
     const char *so = GetStackOriginDescr(o.getStackId(), &pc);
     DescribeStackOrigin(so, pc);
   } else {
     StackTrace stack = o.getStackTraceForHeapOrigin();
-    switch (stack.tag) {
-      case StackTrace::TAG_ALLOC:
-        Printf("  %sUninitialized value was created by a heap allocation%s\n",
-               d.Origin(), d.Default());
-        break;
-      case StackTrace::TAG_DEALLOC:
-        Printf("  %sUninitialized value was created by a heap deallocation%s\n",
-               d.Origin(), d.Default());
-        break;
-      case STACK_TRACE_TAG_POISON:
-        Printf("  %sMemory was marked as uninitialized%s\n", d.Origin(),
-               d.Default());
-        break;
-      default:
-        Printf("  %sUninitialized value was created%s\n", d.Origin(),
-               d.Default());
-        break;
-    }
+    Printf("  %sUninitialized value was created%s\n", d.Origin(), d.Default());
     stack.Print();
   }
 }
 
 void ReportUMR(StackTrace *stack, u32 origin) {
   if (!__msan::flags()->report_umrs) return;
 
   ScopedErrorReportLock l;

compiler-rt/lib/sanitizer_common/sanitizer_stackdepot.cpp

 
 namespace __sanitizer {
 
 struct StackDepotNode {
   StackDepotNode *link;
   u32 id;
   atomic_uint32_t hash_and_use_count; // hash_bits : 12; use_count : 20;
   u32 size;
-  u32 tag;
   uptr stack[1];  // [size]
 
   static const u32 kTabSizeLog = SANITIZER_ANDROID ? 16 : 20;
   // Lower kTabSizeLog bits are equal for all items in one bucket.
   // We use these bits to store the per-stack use counter.
   static const u32 kUseCountBits = kTabSizeLog;
   static const u32 kMaxUseCount = 1 << kUseCountBits;
   static const u32 kUseCountMask = (1 << kUseCountBits) - 1;
   static const u32 kHashMask = ~kUseCountMask;
 
   typedef StackTrace args_type;
   bool eq(u32 hash, const args_type &args) const {
     u32 hash_bits =
         atomic_load(&hash_and_use_count, memory_order_relaxed) & kHashMask;
-    if ((hash & kHashMask) != hash_bits || args.size != size || args.tag != tag)
+    if ((hash & kHashMask) != hash_bits || args.size != size)
       return false;
     uptr i = 0;
     for (; i < size; i++) {
       if (stack[i] != args.trace[i]) return false;
     }
     return true;
   }
   static uptr storage_size(const args_type &args) {
     return sizeof(StackDepotNode) + (args.size - 1) * sizeof(uptr);
   }
   static u32 hash(const args_type &args) {
     MurMur2HashBuilder H(args.size * sizeof(uptr));
     for (uptr i = 0; i < args.size; i++) H.add(args.trace[i]);
     return H.get();
   }
   static bool is_valid(const args_type &args) {
     return args.size > 0 && args.trace;
   }
   void store(const args_type &args, u32 hash) {
     atomic_store(&hash_and_use_count, hash & kHashMask, memory_order_relaxed);
     size = args.size;
-    tag = args.tag;
     internal_memcpy(stack, args.trace, size * sizeof(uptr));
   }
-  args_type load() const {
-    return args_type(&stack[0], size, tag);
-  }
+  args_type load() const { return args_type(&stack[0], size); }
   StackDepotHandle get_handle() { return StackDepotHandle(this); }
 
   typedef StackDepotHandle handle_type;
 };
 
 COMPILER_CHECK(StackDepotNode::kMaxUseCount == (u32)kStackDepotMaxUseCount);
 
 u32 StackDepotHandle::id() { return node_->id; }

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.h

 #  define SANITIZER_CAN_SLOW_UNWIND 0
 #else
 # define SANITIZER_CAN_SLOW_UNWIND 1
 #endif
 
 struct StackTrace {
   const uptr *trace;
   u32 size;
-  u32 tag;
 
-  static const int TAG_UNKNOWN = 0;
-  static const int TAG_ALLOC = 1;
-  static const int TAG_DEALLOC = 2;
-  static const int TAG_CUSTOM = 100; // Tool specific tags start here.
-
-  StackTrace() : trace(nullptr), size(0), tag(0) {}
-  StackTrace(const uptr *trace, u32 size) : trace(trace), size(size), tag(0) {}
-  StackTrace(const uptr *trace, u32 size, u32 tag)
-      : trace(trace), size(size), tag(tag) {}
+  StackTrace() : trace(nullptr), size(0) {}
+  StackTrace(const uptr *trace, u32 size) : trace(trace), size(size) {}
 
   // Prints a symbolized stacktrace, followed by an empty line.
   void Print() const;
 
   // Prints a symbolized stacktrace to the output string, followed by an empty
   // line.
   void PrintTo(InternalScopedString *output) const;
 

compiler-rt/test/msan/chained_origin.cpp

 // CHECK-FULL-STACK: {{#0 .* in fn_g.*chained_origin.cpp:}}[[@LINE-34]]
 // CHECK-FULL-STACK: {{#1 .* in fn_f.*chained_origin.cpp:}}[[@LINE-30]]
 // CHECK-FULL-STACK: {{#2 .* in main.*chained_origin.cpp:}}[[@LINE-16]]
 // CHECK-SHORT-STACK: {{#0 .* in fn_g.*chained_origin.cpp:}}[[@LINE-37]]
 
 // CHECK-STACK: Uninitialized value was created by an allocation of 'z' in the stack frame of function 'main'
 // CHECK-STACK: {{#0 .* in main.*chained_origin.cpp:}}[[@LINE-27]]
 
-// CHECK-HEAP: Uninitialized value was created by a heap allocation
+// CHECK-HEAP: Uninitialized value was created
 // CHECK-HEAP: {{#1 .* in main.*chained_origin.cpp:}}[[@LINE-28]]

compiler-rt/test/msan/check_mem_is_initialized.cpp

 
 int main(int argc, char **argv) {
   int *volatile p = (int *)malloc(sizeof(int));
 
   __msan_check_mem_is_initialized(p, sizeof(*p));
   // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
   // CHECK: {{#0 0x.* in main .*check_mem_is_initialized.cpp:}}[[@LINE-2]]
 
-  // CHECK-ORIGINS: Uninitialized value was created by a heap allocation
+  // CHECK-ORIGINS: Uninitialized value was created
   // CHECK-ORIGINS: {{#0 0x.* in .*malloc}}
   // CHECK-ORIGINS: {{#1 0x.* in main .*check_mem_is_initialized.cpp:}}[[@LINE-8]]
   return 0;
 }

compiler-rt/test/msan/dso-origin.cpp

 int main(int argc, char **argv) {
   int *x = (int *)my_alloc(sizeof(int));
   my_access(x);
   delete x;
 
   // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
   // CHECK: {{#0 0x.* in my_access .*dso-origin.cpp:}}
   // CHECK: {{#1 0x.* in main .*dso-origin.cpp:}}[[@LINE-5]]
-  // CHECK: Uninitialized value was created by a heap allocation
+  // CHECK: Uninitialized value was created
   // CHECK: {{#0 0x.* in .*malloc}}
   // CHECK: {{#1 0x.* in my_alloc .*dso-origin.cpp:}}
   // CHECK: {{#2 0x.* in main .*dso-origin.cpp:}}[[@LINE-10]]
   // CHECK: SUMMARY: MemorySanitizer: use-of-uninitialized-value {{.*dso-origin.cpp:.* my_access}}
   return 0;
 }
 
 #endif  // BUILD_SO

compiler-rt/test/msan/heap-origin.cpp

 
 #include <stdlib.h>
 int main(int argc, char **argv) {
   char *volatile x = (char*)malloc(5 * sizeof(char));
   return *x;
   // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
   // CHECK: {{#0 0x.* in main .*heap-origin.cpp:}}[[@LINE-2]]
 
-  // CHECK-ORIGINS: Uninitialized value was created by a heap allocation
+  // CHECK-ORIGINS: Uninitialized value was created
   // CHECK-ORIGINS: {{#0 0x.* in .*malloc}}
   // CHECK-ORIGINS: {{#1 0x.* in main .*heap-origin.cpp:}}[[@LINE-7]]
 
   // CHECK: SUMMARY: MemorySanitizer: use-of-uninitialized-value {{.*heap-origin.cpp:.* main}}
 }

compiler-rt/test/msan/insertvalue_origin.cpp

 int main() {
  int64_t * volatile p = new int64_t;
  mypair z = my_make_pair(*p, 0);
  if (z.x)
    printf("zzz\n");
  // CHECK: MemorySanitizer: use-of-uninitialized-value
  // CHECK: {{in main .*insertvalue_origin.cpp:}}[[@LINE-3]]
 
- // CHECK: Uninitialized value was created by a heap allocation
+ // CHECK: Uninitialized value was created
  // CHECK: {{in main .*insertvalue_origin.cpp:}}[[@LINE-8]]
  delete p;
  return 0;
 }

compiler-rt/test/msan/msan_copy_shadow.cpp

int main() {
   assert(__msan_test_shadow(b + 1, 3) == 1);
   assert(__msan_test_shadow(b + 3, 1) == -1);
   __msan_check_mem_is_initialized(b, 4);
   // CHECK: use-of-uninitialized-value
   // CHECK:   {{in main.*msan_copy_shadow.cpp:}}[[@LINE-2]]
   // CHECK: Uninitialized value was stored to memory at
   // CHECK-FULL-STACK:   {{in main.*msan_copy_shadow.cpp:}}[[@LINE-8]]
   // CHECK-SHORT-STACK:   {{in __msan_copy_shadow .*msan_interceptors.cpp:}}
-  // CHECK: Uninitialized value was created by a heap allocation
+  // CHECK: Uninitialized value was created
   // CHECK:   {{in main.*msan_copy_shadow.cpp:}}[[@LINE-23]]
 }

compiler-rt/test/msan/msan_print_shadow.cpp

 // CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |A A A A|
 // CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |A A A A|
 // CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |A A A A|
 // CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |A A A A|
 // CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |A A A A|
 // CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffff.... ........  |A A A .|
 
 // CHECK-ORIGINS: Origin A (origin_id {{.*}}):
-// CHECK-ORIGINS:   Uninitialized value was created by a heap allocation
+// CHECK-ORIGINS:   Uninitialized value was created
 // CHECK-ORIGINS:     #1 {{.*}} in main{{.*}}msan_print_shadow.cpp:14
 
 // CHECK-ORIGINS: Origin B (origin_id {{.*}}):
-// CHECK-ORIGINS:   Memory was marked as uninitialized
+// CHECK-ORIGINS:   Uninitialized value was created
 // CHECK-ORIGINS:     #0 {{.*}} in __msan_allocated_memory
 // CHECK-ORIGINS:     #1 {{.*}} in main{{.*}}msan_print_shadow.cpp:18
 
 // CHECK-ORIGINS: Origin C (origin_id {{.*}}):
 // CHECK-ORIGINS-2:  Uninitialized value was stored to memory at
 // CHECK-ORIGINS-2:    #0 {{.*}} in main{{.*}}msan_print_shadow.cpp:48
 // CHECK-ORIGINS:   Uninitialized value was created by an allocation of 'x' in the stack frame of function 'main'
 // CHECK-ORIGINS:     #0 {{.*}} in main{{.*}}msan_print_shadow.cpp:12
 
 // CHECK-ORIGINS: Origin D (origin_id {{.*}}):
-// CHECK-ORIGINS:   Memory was marked as uninitialized
+// CHECK-ORIGINS:   Uninitialized value was created
 // CHECK-ORIGINS:     #0 {{.*}} in __msan_allocated_memory
 // CHECK-ORIGINS:     #1 {{.*}} in main{{.*}}msan_print_shadow.cpp:20
 
 // ...
 
 // CHECK-ORIGINS: Origin Z (origin_id {{.*}}):
-// CHECK-ORIGINS:   Memory was marked as uninitialized
+// CHECK-ORIGINS:   Uninitialized value was created
 // CHECK-ORIGINS:     #0 {{.*}} in __msan_allocated_memory
 // CHECK-ORIGINS:     #1 {{.*}} in main{{.*}}msan_print_shadow.cpp:42

compiler-rt/test/msan/origin-store-long.cpp

int main() {
   uint64_t *volatile p = new uint64_t;
   uint64_t *volatile q = new uint64_t;
   *p = *q;
   char *z = (char *)p;
   return z[6];
 // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
 // CHECK:   in main {{.*}}origin-store-long.cpp:[[@LINE-2]]
 
-// CHECK:  Uninitialized value was created by a heap allocation
+  // CHECK:  Uninitialized value was created
   // CHECK:   in main {{.*}}origin-store-long.cpp:[[@LINE-8]]
 }
 

compiler-rt/test/msan/realloc-large-origin.cpp

 // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
 // CHECK:   {{#0 0x.* in main .*realloc-large-origin.cpp:}}[[@LINE-3]]
 
 // CHECK:  Uninitialized value was stored to memory at
 // CHECK-FULL-STACK:   {{#0 0x.* in .*realloc}}
 // CHECK-FULL-STACK:   {{#1 0x.* in main .*realloc-large-origin.cpp:}}[[@LINE-10]]
 // CHECK-SHORT-STACK:   {{#0 0x.* in .*realloc}}
 
-// CHECK:   Uninitialized value was created by a heap allocation
+  // CHECK:   Uninitialized value was created
   // CHECK:   {{#0 0x.* in .*malloc}}
   // CHECK:   {{#1 0x.* in main .*realloc-large-origin.cpp:}}[[@LINE-16]]
 }

compiler-rt/test/msan/realloc-origin.cpp

int main(int argc, char **argv) {
   char *p = (char *)malloc(100);
   p = (char *)realloc(p, 101);
   char x = p[100];
   free(p);
   return x;
   // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
   // CHECK: {{#0 0x.* in main .*realloc-origin.cpp:}}[[@LINE-2]]
 
-  // CHECK: Uninitialized value was created by a heap allocation
+  // CHECK: Uninitialized value was created
   // CHECK: {{#0 0x.* in .*realloc}}
   // CHECK: {{#1 0x.* in main .*realloc-origin.cpp:}}[[@LINE-9]]
 }

compiler-rt/test/msan/select_float_origin.cpp

 
 int main() {
   volatile bool b = true;
   float x, y;
   __msan_allocated_memory(&x, sizeof(x));
   __msan_allocated_memory(&y, sizeof(y));
   float z = b ? x : y;
   if (z > 0) printf(".\n");
-  // CHECK: Memory was marked as uninitialized
+  // CHECK: Uninitialized value was created
   // CHECK: {{#0 0x.* in .*__msan_allocated_memory}}
   // CHECK: {{#1 0x.* in main .*select_float_origin.cpp:}}[[@LINE-6]]
   return 0;
 }

compiler-rt/test/msan/use-after-dtor.cpp

int main() {
   s->~Simple();
 
   fprintf(stderr, "\n");  // Need output to parse for CHECK-UAD-OFF case
   return s->x_;
 
   // CHECK-UAD: WARNING: MemorySanitizer: use-of-uninitialized-value
   // CHECK-UAD: {{#0 0x.* in main.*use-after-dtor.cpp:}}[[@LINE-3]]
 
-  // CHECK-ORIGINS: Memory was marked as uninitialized
+  // CHECK-ORIGINS: Uninitialized value was created
   // CHECK-ORIGINS: {{#0 0x.* in __sanitizer_dtor_callback}}
   // CHECK-ORIGINS: {{#1 0x.* in .*~Simple}}
 
   // CHECK-UAD: SUMMARY: MemorySanitizer: use-of-uninitialized-value {{.*main}}
   // CHECK-UAD-OFF-NOT: SUMMARY: MemorySanitizer: use-of-uninitialized-value
 }

compiler-rt/test/msan/use-after-free.cpp

int main(int argc, char **argv) {
   *p = 42;
   free(p);
 
   if (*p)
     exit(0);
   // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
   // CHECK: {{#0 0x.* in main .*use-after-free.cpp:}}[[@LINE-3]]
 
-  // CHECK-ORIGINS: Uninitialized value was created by a heap deallocation
+  // CHECK-ORIGINS: Uninitialized value was created
   // CHECK-ORIGINS: {{#0 0x.* in .*free}}
   // CHECK-ORIGINS: {{#1 0x.* in main .*use-after-free.cpp:}}[[@LINE-9]]
   return 0;
 }

compiler-rt/test/msan/wcsncpy.cpp

 // CHECK:  Uninitialized bytes in __msan_check_mem_is_initialized
 // CHECK:  WARNING: MemorySanitizer: use-of-uninitialized-value
 // CHECK:    in main {{.*}}wcsncpy.cpp:28
 
 // CHECK:  Uninitialized value was stored to memory at
 // CHECK:    in {{[^\s]*}}wcsncpy
 // CHECK:    in main {{.*}}wcsncpy.cpp:27
 
-// CHECK:  Memory was marked as uninitialized
+// CHECK:  Uninitialized value was created
 // CHECK:    in __msan_allocated_memory
 // CHECK:    in main {{.*}}wcsncpy.cpp:25