[lldb/Plugins] Replace platform-specific macro with LLVM_PRETTY_FUNCTION (NFC)

[mib]

Summary

This patch refactors Scripted Process and Scripted Thread related
classes to use LLVM_PRETTY_FUNCTION instead of the compiler macro.

Signed-off-by: Med Ismail Bennani <[e-mail]>

[JDevlieghere]

LGTM!

lldb/include/lldb/Interpreter/ScriptedInterface.h

 //===-- ScriptedInterface.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_INTERPRETER_SCRIPTEDINTERFACE_H
 #define LLDB_INTERPRETER_SCRIPTEDINTERFACE_H
 
-#ifdef _MSC_VER
-#define __PRETTY_FUNCTION__ __FUNCSIG__
-#endif
-
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"
 #include "lldb/lldb-private.h"
 
+#include "llvm/Support/Compiler.h"
+
 #include <string>
 
 namespace lldb_private {
 class ScriptedInterface {
 public:
   ScriptedInterface() = default;
   virtual ~ScriptedInterface() = default;
 

lldb/source/Plugins/Process/scripted/ScriptedProcess.cpp

bool ScriptedProcess::IsAlive() {
   if (m_interpreter && m_script_object_sp)
     return GetInterface().IsAlive();
   return false;
 }
 
 size_t ScriptedProcess::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
                                      Status &error) {
   if (!m_interpreter)
-    return GetInterface().ErrorWithMessage<size_t>(__PRETTY_FUNCTION__,
+    return GetInterface().ErrorWithMessage<size_t>(LLVM_PRETTY_FUNCTION,
                                                    "No interpreter.", error);
 
   lldb::DataExtractorSP data_extractor_sp =
       GetInterface().ReadMemoryAtAddress(addr, size, error);
 
   if (!data_extractor_sp || !data_extractor_sp->GetByteSize() || error.Fail())
     return 0;
 
   offset_t bytes_copied = data_extractor_sp->CopyByteOrderedData(
       0, data_extractor_sp->GetByteSize(), buf, size, GetByteOrder());
 
   if (!bytes_copied || bytes_copied == LLDB_INVALID_OFFSET)
     return GetInterface().ErrorWithMessage<size_t>(
-        __PRETTY_FUNCTION__, "Failed to copy read memory to buffer.", error);
+        LLVM_PRETTY_FUNCTION, "Failed to copy read memory to buffer.", error);
 
   return size;
 }
 
 ArchSpec ScriptedProcess::GetArchitecture() {
   return GetTarget().GetArchitecture();
 }
 
bool ScriptedProcess::DoUpdateThreadList(ThreadList &old_thread_list,
 
   CheckInterpreterAndScriptObject();
 
   Status error;
   ScriptLanguage language = m_interpreter->GetLanguage();
 
   if (language != eScriptLanguagePython)
     return GetInterface().ErrorWithMessage<bool>(
-        __PRETTY_FUNCTION__,
+        LLVM_PRETTY_FUNCTION,
         llvm::Twine("ScriptInterpreter language (" +
                     llvm::Twine(m_interpreter->LanguageToString(language)) +
                     llvm::Twine(") not supported."))
             .str(),
         error);
 
   lldb::ThreadSP thread_sp;
   thread_sp = std::make_shared<ScriptedThread>(*this, error);
 
   if (!thread_sp || error.Fail())
-    return GetInterface().ErrorWithMessage<bool>(__PRETTY_FUNCTION__,
+    return GetInterface().ErrorWithMessage<bool>(LLVM_PRETTY_FUNCTION,
                                                  error.AsCString(), error);
 
   new_thread_list.AddThread(thread_sp);
 
   return new_thread_list.GetSize(false) > 0;
 }
 
 bool ScriptedProcess::GetProcessInfo(ProcessInstanceInfo &info) {

lldb/source/Plugins/Process/scripted/ScriptedThread.cpp

bool ScriptedThread::CalculateStopInfo() {
   StructuredData::DictionarySP dict_sp = GetInterface()->GetStopReason();
 
   Status error;
   lldb::StopInfoSP stop_info_sp;
   lldb::StopReason stop_reason_type;
 
   if (!dict_sp->GetValueForKeyAsInteger("type", stop_reason_type))
     return GetInterface()->ErrorWithMessage<bool>(
-        __PRETTY_FUNCTION__,
+        LLVM_PRETTY_FUNCTION,
         "Couldn't find value for key 'type' in stop reason dictionary.", error);
 
   StructuredData::Dictionary *data_dict;
   if (!dict_sp->GetValueForKeyAsDictionary("data", data_dict))
     return GetInterface()->ErrorWithMessage<bool>(
-        __PRETTY_FUNCTION__,
+        LLVM_PRETTY_FUNCTION,
         "Couldn't find value for key 'type' in stop reason dictionary.", error);
 
   switch (stop_reason_type) {
   case lldb::eStopReasonNone:
     break;
   case lldb::eStopReasonBreakpoint: {
     lldb::break_id_t break_id;
     data_dict->GetValueForKeyAsInteger("break_id", break_id,
                                        LLDB_INVALID_BREAK_ID);
     stop_info_sp =
         StopInfo::CreateStopReasonWithBreakpointSiteID(*this, break_id);
   } break;
   case lldb::eStopReasonSignal: {
     int signal;
     llvm::StringRef description;
     data_dict->GetValueForKeyAsInteger("signal", signal,
                                        LLDB_INVALID_SIGNAL_NUMBER);
     data_dict->GetValueForKeyAsString("desc", description);
     stop_info_sp =
         StopInfo::CreateStopReasonWithSignal(*this, signal, description.data());
   } break;
   default:
     return GetInterface()->ErrorWithMessage<bool>(
-        __PRETTY_FUNCTION__,
+        LLVM_PRETTY_FUNCTION,
         llvm::Twine("Unsupported stop reason type (" +
                     llvm::Twine(stop_reason_type) + llvm::Twine(")."))
             .str(),
         error);
   }
 
   SetStopInfo(stop_info_sp);
   return true;

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedProcessPythonInterface.cpp

 Status ScriptedProcessPythonInterface::Resume() {
   return GetStatusFromMethod("resume");
 }
 
 bool ScriptedProcessPythonInterface::ShouldStop() {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("is_alive", error);
 
-  if (!CheckStructuredDataObject(__PRETTY_FUNCTION__, obj, error))
+  if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return {};
 
   return obj->GetBooleanValue();
 }
 
 Status ScriptedProcessPythonInterface::Stop() {
   return GetStatusFromMethod("stop");
 }
 
 llvm::Optional<MemoryRegionInfo>
 ScriptedProcessPythonInterface::GetMemoryRegionContainingAddress(
     lldb::addr_t address, Status &error) {
   auto mem_region = Dispatch<llvm::Optional<MemoryRegionInfo>>(
       "get_memory_region_containing_address", error, address);
 
   if (error.Fail()) {
-    return ErrorWithMessage<MemoryRegionInfo>(__PRETTY_FUNCTION__,
+    return ErrorWithMessage<MemoryRegionInfo>(LLVM_PRETTY_FUNCTION,
                                               error.AsCString(), error);
   }
 
   return mem_region;
 }
 
 StructuredData::DictionarySP
 ScriptedProcessPythonInterface::GetThreadWithID(lldb::tid_t tid) {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("get_thread_with_id", error, tid);
 
-  if (!CheckStructuredDataObject(__PRETTY_FUNCTION__, obj, error))
+  if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return {};
 
   StructuredData::DictionarySP dict{obj->GetAsDictionary()};
 
   return dict;
 }
 
 StructuredData::DictionarySP
StructuredData::DictionarySP ScriptedProcessPythonInterface::GetLoadedImages() {
   // TODO: Implement
   return {};
 }
 
 lldb::pid_t ScriptedProcessPythonInterface::GetProcessID() {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("get_process_id", error);
 
-  if (!CheckStructuredDataObject(__PRETTY_FUNCTION__, obj, error))
+  if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return LLDB_INVALID_PROCESS_ID;
 
   return obj->GetIntegerValue(LLDB_INVALID_PROCESS_ID);
 }
 
 bool ScriptedProcessPythonInterface::IsAlive() {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("is_alive", error);
 
-  if (!CheckStructuredDataObject(__PRETTY_FUNCTION__, obj, error))
+  if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return {};
 
   return obj->GetBooleanValue();
 }
 
 llvm::Optional<std::string>
 ScriptedProcessPythonInterface::GetScriptedThreadPluginName() {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("get_scripted_thread_plugin", error);
 
-  if (!CheckStructuredDataObject(__PRETTY_FUNCTION__, obj, error))
+  if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return {};
 
   return obj->GetStringValue().str();
 }
 
 lldb::ScriptedThreadInterfaceSP
 ScriptedProcessPythonInterface::GetScriptedThreadInterface() {
   if (!m_scripted_thread_interface_sp)
     m_scripted_thread_interface_sp =
         std::make_shared<ScriptedThreadPythonInterface>(m_interpreter);
 
   return m_scripted_thread_interface_sp;
 }
 
 #endif

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedPythonInterface.h

protected:
   }
 
   template <typename T = StructuredData::ObjectSP, typename... Args>
   T Dispatch(llvm::StringRef method_name, Status &error, Args... args) {
     using namespace python;
     using Locker = ScriptInterpreterPythonImpl::Locker;
 
     std::string caller_signature =
-        llvm::Twine(__PRETTY_FUNCTION__ + llvm::Twine(" (") +
+        llvm::Twine(LLVM_PRETTY_FUNCTION + llvm::Twine(" (") +
                     llvm::Twine(method_name) + llvm::Twine(")"))
             .str();
     if (!m_object_instance_sp)
       return ErrorWithMessage<T>(caller_signature, "Python object ill-formed",
                                  error);
 
     Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
                    Locker::FreeLock);

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedThreadPythonInterface.cpp

StructuredData::GenericSP ScriptedThreadPythonInterface::CreatePluginObject(
 
   return m_object_instance_sp;
 }
 
 lldb::tid_t ScriptedThreadPythonInterface::GetThreadID() {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("get_thread_id", error);
 
-  if (!CheckStructuredDataObject(__PRETTY_FUNCTION__, obj, error))
+  if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return LLDB_INVALID_THREAD_ID;
 
   return obj->GetIntegerValue(LLDB_INVALID_THREAD_ID);
 }
 
 llvm::Optional<std::string> ScriptedThreadPythonInterface::GetName() {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("get_name", error);
 
-  if (!CheckStructuredDataObject(__PRETTY_FUNCTION__, obj, error))
+  if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return {};
 
   return obj->GetStringValue().str();
 }
 
 lldb::StateType ScriptedThreadPythonInterface::GetState() {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("get_state", error);
 
-  if (!CheckStructuredDataObject(__PRETTY_FUNCTION__, obj, error))
+  if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return eStateInvalid;
 
   return static_cast<StateType>(obj->GetIntegerValue(eStateInvalid));
 }
 
 llvm::Optional<std::string> ScriptedThreadPythonInterface::GetQueue() {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("get_queue", error);
 
-  if (!CheckStructuredDataObject(__PRETTY_FUNCTION__, obj, error))
+  if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return {};
 
   return obj->GetStringValue().str();
 }
 
 StructuredData::DictionarySP ScriptedThreadPythonInterface::GetStopReason() {
   Status error;
   StructuredData::DictionarySP dict =
       Dispatch<StructuredData::DictionarySP>("get_stop_reason", error);
 
-  if (!CheckStructuredDataObject(__PRETTY_FUNCTION__, dict, error))
+  if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, dict, error))
     return {};
 
   return dict;
 }
 
 StructuredData::ArraySP ScriptedThreadPythonInterface::GetStackFrames() {
   return nullptr;
 }
 
 StructuredData::DictionarySP ScriptedThreadPythonInterface::GetRegisterInfo() {
   Status error;
   StructuredData::DictionarySP dict =
       Dispatch<StructuredData::DictionarySP>("get_register_info", error);
 
-  if (!CheckStructuredDataObject(__PRETTY_FUNCTION__, dict, error))
+  if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, dict, error))
     return {};
 
   return dict;
 }
 
 llvm::Optional<std::string>
 ScriptedThreadPythonInterface::GetRegisterContext() {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("get_register_context", error);
 
-  if (!CheckStructuredDataObject(__PRETTY_FUNCTION__, obj, error))
+  if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return {};
 
   return obj->GetAsString()->GetValue().str();
 }
 
 #endif