[cling] Enable JITLink debugging and profiling support

`CLING_PROFILE=1` enables perf profiling using `jitdump` format.

Profiling now requires a `perf inject` step (with JITLink):
```
perf record -k 1 <cling>
perf inject -j -i perf.data -o perf.jitted.data
perf report -i perf.jitted.data
```

Author: devajithvs

interpreter/cling/README.md

@@ -119,6 +119,26 @@ or
 [cling]$ .help
 ```
 
+Debugging and Profiling JITted Code
+-----------------------------------
+
+Cling provides support for debugging and profiling interpreted (JITted) code.
+- `CLING_DEBUG=1` enables debug symbol emission on interpreted code, allowing
+the use of a standard debugger. Debugging is aided by switching off
+optimisations and adding frame pointers for better stack traces.
+- `CLING_PROFILE=1` enables perf profiling:
+  - When `jitlink` is enabled (`CLING_JITLINK=1`, soon the default), profiling
+requires a [`perf inject`](https://linux.die.net/man/1/perf-inject) step:
+    ```bash
+    perf record -k 1 <cling>
+    perf inject -j -i perf.data -o perf.jitted.data
+    perf report -i perf.jitted.data
+    ```
+  - When `jitlink` is disabled, perf support is enabled with "perf map" (legacy)
+instead of "JIT dump" and there is no need for an inject step.
+
+Debugging and Profiling, both have a runtime cost, and is therefore disabled by
+default.
 
 Jupyter
 -------

interpreter/cling/lib/Interpreter/CMakeLists.txt

@@ -48,6 +48,7 @@ set(LLVM_LINK_COMPONENTS
   object
   option
   orcjit
+  orcdebugging
   runtimedyld
   scalaropts
   support

interpreter/cling/lib/Interpreter/IncrementalJIT.cpp

@@ -19,9 +19,13 @@
 #include <clang/Basic/TargetOptions.h>
 #include <clang/Frontend/CompilerInstance.h>
 
+#include <llvm/ExecutionEngine/Orc/Debugging/DebugInfoSupport.h>
+#include <llvm/ExecutionEngine/Orc/Debugging/DebuggerSupport.h>
+#include <llvm/ExecutionEngine/Orc/Debugging/PerfSupportPlugin.h>
 #include <llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h>
 #include <llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h>
 #include <llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h>
+#include <llvm/ExecutionEngine/Orc/TargetProcess/JITLoaderPerf.h>
 #include <llvm/ExecutionEngine/SectionMemoryManager.h>
 #include <llvm/IR/LLVMContext.h>
 #include <llvm/MC/TargetRegistry.h>
@@ -40,7 +44,57 @@ using namespace llvm;
 using namespace llvm::jitlink;
 using namespace llvm::orc;
 
+static LLVM_ATTRIBUTE_USED void linkComponents() {
+  errs() << "Linking in runtime functions\n"
+         << (void*)&llvm_orc_registerJITLoaderPerfStart << '\n'
+         << (void*)&llvm_orc_registerJITLoaderPerfEnd << '\n'
+         << (void*)&llvm_orc_registerJITLoaderPerfImpl << '\n';
+}
+
 namespace {
+  // This could potentially be upstreamed, similar to enableDebuggerSupport()
+  Error enablePerfSupport(LLJIT& J) {
+    auto* ObjLinkingLayer =
+        dyn_cast<ObjectLinkingLayer>(&J.getObjLinkingLayer());
+    if (!ObjLinkingLayer)
+      return make_error<StringError>("Cannot enable LLJIT perf support: "
+                                     "perf support requires JITLink",
+                                     inconvertibleErrorCode());
+    auto ProcessSymsJD = J.getProcessSymbolsJITDylib();
+    if (!ProcessSymsJD)
+      return make_error<StringError>("Cannot enable LLJIT perf support: "
+                                     "Process symbols are not available",
+                                     inconvertibleErrorCode());
+
+    auto& ES = J.getExecutionSession();
+    const auto& TT = J.getTargetTriple();
+
+    switch (TT.getObjectFormat()) {
+      case Triple::ELF: {
+        auto debugInfoPreservationPlugin =
+            DebugInfoPreservationPlugin::Create();
+        if (!debugInfoPreservationPlugin)
+          return debugInfoPreservationPlugin.takeError();
+
+        auto perfSupportPlugin =
+            PerfSupportPlugin::Create(ES.getExecutorProcessControl(),
+                                      *ProcessSymsJD, true, true);
+        if (!perfSupportPlugin)
+          return perfSupportPlugin.takeError();
+
+        ObjLinkingLayer->addPlugin(std::move(*debugInfoPreservationPlugin));
+        ObjLinkingLayer->addPlugin(std::move(*perfSupportPlugin));
+
+        return Error::success();
+      }
+      default:
+        return make_error<StringError>("Cannot enable LLJIT perf support: " +
+                                           Triple::getObjectFormatTypeName(
+                                               TT.getObjectFormat()) +
+                                           " is not supported",
+                                       inconvertibleErrorCode());
+    }
+  }
 
   class ClingMMapper final : public SectionMemoryManager::MemoryMapper {
   public:
@@ -491,6 +545,18 @@ IncrementalJIT::IncrementalJIT(
   Builder.setDataLayout(m_TM->createDataLayout());
   Builder.setExecutorProcessControl(std::move(EPC));
 
+  if (m_JITLink) {
+    Builder.setPrePlatformSetup([](llvm::orc::LLJIT& J) {
+      // Try to enable debugging of JIT'd code (only works with JITLink for
+      // ELF and MachO).
+      if (cling::utils::ConvertEnvValueToBool(std::getenv("CLING_DEBUG")))
+        consumeError(enableDebuggerSupport(J));
+      if (cling::utils::ConvertEnvValueToBool(std::getenv("CLING_PROFILE")))
+        consumeError(enablePerfSupport(J));
+      return llvm::Error::success();
+    });
+  }
+
   // Create ObjectLinkingLayer with our own MemoryManager.
   Builder.setObjectLinkingLayerCreator([&](ExecutionSession& ES,
                                            const Triple& TT)