[MemProf] Allow the binary to specify the profile output filename

[tejohnson]

Summary

This will allow the output directory to be specified by a build time
option, similar to the directory specified for regular PGO profiles via
-fprofile-generate=. The memory profiling instrumentation pass will
set up the variable. This is the same mechanism used by the PGO
instrumentation and runtime.

Depends on D87120 and D89629.

[davidxl]

Profile runtime has 4 ways of setting output: 1) default 2) compiler command line arg 3) environment variable at runtime; and 4) user invocation of runtime API at runtime. The order of the precedence is 4> 3 > 2 > 1. Is the behavior here consistent with that?

[vitalybuka]

LGTM but I have no opinion on David's request.

compiler-rt/lib/memprof/memprof_rtl.cpp

31

not needed?

compiler-rt/lib/sanitizer_common/sanitizer_file.cpp

71–92

looks correct, but it would be nice to have sanitizer_common as a separate patch

compiler-rt/test/memprof/TestCases/atexit_stats.cpp

4

It's not clear why this is needed before reading patch description.
Seems unrelated to __memprof_profile_filename and can be a separate patch.

[tejohnson]

In D89086#2322033, @davidxl wrote:

Profile runtime has 4 ways of setting output: 1) default 2) compiler command line arg 3) environment variable at runtime; and 4) user invocation of runtime API at runtime. The order of the precedence is 4> 3 > 2 > 1. Is the behavior here consistent with that?

The runtime I recently upstreamed has #3, and this patch adds #1 (well there is a default in the already upstreamed stuff, but it is stderr) and #2. A follow on patch will add #4. The order of precedence will be the same as in the profile runtime (it is already 3>2>1).

compiler-rt/lib/memprof/memprof_rtl.cpp

31

This is to ensure that the if below at line 182 will fail when the compiler has not set up a strong version of this variable.

compiler-rt/lib/sanitizer_common/sanitizer_file.cpp

71–92

Ok, I can split this out.

compiler-rt/test/memprof/TestCases/atexit_stats.cpp

4

I can just move this to the follow on patch that changes the compiler which affects the defaults, requiring this change.

[vitalybuka]

compiler-rt/lib/memprof/memprof_rtl.cpp

31

Sorry, I asked if initialization is needed. "={0}" I'd expect it's already zeroes.

[tejohnson]

compiler-rt/lib/memprof/memprof_rtl.cpp

31

You're right. The global should get zero initialized so the init isn't really necessary. I can remove it.

[tejohnson]

Address comments.

compiler-rt/lib/memprof/memprof_interface_internal.h

 SANITIZER_INTERFACE_ATTRIBUTE void __memprof_print_accumulated_stats();
 
 SANITIZER_INTERFACE_ATTRIBUTE
 const char *__memprof_default_options();
 
 SANITIZER_INTERFACE_ATTRIBUTE
 extern uptr __memprof_shadow_memory_dynamic_address;
 
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE extern char
+    __memprof_profile_filename[1];
+
 SANITIZER_INTERFACE_ATTRIBUTE void __memprof_load(uptr p);
 SANITIZER_INTERFACE_ATTRIBUTE void __memprof_store(uptr p);
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void *__memprof_memcpy(void *dst, const void *src, uptr size);
 SANITIZER_INTERFACE_ATTRIBUTE
 void *__memprof_memset(void *s, int c, uptr n);
 SANITIZER_INTERFACE_ATTRIBUTE
 void *__memprof_memmove(void *dest, const void *src, uptr n);
 } // extern "C"
 
 #endif // MEMPROF_INTERFACE_INTERNAL_H

compiler-rt/lib/memprof/memprof_rtl.cpp

 #include "sanitizer_common/sanitizer_atomic.h"
 #include "sanitizer_common/sanitizer_flags.h"
 #include "sanitizer_common/sanitizer_libc.h"
 #include "sanitizer_common/sanitizer_symbolizer.h"
 #include <ctime>
 
 uptr __memprof_shadow_memory_dynamic_address; // Global interface symbol.
 
