[memprof] Restrict memprof profile generation to clang only.

[snehasish]

Summary

This disable the memprof tests on gcc since allocation sites are affected by
optimizations. Adopted from the approach in
compiler-rt/test/asan/TestCases/heap-overflow.cpp

Example failure: https://lab.llvm.org/buildbot/#/builders/247/builds/2185

[tejohnson]

I'm not sure I understand what is happening - presumably gcc is being used to build clang and compiler-rt. How is that affecting the allocation sites?

[snehasish]

I assumed it was due to optimizations however after looking more closely, the behaviour is due to a difference in debug information for the compiler-rt runtime. For the basic test case with the code below --

#include <stdlib.h>                                                                                                                                                          
#include <string.h>                                                                                                                                                          
int main(int argc, char **argv) {                                                                                                                                            
  char *x = (char *)malloc(10);                                                                                                                                              
  memset(x, 0, 10);                                                                                                                                                          
  free(x);                                                                                                                                                                   
  x = (char *)malloc(10);                                                                                                                                                    
  memset(x, 0, 10);                                                                                                                                                          
  free(x);                                                                                                                                                                   
  return 0;                                                                                                                                                                  
}

In both gcc and clang, we record 4 allocation sites. However two of them are from the application and two of them are from the runtime only [1]. We filter the records and drop frames which are from the runtime using the check here [2]. For gcc, this check fails since the path is just the filename memprof_malloc_linux.cpp as opposed to compiler-rt/lib/memprof/memprof_malloc_linux.cpp when built with clang. The isRuntime check looks for memprof/memprof_*. This seems to be an artifact of how the runtime was compiled in this environment and perhaps we can make this check more robust by listing the runtime filenames directly?

[1] https://github.com/llvm/llvm-project/blob/main/compiler-rt/lib/memprof/memprof_malloc_linux.cpp#L58
[2] https://github.com/llvm/llvm-project/blob/main/llvm/lib/ProfileData/RawMemProfReader.cpp#L151-L154

[snehasish]

Also looking into why we have these extra interceptions, it looks like we set memprof_init_is_running to false and a subsequent call to Symbolizer::LateInitialize is intercepted [1].

[1] https://github.com/llvm/llvm-project/blob/main/compiler-rt/lib/memprof/memprof_rtl.cpp#L201-L217

[tejohnson]

In D145428#4173671, @snehasish wrote:

I assumed it was due to optimizations however after looking more closely, the behaviour is due to a difference in debug information for the compiler-rt runtime. For the basic test case with the code below --

#include <stdlib.h>                                                                                                                                                          
#include <string.h>                                                                                                                                                          
int main(int argc, char **argv) {                                                                                                                                            
  char *x = (char *)malloc(10);                                                                                                                                              
  memset(x, 0, 10);                                                                                                                                                          
  free(x);                                                                                                                                                                   
  x = (char *)malloc(10);                                                                                                                                                    
  memset(x, 0, 10);                                                                                                                                                          
  free(x);                                                                                                                                                                   
  return 0;                                                                                                                                                                  
}

In both gcc and clang, we record 4 allocation sites. However two of them are from the application and two of them are from the runtime only [1]. We filter the records and drop frames which are from the runtime using the check here [2]. For gcc, this check fails since the path is just the filename memprof_malloc_linux.cpp as opposed to compiler-rt/lib/memprof/memprof_malloc_linux.cpp when built with clang. The isRuntime check looks for memprof/memprof_*. This seems to be an artifact of how the runtime was compiled in this environment and perhaps we can make this check more robust by listing the runtime filenames directly?

Yeah, that seems like the best option.

Also looking into why we have these extra interceptions, it looks like we set memprof_init_is_running to false and a subsequent call to Symbolizer::LateInitialize is intercepted [1].

I don't recall why we set this to false at this specific point, it seems like it should be ok to delay it. And then I wonder if we can combine memprof_init_is_running with memprof_init_done?

[snehasish]

I don't recall why we set this to false at this specific point, it seems like it should be ok to delay it. And then I wonder if we can combine memprof_init_is_running with memprof_init_done?

Delaying it seems to be fine on the small tests, let me look into what the other flags do and try to simplify if we can.

[snehasish]

Yeah, that seems like the best option.

Sent D145521 to match filenames which define interceptors.

[snehasish]

In D145428#4175870, @snehasish wrote:

I don't recall why we set this to false at this specific point, it seems like it should be ok to delay it. And then I wonder if we can combine memprof_init_is_running with memprof_init_done?

Delaying it seems to be fine on the small tests, let me look into what the other flags do and try to simplify if we can.

Done in D145528.

compiler-rt/test/memprof/TestCases/memprof_basic.c

 // REQUIRES: x86_64-linux
+// REQUIRES: Clang
 // RUN: %clang_memprof -fuse-ld=lld -Wl,--no-rosegment -gmlt -fdebug-info-for-profiling -fmemory-profile -mno-omit-leaf-frame-pointer -fno-omit-frame-pointer -fno-optimize-sibling-calls -m64 -Wl,-build-id -no-pie %s -o %t.memprofexe
 // RUN: env MEMPROF_OPTIONS=log_path=stdout %t.memprofexe > %t.memprofraw
 // RUN: %llvm_profdata show --memory %t.memprofraw --profiled-binary %t.memprofexe -o - | FileCheck %s
 #include <stdlib.h>
 #include <string.h>
 int main(int argc, char **argv) {
   char *x = (char *)malloc(10);
   memset(x, 0, 10);

compiler-rt/test/memprof/TestCases/memprof_inline.c

 // REQUIRES: x86_64-linux
+// REQUIRES: Clang
 // RUN: %clang_memprof -fuse-ld=lld -Wl,--no-rosegment -gmlt -fdebug-info-for-profiling -fmemory-profile -mno-omit-leaf-frame-pointer -fno-omit-frame-pointer -fno-optimize-sibling-calls -m64 -Wl,-build-id -no-pie %s -o %t.memprofexe
 // RUN: env MEMPROF_OPTIONS=log_path=stdout %t.memprofexe > %t.memprofraw
 // RUN: %llvm_profdata show --memory %t.memprofraw --profiled-binary %t.memprofexe | FileCheck %s
 #include <stdlib.h>
 #include <string.h>
 
 __attribute__((always_inline)) void qux(int x) {
   char *ptr = malloc(x);

compiler-rt/test/memprof/TestCases/memprof_multi.c

 // REQUIRES: x86_64-linux
+// REQUIRES: Clang
 // RUN: %clang_memprof -fuse-ld=lld -Wl,--no-rosegment -gmlt -fdebug-info-for-profiling -fmemory-profile -mno-omit-leaf-frame-pointer -fno-omit-frame-pointer -fno-optimize-sibling-calls -m64 -Wl,-build-id -no-pie %s -o %t.memprofexe
 // RUN: env MEMPROF_OPTIONS=log_path=stdout %t.memprofexe > %t.memprofraw
 // RUN: %llvm_profdata show --memory %t.memprofraw --profiled-binary %t.memprofexe -o - | FileCheck %s
 #include <sanitizer/memprof_interface.h>
 #include <stdlib.h>
 #include <string.h>
 int main(int argc, char **argv) {
   char *x = (char *)malloc(10);