[OptRemark] Demangle symbols when emitting remarks

[thegameg]

Summary

Use the itaniumDemangler in Demangle/Demangle.h to demangle symbols starting with "_Z".

[hfinkel]

I specifically didn't want to do this for the YAML output. The tool consuming the YAML should demangle if it wants. It's hard to go backward, and so if the tool needs to map back to symbols in the program, it needs the mangled name. That having been said:

1. I'm happy to demangle in textual output from the command-line tools (although we should probably print both the mangled and demangled name).
2. I'm happy to include both the mangled and demangled name in the YAML.

[thegameg]

Thanks Hal!

In D49139#1157602, @hfinkel wrote:

1. I'm happy to demangle in textual output from the command-line tools (although we should probably print both the mangled and demangled name).

• I'll follow up in a new patch to demangle in the command line output but keep the mangled name in the serialized format.
• Part of this was to match swift's behavior, but we might be better using the mangled name in swift as well.

lib/IR/DiagnosticInfo.cpp

 // Diagnostics reporting is still done as part of the LLVMContext.
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/DiagnosticInfo.h"
 #include "LLVMContextImpl.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/iterator_range.h"
+#include "llvm/Demangle/Demangle.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/Instruction.h"

 
 int llvm::getNextAvailablePluginDiagnosticKind() {
   static std::atomic<int> PluginKindID(DK_FirstPluginKind);
   return ++PluginKindID;
 }
 
 const char *OptimizationRemarkAnalysis::AlwaysPrint = "";
 