+// Allow the user to specify a profile output file via the binary.
+SANITIZER_WEAK_ATTRIBUTE char __memprof_profile_filename[1] = {0};
+
 namespace __memprof {
 
 static void MemprofDie() {
   static atomic_uint32_t num_calls;
   if (atomic_fetch_add(&num_calls, 1, memory_order_relaxed) != 0) {
     // Don't die twice - run a busy loop.
     while (1) {
     }
static void MemprofInitInternal() {
 
   // Make sure we are not statically linked.
   MemprofDoesNotSupportStaticLinkage();
 
   // Install tool-specific callbacks in sanitizer_common.
   AddDieCallback(MemprofDie);
   SetCheckFailedCallback(MemprofCheckFailed);
 
+  // Use profile name specified via the binary itself if it exists, and hasn't
+  // been overrriden by a flag at runtime.
+  if (__memprof_profile_filename[0] != 0 && !common_flags()->log_path)
+    __sanitizer_set_report_path(__memprof_profile_filename);
+  else
     __sanitizer_set_report_path(common_flags()->log_path);
 
   __sanitizer::InitializePlatformEarly();
 
   // Re-exec ourselves if we need to set additional env or command line args.
   MaybeReexec();
 
   // Setup internal allocator callback.
   SetLowLevelAllocateMinAlignment(SHADOW_GRANULARITY);

compiler-rt/lib/memprof/weak_symbols.txt

-___memprof_default_options
+___memprof_default_options __memprof_profile_filename

compiler-rt/lib/sanitizer_common/sanitizer_file.cpp

if (fd == kInvalidFd) {
     const char *ErrorMsgPrefix = "ERROR: Can't open file: ";
     WriteToFile(kStderrFd, ErrorMsgPrefix, internal_strlen(ErrorMsgPrefix));
     WriteToFile(kStderrFd, full_path, internal_strlen(full_path));
     Die();
   }
   fd_pid = pid;
 }
 
 void ReportFile::SetReportPath(const char *path) {
-  if (!path)
-    return;
+  if (path) {
     uptr len = internal_strlen(path);
     if (len > sizeof(path_prefix) - 100) {
-    Report("ERROR: Path is too long: %c%c%c%c%c%c%c%c...\n",
-           path[0], path[1], path[2], path[3],
-           path[4], path[5], path[6], path[7]);
+      Report("ERROR: Path is too long: %c%c%c%c%c%c%c%c...\n", path[0], path[1],
+             path[2], path[3], path[4], path[5], path[6], path[7]);
       Die();
     }
+  }
 
   SpinMutexLock l(mu);
   if (fd != kStdoutFd && fd != kStderrFd && fd != kInvalidFd)
     CloseFile(fd);
   fd = kInvalidFd;
-  if (internal_strcmp(path, "stdout") == 0) {
-    fd = kStdoutFd;
-  } else if (internal_strcmp(path, "stderr") == 0) {
+  if (!path || internal_strcmp(path, "stderr") == 0) {
     fd = kStderrFd;
+  } else if (internal_strcmp(path, "stdout") == 0) {
+    fd = kStdoutFd;
   } else {
     internal_snprintf(path_prefix, kMaxPathLength, "%s", path);
   }
 }
 
 bool ReadFileToBuffer(const char *file_name, char **buff, uptr *buff_size,
                       uptr *read_len, uptr max_len, error_t *errno_p) {
   *buff = nullptr;
   *buff_size = 0;
   *read_len = 0;
   if (!max_len)
     return true;

compiler-rt/lib/sanitizer_common/sanitizer_flags.inc

 //===-- sanitizer_flags.h ---------------------------------------*- C++ -*-===//
 //
 // 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 describes common flags available in all sanitizers.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef COMMON_FLAG
 #error "Define COMMON_FLAG prior to including this file!"
 #endif
 
 // COMMON_FLAG(Type, Name, DefaultValue, Description)
 // Supported types: bool, const char *, int, uptr.
 // Default value must be a compile-time constant.
 // Description must be a string literal.
 
 COMMON_FLAG(
     bool, symbolize, true,
     "If set, use the online symbolizer from common sanitizer runtime to turn "
     "virtual addresses to file/line locations.")
 COMMON_FLAG(
     const char *, external_symbolizer_path, nullptr,
     "Path to external symbolizer. If empty, the tool will search $PATH for "
     "the symbolizer.")
 COMMON_FLAG(
     bool, allow_addr2line, false,
     "If set, allows online symbolizer to run addr2line binary to symbolize "
     "stack traces (addr2line will only be used if llvm-symbolizer binary is "
     "unavailable.")
 COMMON_FLAG(const char *, strip_path_prefix, "",
             "Strips this prefix from file paths in error reports.")
 COMMON_FLAG(bool, fast_unwind_on_check, false,
             "If available, use the fast frame-pointer-based unwinder on "
             "internal CHECK failures.")
 COMMON_FLAG(bool, fast_unwind_on_fatal, false,
             "If available, use the fast frame-pointer-based unwinder on fatal "
             "errors.")
 COMMON_FLAG(bool, fast_unwind_on_malloc, true,
             "If available, use the fast frame-pointer-based unwinder on "
             "malloc/free.")
 COMMON_FLAG(bool, handle_ioctl, false, "Intercept and handle ioctl requests.")
 COMMON_FLAG(int, malloc_context_size, 1,
             "Max number of stack frames kept for each allocation/deallocation.")
 COMMON_FLAG(
-    const char *, log_path, "stderr",
+    const char *, log_path, nullptr,
     "Write logs to \"log_path.pid\". The special values are \"stdout\" and "
-    "\"stderr\". The default is \"stderr\".")
+    "\"stderr\". If unspecified, defaults to \"stderr\".")
 COMMON_FLAG(
     bool, log_exe_name, false,
     "Mention name of executable when reporting error and "
     "append executable name to logs (as in \"log_path.exe_name.pid\").")
 COMMON_FLAG(
     bool, log_to_syslog, (bool)SANITIZER_ANDROID || (bool)SANITIZER_MAC,
     "Write all sanitizer output to syslog in addition to other means of "
     "logging.")

compiler-rt/test/memprof/TestCases/atexit_stats.cpp

 // Check atexit option.
 
 // RUN: %clangxx_memprof -O0 %s -o %t
-// RUN: %env_memprof_opts=atexit=1 %run %t 2>&1 | FileCheck %s
-// RUN: %env_memprof_opts=atexit=0 %run %t 2>&1 | FileCheck %s --check-prefix=NOATEXIT
+// RUN: %env_memprof_opts=log_path=stderr:atexit=1 %run %t 2>&1 | FileCheck %s
+// RUN: %env_memprof_opts=log_path=stderr:atexit=0 %run %t 2>&1 | FileCheck %s --check-prefix=NOATEXIT
 
 // CHECK: MemProfiler exit stats:
 // CHECK: Stats: {{[0-9]+}}M malloced ({{[0-9]+}}M for overhead) by {{[0-9]+}} calls
 // CHECK: Stats: {{[0-9]+}}M realloced by {{[0-9]+}} calls
 // CHECK: Stats: {{[0-9]+}}M freed by {{[0-9]+}} calls
 // CHECK: Stats: {{[0-9]+}}M really freed by {{[0-9]+}} calls
 // CHECK: Stats: {{[0-9]+}}M ({{[0-9]+}}M-{{[0-9]+}}M) mmaped; {{[0-9]+}} maps, {{[0-9]+}} unmaps
 // CHECK:   mallocs by size class:
 // CHECK: Stats: malloc large: {{[0-9]+}}
 
 // NOATEXIT-NOT: MemProfiler exit stats
 
 int main() {
   return 0;
 }

compiler-rt/test/memprof/TestCases/dump_process_map.cpp

 // Check dump_process_map option.
 
 // RUN: %clangxx_memprof -O0 %s -o %t
-// RUN: %env_memprof_opts=dump_process_map=1 %run %t 2>&1 | FileCheck %s
-// RUN: %env_memprof_opts=dump_process_map=0 %run %t 2>&1 | FileCheck %s --check-prefix=NOMAP
+// RUN: %env_memprof_opts=log_path=stderr:dump_process_map=1 %run %t 2>&1 | FileCheck %s
+// RUN: %env_memprof_opts=log_path=stderr:dump_process_map=0 %run %t 2>&1 | FileCheck %s --check-prefix=NOMAP
 
 // CHECK: Process memory map follows:
 // CHECK: dump_process_map.cpp.tmp
 // CHECK: End of process memory map.
 // NOMAP-NOT: memory map
 
 int main() {
   return 0;
 }

compiler-rt/test/memprof/TestCases/log_path_test.cpp

 // The for loop in the backticks below requires bash.
 // REQUIRES: shell
 //
 // RUN: %clangxx_memprof  %s -o %t
 
-// Regular run.
-// RUN: %run %t 2> %t.out
+// stderr log_path
+// RUN: %env_memprof_opts=log_path=stderr %run %t 2> %t.out
 // RUN: FileCheck %s --check-prefix=CHECK-GOOD < %t.out
 
 // Good log_path.
 // RUN: rm -f %t.log.*
 // RUN: %env_memprof_opts=log_path=%t.log %run %t 2> %t.out
 // RUN: FileCheck %s --check-prefix=CHECK-GOOD < %t.log.*
 
 // Invalid log_path.
 // RUN: %env_memprof_opts=log_path=/dev/null/INVALID not %run %t 2> %t.out
 // RUN: FileCheck %s --check-prefix=CHECK-INVALID < %t.out
 
 // Too long log_path.
 // RUN: %env_memprof_opts=log_path=`for((i=0;i<10000;i++)); do echo -n $i; done` \
 // RUN:   not %run %t 2> %t.out
 // RUN: FileCheck %s --check-prefix=CHECK-LONG < %t.out
 
+// Specifying the log name via the __memprof_profile_filename variable.
+// RUN: %clangxx_memprof  %s -o %t -DPROFILE_NAME_VAR="%t.log2"
+// RUN: rm -f %t.log2.*
+// RUN: %run %t 2> %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-GOOD < %t.log2.*
+
+// Check that the log_path option overrides the log name set via the
+// __memprof_profile_filename variable.
+// RUN: rm -f %t.log.*
+// RUN: %env_memprof_opts=log_path=%t.log %run %t 2> %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-GOOD < %t.log.*
+
+#ifdef PROFILE_NAME_VAR
+#define xstr(s) str(s)
+#define str(s) #s
+char __memprof_profile_filename[] = xstr(PROFILE_NAME_VAR);
+#endif
+
 #include <stdlib.h>
 #include <string.h>
 int main(int argc, char **argv) {
   char *x = (char *)malloc(10);
   memset(x, 0, 10);
   free(x);
   return 0;
 }
 // CHECK-GOOD: Memory allocation stack id
 // CHECK-INVALID: ERROR: Can't open file: /dev/null/INVALID
 // CHECK-LONG: ERROR: Path is too long: 01234

compiler-rt/test/memprof/TestCases/malloc-size-too-big.cpp

 // RUN: %clangxx_memprof -O0 %s -o %t
-// RUN: %env_memprof_opts=allocator_may_return_null=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-SUMMARY
-// RUN: %env_memprof_opts=allocator_may_return_null=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-NULL
+// RUN: %env_memprof_opts=log_path=stderr:allocator_may_return_null=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-SUMMARY
+// RUN: %env_memprof_opts=log_path=stderr:allocator_may_return_null=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-NULL
 // Test print_summary
-// RUN: %env_memprof_opts=allocator_may_return_null=0:print_summary=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOSUMMARY
+// RUN: %env_memprof_opts=log_path=stderr:allocator_may_return_null=0:print_summary=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOSUMMARY
 
 #include <stdio.h>
 #include <stdlib.h>
 
 static const size_t kMaxAllowedMallocSizePlusOne = (1ULL << 40) + 1;
 int main() {
   void *p = malloc(kMaxAllowedMallocSizePlusOne);
   // CHECK: {{ERROR: MemProfiler: requested allocation size .* exceeds maximum supported size}}

compiler-rt/test/memprof/TestCases/mem_info_cache_entries.cpp

 // Check mem_info_cache_entries option.
 
-// RUN: %clangxx_memprof -O0 %s -o %t && %env_memprof_opts=mem_info_cache_entries=15:print_mem_info_cache_miss_rate=1:print_mem_info_cache_miss_rate_details=1 %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_memprof -O0 %s -o %t && %env_memprof_opts=log_path=stderr:mem_info_cache_entries=15:print_mem_info_cache_miss_rate=1:print_mem_info_cache_miss_rate_details=1 %run %t 2>&1 | FileCheck %s
 
 // CHECK: Set 14 miss rate: 0 / {{.*}} = 0.00%
 // CHECK-NOT: Set
 
 int main() {
   return 0;
 }

compiler-rt/test/memprof/TestCases/print_miss_rate.cpp

 // Check print_mem_info_cache_miss_rate and
 // print_mem_info_cache_miss_rate_details options.
 
 // RUN: %clangxx_memprof -O0 %s -o %t
-// RUN: %env_memprof_opts=print_mem_info_cache_miss_rate=1 %run %t 2>&1 | FileCheck %s
-// RUN: %env_memprof_opts=print_mem_info_cache_miss_rate=1:print_mem_info_cache_miss_rate_details=1 %run %t 2>&1 | FileCheck %s --check-prefix=DETAILS
+// RUN: %env_memprof_opts=log_path=stderr:print_mem_info_cache_miss_rate=1 %run %t 2>&1 | FileCheck %s
+// RUN: %env_memprof_opts=log_path=stderr:print_mem_info_cache_miss_rate=1:print_mem_info_cache_miss_rate_details=1 %run %t 2>&1 | FileCheck %s --check-prefix=DETAILS
 
 // CHECK: Overall miss rate: 0 / {{.*}} = 0.00%
 // DETAILS: Set 0 miss rate: 0 / {{.*}} = 0.00%
 // DETAILS: Set 16380 miss rate: 0 / {{.*}} = 0.00%
 
 int main() {
   return 0;
 }

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

 // REQUIRES: memprof-64-bits
 // Stress test dynamic TLS + dlopen + threads.
 //
 // RUN: %clangxx_memprof -x c -DSO_NAME=f0 %s -shared -o %t-f0.so -fPIC
 // RUN: %clangxx_memprof -x c -DSO_NAME=f1 %s -shared -o %t-f1.so -fPIC
 // RUN: %clangxx_memprof -x c -DSO_NAME=f2 %s -shared -o %t-f2.so -fPIC
 // RUN: %clangxx_memprof %s -ldl -pthread -o %t
 // RUN: %run %t 0 3
 // RUN: %run %t 2 3
-// RUN: %env_memprof_opts=verbosity=2 %run %t 10 2 2>&1 | FileCheck %s
-// RUN: %env_memprof_opts=verbosity=2:intercept_tls_get_addr=1 %run %t 10 2 2>&1 | FileCheck %s
-// RUN: %env_memprof_opts=verbosity=2:intercept_tls_get_addr=0 %run %t 10 2 2>&1 | FileCheck %s --check-prefix=CHECK0
+// RUN: %env_memprof_opts=log_path=stderr:verbosity=2 %run %t 10 2 2>&1 | FileCheck %s
+// RUN: %env_memprof_opts=log_path=stderr:verbosity=2:intercept_tls_get_addr=1 %run %t 10 2 2>&1 | FileCheck %s
+// RUN: %env_memprof_opts=log_path=stderr:verbosity=2:intercept_tls_get_addr=0 %run %t 10 2 2>&1 | FileCheck %s --check-prefix=CHECK0
 // CHECK: __tls_get_addr
 // CHECK: Creating thread 0
 // CHECK: __tls_get_addr
 // CHECK: Creating thread 1
 // CHECK: __tls_get_addr
 // CHECK: Creating thread 2
 // CHECK: __tls_get_addr
 // CHECK: Creating thread 3

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

 // Check profile with a single malloc call and set of loads and stores. Ensures
 // we get the same profile regardless of whether the memory is deallocated
 // before exit.
 
 // RUN: %clangxx_memprof -O0 %s -o %t
-// RUN: %env_memprof_opts= %run %t 2>&1 | FileCheck %s
+// RUN: %env_memprof_opts=log_path=stderr %run %t 2>&1 | FileCheck %s
 
 // RUN: %clangxx_memprof -DFREE -O0 %s -o %t
-// RUN: %env_memprof_opts= %run %t 2>&1 | FileCheck %s
+// RUN: %env_memprof_opts=log_path=stderr %run %t 2>&1 | FileCheck %s
 
 // This is actually:
 //  Memory allocation stack id = STACKID
 //   alloc_count 1, size (ave/min/max) 40.00 / 40 / 40
 // but we need to look for them in the same CHECK to get the correct STACKID.
 // CHECK:  Memory allocation stack id = [[STACKID:[0-9]+]]{{[[:space:]].*}}alloc_count 1, size (ave/min/max) 40.00 / 40 / 40
 // CHECK-NEXT:  access_count (ave/min/max): 20.00 / 20 / 20
 // CHECK-NEXT:  lifetime (ave/min/max): [[AVELIFETIME:[0-9]+]].00 / [[AVELIFETIME]] / [[AVELIFETIME]]

compiler-rt/test/memprof/TestCases/test_memintrin.cpp

 // Check profile with calls to memory intrinsics.
 
-// RUN: %clangxx_memprof -O0 %s -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_memprof -O0 %s -o %t && %env_memprof_opts=log_path=stderr %run %t 2>&1 | FileCheck %s
 
 // This is actually:
 //  Memory allocation stack id = STACKIDP
 //   alloc_count 1, size (ave/min/max) 40.00 / 40 / 40
 //   access_count (ave/min/max): 3.00 / 3 / 3
 // but we need to look for them in the same CHECK to get the correct STACKIDP.
 // CHECK-DAG:  Memory allocation stack id = [[STACKIDP:[0-9]+]]{{[[:space:]].*}} alloc_count 1, size (ave/min/max) 40.00 / 40 / 40{{[[:space:]].*}} access_count (ave/min/max): 3.00 / 3 / 3
 //

compiler-rt/test/memprof/TestCases/test_new_load_store.cpp

 // Check profile with a single new call and set of loads and stores. Ensures
 // we get the same profile regardless of whether the memory is deallocated
 // before exit.
 
 // RUN: %clangxx_memprof -O0 %s -o %t
-// RUN: %env_memprof_opts= %run %t 2>&1 | FileCheck %s
+// RUN: %env_memprof_opts=log_path=stderr %run %t 2>&1 | FileCheck %s
 
 // RUN: %clangxx_memprof -DFREE -O0 %s -o %t
-// RUN: %env_memprof_opts= %run %t 2>&1 | FileCheck %s
+// RUN: %env_memprof_opts=log_path=stderr %run %t 2>&1 | FileCheck %s
 
 // Try again with callbacks instead of inline sequences
 // RUN: %clangxx_memprof -mllvm -memprof-use-callbacks -O0 %s -o %t
-// RUN: %env_memprof_opts= %run %t 2>&1 | FileCheck %s
+// RUN: %env_memprof_opts=log_path=stderr %run %t 2>&1 | FileCheck %s
 
 // This is actually:
 //  Memory allocation stack id = STACKID
 //   alloc_count 1, size (ave/min/max) 40.00 / 40 / 40
 // but we need to look for them in the same CHECK to get the correct STACKID.
 // CHECK:  Memory allocation stack id = [[STACKID:[0-9]+]]{{[[:space:]].*}}alloc_count 1, size (ave/min/max) 40.00 / 40 / 40
 // CHECK-NEXT:  access_count (ave/min/max): 20.00 / 20 / 20
 // CHECK-NEXT:  lifetime (ave/min/max): [[AVELIFETIME:[0-9]+]].00 / [[AVELIFETIME]] / [[AVELIFETIME]]

compiler-rt/test/memprof/TestCases/test_terse.cpp

 // Check terse format profile with a single malloc call and set of loads and
 // stores. Ensures we get the same profile regardless of whether the memory is
 // deallocated before exit.
 
 // RUN: %clangxx_memprof -O0 %s -o %t
-// RUN: %env_memprof_opts=print_terse=1 %run %t 2>&1 | FileCheck %s
+// RUN: %env_memprof_opts=log_path=stderr:print_terse=1 %run %t 2>&1 | FileCheck %s
 
 // RUN: %clangxx_memprof -DFREE -O0 %s -o %t
-// RUN: %env_memprof_opts=print_terse=1 %run %t 2>&1 | FileCheck %s
+// RUN: %env_memprof_opts=log_path=stderr:print_terse=1 %run %t 2>&1 | FileCheck %s
 
 // CHECK: MIB:[[STACKID:[0-9]+]]/1/40.00/40/40/20.00/20/20/[[AVELIFETIME:[0-9]+]].00/[[AVELIFETIME]]/[[AVELIFETIME]]/0/0/0/0
 // CHECK: Stack for id [[STACKID]]:
 // CHECK-NEXT: #0 {{.*}} in operator new
 // CHECK-NEXT: #1 {{.*}} in main {{.*}}:[[@LINE+6]]
 
 #include <stdio.h>
 #include <stdlib.h>

compiler-rt/test/memprof/TestCases/unaligned_loads_and_stores.cpp

-// RUN: %clangxx_memprof -O0 %s -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_memprof -O0 %s -o %t && %env_memprof_opts=log_path=stderr %run %t 2>&1 | FileCheck %s
 
 // This is actually:
 //  Memory allocation stack id = STACKID
 //    alloc_count 1, size (ave/min/max) 128.00 / 128 / 128
 // but we need to look for them in the same CHECK to get the correct STACKID.
 // CHECK:      Memory allocation stack id = [[STACKID:[0-9]+]]{{[[:space:]].*}}alloc_count 1, size (ave/min/max) 128.00 / 128 / 128
 // CHECK-NEXT:   access_count (ave/min/max): 7.00 / 7 / 7