[memprof] Update the isRuntime symbolization check.

[snehasish]

Summary

Update the isRuntime check to only match against known memprof filenames
where interceptors are defined. This avoid issues where the path does
not include the directory based on how the runtime was compiled. Also
update the unittest.

[tejohnson]

lgtm

[snehasish]

Failing build on Windows seems to be unrelated:

Failed Tests (1):
  Clangd Unit Tests :: ./ClangdTests.exe/IncludeCleaner/GenerateMissingHeaderDiags

llvm/lib/ProfileData/RawMemProfReader.cpp

 }
 
 Error report(Error E, const StringRef Context) {
   return joinErrors(createStringError(inconvertibleErrorCode(), Context),
                     std::move(E));
 }
 
 bool isRuntimePath(const StringRef Path) {
-  return StringRef(llvm::sys::path::convert_to_slash(Path))
-      .contains("memprof/memprof_");
+  const StringRef Filename = llvm::sys::path::filename(Path);
+  // This list should be updated in case new files with additional interceptors
+  // are added to the memprof runtime.
+  return Filename.equals("memprof_malloc_linux.cpp") ||
+         Filename.equals("memprof_interceptors.cpp") ||
+         Filename.equals("memprof_new_delete.cpp");
 }
 
 std::string getBuildIdString(const SegmentEntry &Entry) {
   constexpr size_t Size = sizeof(Entry.BuildId) / sizeof(uint8_t);
   constexpr uint8_t Zeros[Size] = {0};
   // If the build id is unset print a helpful string instead of all zeros.
   if (memcmp(Entry.BuildId, Zeros, Size) == 0)
     return "<None>";

llvm/unittests/ProfileData/MemProfTest.cpp

EXPECT_CALL(*Symbolizer, symbolizeInlinedCode(SectionedAddress{0x3000},
       .WillRepeatedly(Return(makeInliningInfo({
           {DILineInfo::BadString, 0, 0, 0},
       })));
 
   EXPECT_CALL(*Symbolizer, symbolizeInlinedCode(SectionedAddress{0x4000},
                                                 specifier(), false))
       .Times(1)
       .WillRepeatedly(Return(makeInliningInfo({
-          {"foo", 10, 5, 30},
+          {"foo", 10, 5, 30, "memprof/memprof_test_file.cpp"},
+      })));
+
+  EXPECT_CALL(*Symbolizer, symbolizeInlinedCode(SectionedAddress{0x5000},
+                                                specifier(), false))
+      .Times(1)
+      .WillRepeatedly(Return(makeInliningInfo({
+          // Depending on how the runtime was compiled, only the filename
+          // may be present in the debug information.
+          {"malloc", 70, 57, 3, "memprof_malloc_linux.cpp"},
       })));
 
   CallStackMap CSM;
   CSM[0x1] = {0x1000, 0x2000, 0x3000, 0x4000};
   // This entry should be dropped since all PCs are either not
   // symbolizable or belong to the runtime.
-  CSM[0x2] = {0x1000, 0x2000};
+  CSM[0x2] = {0x1000, 0x2000, 0x5000};
 
   llvm::MapVector<uint64_t, MemInfoBlock> Prof;
   Prof[0x1].AllocCount = 1;
   Prof[0x2].AllocCount = 1;
 
   auto Seg = makeSegments();
 
   RawMemProfReader Reader(std::move(Symbolizer), Seg, Prof, CSM);