+// Itanium demangle a name from a global value (global variable, function).
+// Returns a pointer to a null-terminated string and the length of the string.
+static std::pair<std::unique_ptr<char, decltype(&std::free)>, size_t>
+demangleCXXGlobalValue(StringRef Function) {
+  if (!Function.startswith("_Z"))
+    return {std::unique_ptr<char, decltype(&std::free)>(nullptr, nullptr), 0};
+  size_t Len = 0;
+  int Status = 0;
+  char *Demangled = itaniumDemangle(Function.data(), nullptr, &Len, &Status);
+  if (!Demangled || Status != 0)
+    return {std::unique_ptr<char, decltype(&std::free)>(nullptr, nullptr), 0};
+  return {std::unique_ptr<char, decltype(&std::free)>(Demangled, std::free),
+          Len - 1};
+}
+
 DiagnosticInfoInlineAsm::DiagnosticInfoInlineAsm(const Instruction &I,
                                                  const Twine &MsgStr,
                                                  DiagnosticSeverity Severity)
     : DiagnosticInfo(DK_InlineAsm, Severity), MsgStr(MsgStr), Instr(&I) {
   if (const MDNode *SrcLoc = I.getMetadata("srcloc")) {
     if (SrcLoc->getNumOperands() != 0)
       if (const auto *CI =
               mdconst::dyn_extract<ConstantInt>(SrcLoc->getOperand(0)))
if (auto *F = dyn_cast<Function>(V)) {
     if (DISubprogram *SP = F->getSubprogram())
       Loc = SP;
   }
   else if (auto *I = dyn_cast<Instruction>(V))
     Loc = I->getDebugLoc();
 
   // Only include names that correspond to user variables.  FIXME: We should use
   // debug info if available to get the name of the user variable.
-  if (isa<llvm::Argument>(V) || isa<GlobalValue>(V))
+  if (isa<GlobalValue>(V)) {
+    StringRef Name = GlobalValue::dropLLVMManglingEscape(V->getName());
+    auto Demangled = demangleCXXGlobalValue(Name);
+    if (size_t Len = Demangled.second)
+      Val = std::string(Demangled.first.get(), Len);
+    else
+      Val = Name;
+  } else if (isa<llvm::Argument>(V)) {
     Val = GlobalValue::dropLLVMManglingEscape(V->getName());
-  else if (isa<Constant>(V)) {
+  } else if (isa<Constant>(V)) {
     raw_string_ostream OS(Val);
     V->printAsOperand(OS, /*PrintType=*/false);
   } else if (auto *I = dyn_cast<Instruction>(V))
     Val = I->getOpcodeName();
 }
 
 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, const Type *T)
     : Key(Key) {
void MappingTraits<DiagnosticInfoOptimizationBase *>::mapping(
   StringRef FN =
       GlobalValue::dropLLVMManglingEscape(OptDiag->getFunction().getName());
 
   StringRef PassName(OptDiag->PassName);
   io.mapRequired("Pass", PassName);
   io.mapRequired("Name", OptDiag->RemarkName);
   if (!io.outputting() || DL.isValid())
     io.mapOptional("DebugLoc", DL);
+
+  auto DemangledFN = demangleCXXGlobalValue(FN);
+  if (size_t Len = DemangledFN.second) {
+    StringRef Demangled(DemangledFN.first.get(), Len);
+    io.mapRequired("Function", Demangled);
+  } else {
     io.mapRequired("Function", FN);
+  }
+
   io.mapOptional("Hotness", OptDiag->Hotness);
   io.mapOptional("Args", OptDiag->Args);
 }
 
 template <> struct MappingTraits<DiagnosticLocation> {
   static void mapping(IO &io, DiagnosticLocation &DL) {
     assert(io.outputting() && "input not yet implemented");
 

test/Transforms/LoopVectorize/X86/vectorization-remarks-missed.ll

 ; }
 ; CHECK: remark: source.cpp:29:7: loop not vectorized: control flow cannot be substituted for a select
 ; CHECK: remark: source.cpp:27:3: loop not vectorized
 
 ; YAML:       --- !Analysis
 ; YAML-NEXT: Pass:            loop-vectorize
 ; YAML-NEXT: Name:            CantComputeNumberOfIterations
 ; YAML-NEXT: DebugLoc:        { File: source.cpp, Line: 4, Column: 5 }
-; YAML-NEXT: Function:        _Z4testPii
+; YAML-NEXT: Function:        'test(int*, int)'
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - String:          'loop not vectorized: '
 ; YAML-NEXT:   - String:          could not determine number of loop iterations
 ; YAML-NEXT: ...
 ; YAML-NEXT: --- !Missed
 ; YAML-NEXT: Pass:            loop-vectorize
 ; YAML-NEXT: Name:            MissedDetails
 ; YAML-NEXT: DebugLoc:        { File: source.cpp, Line: 4, Column: 5 }
-; YAML-NEXT: Function:        _Z4testPii
+; YAML-NEXT: Function:        'test(int*, int)'
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - String:          loop not vectorized
 ; YAML-NEXT: ...
 ; YAML-NEXT: --- !Analysis
 ; YAML-NEXT: Pass:            loop-vectorize
 ; YAML-NEXT: Name:            AllDisabled
 ; YAML-NEXT: DebugLoc:        { File: source.cpp, Line: 13, Column: 5 }
-; YAML-NEXT: Function:        _Z13test_disabledPii
+; YAML-NEXT: Function:        'test_disabled(int*, int)'
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - String:          'loop not vectorized: vectorization and interleaving are explicitly disabled, or the loop has already been vectorized
 ; YAML-NEXT: ...
 ; YAML-NEXT: --- !Analysis
 ; YAML-NEXT: Pass:            ''
 ; YAML-NEXT: Name:            CantIdentifyArrayBounds
 ; YAML-NEXT: DebugLoc:        { File: source.cpp, Line: 19, Column: 5 }
-; YAML-NEXT: Function:        _Z17test_array_boundsPiS_i
+; YAML-NEXT: Function:        'test_array_bounds(int*, int*, int)'
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - String:          'loop not vectorized: '
 ; YAML-NEXT:   - String:          cannot identify array bounds
 ; YAML-NEXT: ...
 ; YAML-NEXT: --- !Missed
 ; YAML-NEXT: Pass:            loop-vectorize
 ; YAML-NEXT: Name:            MissedDetails
 ; YAML-NEXT: DebugLoc:        { File: source.cpp, Line: 19, Column: 5 }
-; YAML-NEXT: Function:        _Z17test_array_boundsPiS_i
+; YAML-NEXT: Function:        'test_array_bounds(int*, int*, int)'
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - String:          loop not vectorized
 ; YAML-NEXT:   - String:          ' (Force='
 ; YAML-NEXT:   - Force:           'true'
 ; YAML-NEXT:   - String:          ')'
 ; YAML-NEXT: ...
 ; YAML-NEXT: --- !Failure
 ; YAML-NEXT: Pass:            loop-vectorize
 ; YAML-NEXT: Name:            FailedRequestedVectorization
 ; YAML-NEXT: DebugLoc:        { File: source.cpp, Line: 19, Column: 5 }
-; YAML-NEXT: Function:        _Z17test_array_boundsPiS_i
+; YAML-NEXT: Function:        'test_array_bounds(int*, int*, int)'
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - String:          'loop not vectorized: '
 ; YAML-NEXT:   - String:          failed explicitly specified loop vectorization
 ; YAML-NEXT: ...
 ; YAML-NEXT: --- !Analysis
 ; YAML-NEXT: Pass:            loop-vectorize
 ; YAML-NEXT: Name:            NoCFGForSelect
 ; YAML-NEXT: DebugLoc:        { File: source.cpp, Line: 29, Column: 7 }

test/Transforms/SampleProfile/inline-coverage.ll

 ;     6
 ;     7    int main() {
 ;     8      long long int sum = 0;
 ;     9      for (int i = 0; i < 200000 * 3000; i++)
 ;    10        sum += foo(i);
 ;    11      return sum > 0 ? 0 : 1;
 ;    12    }
 ;
-; CHECK: remark: coverage.cc:10:12: inlined hot callee '_Z3fool' into 'main'
+; CHECK: remark: coverage.cc:10:12: inlined hot callee 'foo(long)' into 'main'
 ; CHECK: remark: coverage.cc:9:21: Applied 23478 samples from profile (offset: 2.1)
 ; CHECK: remark: coverage.cc:10:16: Applied 23478 samples from profile (offset: 3)
 ; CHECK: remark: coverage.cc:4:10: Applied 31878 samples from profile (offset: 1)
 ; CHECK: remark: coverage.cc:11:10: Applied 0 samples from profile (offset: 4)
 ; CHECK: remark: coverage.cc:10:16: most popular destination for conditional branches at coverage.cc:9:3
 ;
 ; There is one sample record with 0 samples at offset 4 in main() that we never
 ; use:

test/Transforms/SampleProfile/remarks.ll

 ;     9          sum += -i * rand();
 ;    10      return sum;
 ;    11    }
 ;    12
 ;    13    int main() { return foo() > 0; }
 
 ; We are expecting foo() to be inlined in main() (almost all the cycles are
 ; spent inside foo).
-; CHECK: remark: remarks.cc:13:21: inlined hot callee '_Z3foov' into 'main'
+; CHECK: remark: remarks.cc:13:21: inlined hot callee 'foo()' into 'main'
 
 ; The back edge for the loop is the hottest edge in the loop subgraph.
 ; CHECK: remark: remarks.cc:6:9: most popular destination for conditional branches at remarks.cc:5:3
 
 ; The predicate almost always chooses the 'else' branch.
 ; CHECK: remark: remarks.cc:9:15: most popular destination for conditional branches at remarks.cc:6:9
 
 ; Checking to see if YAML file is generated and contains remarks
 ;YAML:       --- !Passed
 ;YAML-NEXT:  Pass:            sample-profile
 ;YAML-NEXT:  Name:            HotInline
 ;YAML-NEXT:  DebugLoc:        { File: remarks.cc, Line: 13, Column: 21 }
 ;YAML-NEXT:  Function:        main
 ;YAML-NEXT:  Args:
 ;YAML-NEXT:    - String:          'inlined hot callee '''
-;YAML-NEXT:    - Callee:          _Z3foov
+;YAML-NEXT:    - Callee:          'foo()'
 ;YAML-NEXT:      DebugLoc:        { File: remarks.cc, Line: 3, Column: 0 }
 ;YAML-NEXT:    - String:          ''' into '''
 ;YAML-NEXT:    - Caller:          main
 ;YAML-NEXT:        DebugLoc:        { File: remarks.cc, Line: 13, Column: 0 }
 ;YAML-NEXT:    - String:          ''''
 ;YAML-NEXT:  ...
 ;YAML:  --- !Analysis
 ;YAML-NEXT:  Pass:            sample-profile