Remove function name from sanitize-memory-track-origins binary.

[kda]

Summary

This work is being done to reduce the size of MSAN with track origins binary.

Builds upon: https://reviews.llvm.org/D131205

[kda]

collected all updates.

[kda]

removed those changes found in https://reviews.llvm.org/D131205

[kda]

Refactor to address function changes and print generic message regarding location of uninitialized stack variable.

[kcc]

please show an error message on a non-trivial test case
(lots of variables, some defined on the same line) before and after.
Code size is important, but we cannot decrease the report quality

[kda]

In D131415#3713055, @kcc wrote:

please show an error message on a non-trivial test case
(lots of variables, some defined on the same line) before and after.
Code size is important, but we cannot decrease the report quality

Where can I get the name of the variable? (I think it is buried in the debug info some place, but I would need an example to help me extract it.)
An alternative I thought of was putting this behind a flag.

[kcc]

Where can I get the name of the variable? (I think it is buried in the debug info some place, but I would need an example to help me extract it.)
An alternative I thought of was putting this behind a flag.

Not sure I understand the question. MSan gets the variable names today just fine:

% cat stack-uninit.c 
void bar(int *a) {}

int main() {
  int foo;
  bar(&foo);
  if (foo) return 42;
  return 0;
}

% clang -g -fsanitize=memory -fsanitize-memory-track-origins  stack-uninit.c && ./a.out 
==389328==WARNING: MemorySanitizer: use-of-uninitialized-value
...

  Uninitialized value was created by an allocation of 'foo' in the stack frame of function 'main'

[kda]

In D131415#3713065, @kcc wrote:

Uninitialized value was created by an allocation of 'foo' in the stack frame of function 'main'

Absolutely. And this change will remove foo and main from the global.
The new message is:

Uninitialized value was created on the stack (first frame below should reference the variable)

I believe that foo is somewhere else in the binary, but I don't know the code which would be required to draw it out and display it in the message.
I'm looking for a hint.

[vitalybuka]

compiler-rt/lib/msan/msan_report.cpp

43

It technically not the stack, just a frame.
Shorter message like this has the same meaning:
"Uninitialized value was created here:"

[vitalybuka]

compiler-rt/lib/msan/msan_report.cpp

43

actually we still want to note that it's on that stack

"Uninitialized value was created by an allocation in the stack frame here:"

[kda]

restore the variable name to the global and fix up tests

[kda]

remove unnecessary allocation (no longer writing null byte in)

[kda]

Restored variable name. (Still dropping function name.)

[vitalybuka]

compiler-rt/lib/msan/msan_report.cpp

42–43

to many %s ?

[vitalybuka]

compiler-rt/lib/msan/msan_report.cpp

42–43

my mistake, it matches.

[kcc]

dropping the function name is fine, we have it from the stack traces.
the variable name can't be found anywhere else because in most cases
msan is used with -gline-tables-only, i.e. DWARF doesn't have the names of locals.

[kda]

sync to head

compiler-rt/lib/msan/msan_report.cpp

  public:
   Decorator() : SanitizerCommonDecorator() { }
   const char *Origin() const { return Magenta(); }
   const char *Name() const { return Green(); }
 };
 
 static void DescribeStackOrigin(const char *so, uptr pc) {
   Decorator d;
-  char *s = internal_strdup(so);
-  char *sep = internal_strchr(s, '@');
-  CHECK(sep);
-  *sep = '\0';
   Printf("%s", d.Origin());
   Printf(
       "  %sUninitialized value was created by an allocation of '%s%s%s'"
-      " in the stack frame of function '%s%s%s'%s\n",
-      d.Origin(), d.Name(), s, d.Origin(), d.Name(), sep + 1, d.Origin(),
-      d.Default());
-  InternalFree(s);
+      " in the stack frame%s\n",
+      d.Origin(), d.Name(), so, d.Origin(), d.Default());
 
   if (pc) {
     // For some reason function address in LLVM IR is 1 less then the address
     // of the first instruction.
     pc = StackTrace::GetNextInstructionPc(pc);
     StackTrace(&pc, 1).Print();
   }
 }

compiler-rt/test/msan/chained_origin.cpp

 // CHECK-SHORT-STACK: {{#0 .* in fn_h.*chained_origin.cpp:}}[[@LINE-21]]
 
 // CHECK: Uninitialized value was stored to memory at
 // 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: Uninitialized value was created by an allocation of 'z' in the stack frame
 // CHECK-STACK: {{#0 .* in main.*chained_origin.cpp:}}[[@LINE-22]]
 
 // CHECK-HEAP: Uninitialized value was created by a heap allocation
 // CHECK-HEAP: {{#1 .* in main.*chained_origin.cpp:}}[[@LINE-28]]

compiler-rt/test/msan/chained_origin_empty_stack.cpp

 // RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -O3 %s -o %t && \
 // RUN:     MSAN_OPTIONS=store_context_size=1 not %run %t 2>&1 | FileCheck %s
 
 // Test that stack trace for the intermediate store is not empty.
 
 // CHECK: MemorySanitizer: use-of-uninitialized-value
 // CHECK:   #0 {{.*}} in main
 
 // CHECK: Uninitialized value was stored to memory at
 // CHECK:   #0 {{.*}} in fn_g
 // CHECK-NOT: #1
 
-// CHECK: Uninitialized value was created by an allocation of 'z' in the stack frame of function 'main'
+// CHECK: Uninitialized value was created by an allocation of 'z' in the stack frame
 // CHECK:   #0 {{.*}} in main
 
 #include <stdio.h>
 
 volatile int x;
 
 __attribute__((noinline))
 void fn_g(int a) {

compiler-rt/test/msan/chained_origin_memcpy.cpp

 // CHECK-FULL-STACK: {{#1 .* in fn_h.*chained_origin_memcpy.cpp:}}[[@LINE-15]]
 // CHECK-SHORT-STACK: {{#0 .* in __msan_memcpy.*msan_interceptors.cpp:}}
 
 // CHECK: Uninitialized value was stored to memory at
 // CHECK-FULL-STACK: {{#0 .* in fn_g.*chained_origin_memcpy.cpp:}}[[@LINE-29]]
 // CHECK-FULL-STACK: {{#1 .* in fn_f.*chained_origin_memcpy.cpp:}}[[@LINE-25]]
 // CHECK-SHORT-STACK: {{#0 .* in fn_g.*chained_origin_memcpy.cpp:}}[[@LINE-31]]
 
-// CHECK-Z1: Uninitialized value was created by an allocation of 'z1' in the stack frame of function 'main'
-// CHECK-Z2: Uninitialized value was created by an allocation of 'z2' in the stack frame of function 'main'
+// CHECK-Z1: Uninitialized value was created by an allocation of 'z1' in the stack frame
+// CHECK-Z2: Uninitialized value was created by an allocation of 'z2' in the stack frame
 // CHECK-Z1: {{#0 .* in main.*chained_origin_memcpy.cpp:}}[[@LINE-21]]
 // CHECK-Z2: {{#0 .* in main.*chained_origin_memcpy.cpp:}}[[@LINE-21]]

compiler-rt/test/msan/chained_origin_memmove.cpp

 // CHECK-FULL-STACK: {{#1 .* in fn_h.*chained_origin_memmove.cpp:}}[[@LINE-15]]
 // CHECK-SHORT-STACK: {{#0 .* in __msan_memmove.*msan_interceptors.cpp:}}
 
 // CHECK: Uninitialized value was stored to memory at
 // CHECK-FULL-STACK: {{#0 .* in fn_g.*chained_origin_memmove.cpp:}}[[@LINE-27]]
 // CHECK-FULL-STACK: {{#1 .* in fn_f.*chained_origin_memmove.cpp:}}[[@LINE-24]]
 // CHECK-SHORT-STACK: {{#0 .* in fn_g.*chained_origin_memmove.cpp:}}[[@LINE-29]]
 
-// CHECK-Z1: Uninitialized value was created by an allocation of 'z1' in the stack frame of function 'main'
-// CHECK-Z2: Uninitialized value was created by an allocation of 'z2' in the stack frame of function 'main'
+// CHECK-Z1: Uninitialized value was created by an allocation of 'z1' in the stack frame
+// CHECK-Z2: Uninitialized value was created by an allocation of 'z2' in the stack frame
 // CHECK-Z1: {{#0 .* in main.*chained_origin_memmove.cpp:}}[[@LINE-21]]
 // CHECK-Z2: {{#0 .* in main.*chained_origin_memmove.cpp:}}[[@LINE-21]]

compiler-rt/test/msan/msan_print_shadow.cpp

 // CHECK-ORIGINS: Origin B (origin_id {{.*}}):
 // CHECK-ORIGINS:   Memory was marked as uninitialized
 // 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:   Uninitialized value was created by an allocation of 'x' in the stack frame
 // CHECK-ORIGINS:     #0 {{.*}} in main{{.*}}msan_print_shadow.cpp:13
 
 // CHECK-ORIGINS: Origin D (origin_id {{.*}}):
 // CHECK-ORIGINS:   Memory was marked as uninitialized
 // 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:     #0 {{.*}} in __msan_allocated_memory
 // CHECK-ORIGINS:     #1 {{.*}} in main{{.*}}msan_print_shadow.cpp:42

compiler-rt/test/msan/report-demangling.cpp

 // Test that function name is mangled in the "created by an allocation" line,
 // and demangled in the single-frame "stack trace" that follows.
 
 // RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && not %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out && FileCheck %s < %t.out
 
 __attribute__((noinline))
 int f() {
   int x;
   int *volatile p = &x;
   return *p;
 }
 
 int main(int argc, char **argv) {
   return f();
   // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
-  // CHECK: Uninitialized value was created by an allocation of 'x' in the stack frame of function '_Z1fv'
+  // CHECK: Uninitialized value was created by an allocation of 'x' in the stack frame
   // CHECK: #0 {{.*}} in f{{.*}} {{.*}}report-demangling.cpp:[[@LINE-9]]
 }

compiler-rt/test/msan/select_origin.cpp

int *max_by_ptr(int *a, int *b) {
   return *a < *b ? b : a;
 }
 
 int main(void) {
   int x;
   int *volatile px = &x;
   int y = 43;
   int *p = max_by_ptr(px, &y);
-  // CHECK: Uninitialized value was created by an allocation of 'x' in the stack frame of function 'main'
+  // CHECK: Uninitialized value was created by an allocation of 'x' in the stack frame
   return *p;
 }

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

 #include <stdlib.h>
 int main(int argc, char **argv) {
   int x;
   int *volatile p = &x;
   return *p;
   // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
   // CHECK: {{#0 0x.* in main .*stack-origin.cpp:}}[[@LINE-2]]
 
-  // CHECK-ORIGINS: Uninitialized value was created by an allocation of 'x' in the stack frame of function 'main'
+  // CHECK-ORIGINS: Uninitialized value was created by an allocation of 'x' in the stack frame
   // CHECK-ORIGINS: {{#0 0x.* in main .*stack-origin.cpp:}}[[@LINE-7]]
 
   // CHECK: SUMMARY: MemorySanitizer: use-of-uninitialized-value {{.*stack-origin.cpp:.* main}}
 }

compiler-rt/test/msan/stack-origin2.cpp

int f(int depth) {
   return *p;
 }
 
 int main(int argc, char **argv) {
   return f(1);
   // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
   // CHECK: {{#0 0x.* in main .*stack-origin2.cpp:}}[[@LINE-2]]
 
-  // CHECK-ORIGINS: Uninitialized value was created by an allocation of 'x' in the stack frame of function 'f'
+  // CHECK-ORIGINS: Uninitialized value was created by an allocation of 'x' in the stack frame
   // CHECK-ORIGINS: {{#0 0x.* in f .*stack-origin2.cpp:}}[[@LINE-11]]
 
   // CHECK: SUMMARY: MemorySanitizer: use-of-uninitialized-value {{.*stack-origin2.cpp:.* main}}
 }

compiler-rt/test/msan/unaligned_read_origin.cpp

 // RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && not %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out && FileCheck %s < %t.out
 // RUN: %clangxx_msan -fsanitize-memory-track-origins -O3 %s -o %t && not %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out && FileCheck %s < %t.out
 
 #include <sanitizer/msan_interface.h>
 
 int main(int argc, char **argv) {
   int x;
   int *volatile p = &x;
   return __sanitizer_unaligned_load32(p);
   // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
   // CHECK: {{#0 0x.* in main .*unaligned_read_origin.cpp:}}[[@LINE-2]]
-  // CHECK: Uninitialized value was created by an allocation of 'x' in the stack frame of function 'main'
+  // CHECK: Uninitialized value was created by an allocation of 'x' in the stack frame
   // CHECK: {{#0 0x.* in main .*unaligned_read_origin.cpp:}}[[@LINE-6]]
 }

compiler-rt/test/msan/vararg.cpp

if (strcmp(argv[1], "overflow") == 0) {
         a, a, a, a, a, a, uninit
       );
     }
   }
   return 0;
 }
 
 // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
-// CHECK-ORIGIN: Uninitialized value was created by an allocation of 'uninit' in the stack frame of function 'main'
+// CHECK-ORIGIN: Uninitialized value was created by an allocation of 'uninit' in the stack frame

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

   Value *getLocalVarDescription(AllocaInst &I) {
     SmallString<2048> StackDescriptionStorage;
     raw_svector_ostream StackDescription(StackDescriptionStorage);
     // We create a string with a description of the stack allocation and
     // pass it into __msan_set_alloca_origin.
     // It will be printed by the run-time if stack-originated UMR is found.
     // The first 4 bytes of the string are set to '----' and will be replaced
     // by __msan_va_arg_overflow_size_tls at the first call.
-    StackDescription << "----" << I.getName() << "@" << F.getName();
+    StackDescription << "----" << I.getName();
     return createPrivateNonConstGlobalForString(*F.getParent(),
                                                 StackDescription.str());
   }
 
   void poisonAllocaUserspace(AllocaInst &I, IRBuilder<> &IRB, Value *Len) {
     if (PoisonStack && ClPoisonStackWithCall) {
       IRB.CreateCall(MS.MsanPoisonStackFn,
                      {IRB.CreatePointerCast(&I, IRB.getInt8PtrTy()), Len});