Merge pull request #11176 from augusto2112/cp-lldb-rebranch-2

[lldb] Cherry pick missing commits into stable/21.x

Author: augusto2112

lldb/cmake/modules/AddLLDB.cmake

@@ -191,8 +191,8 @@ function(add_properties_for_swift_modules target reldir)
       set_property(TARGET ${target} APPEND PROPERTY INSTALL_RPATH "${SWIFT_INSTALL_RPATH}")
     elseif (CMAKE_SYSTEM_NAME MATCHES "Linux|Android|OpenBSD|FreeBSD")
       string(REGEX MATCH "^[^-]*" arch ${LLVM_TARGET_TRIPLE})
-      target_link_libraries(${target} PRIVATE swiftCore-linux-${arch})
       string(TOLOWER ${CMAKE_SYSTEM_NAME} platform)
+      target_link_libraries(${target} PRIVATE swiftCore-${platform}-${arch})
       set(SWIFT_BUILD_RPATH "${LLDB_SWIFT_LIBS}/${platform}")
       set(SWIFT_INSTALL_RPATH "$ORIGIN/${reldir}lib/swift/${platform}")
       set_property(TARGET ${target} APPEND PROPERTY BUILD_RPATH "${SWIFT_BUILD_RPATH}")

lldb/docs/use/formatting.rst

@@ -89,6 +89,8 @@ A complete list of currently supported format string variables is listed below:
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``function.name-without-args``                    | The name of the current function without arguments and values (used to include a function name in-line in the ``disassembly-format``)                                                                                                                                                       |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``function.name-qualifiers``                      | Any qualifiers added after the name of a function and before its arguments or template arguments. E.g., for Swift the name qualifier for ``closure #1 in A.foo<Int>()`` is `` in A.foo``.                                                                                                   |
++---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``function.basename``                             | The basename of the current function depending on the frame's language. E.g., for C++ the basename for ``void ns::foo<float>::bar<int>(int) const`` is ``bar``.                                                                                                                             |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``function.prefix``                               | Any prefix added to the demangled function name of the current function. This depends on the frame's language. E.g., for C++ the prefix will always be empty.                                                                                                                               |
@@ -332,6 +334,7 @@ The function names displayed in backtraces/``frame info``/``thread info`` are th
 - ``${function.prefix}``
 - ``${function.scope}``
 - ``${function.basename}``
+- ``${function.name-qualifiers}``
 - ``${function.template-arguments}``
 - ``${function.formatted-arguments}``
 - ``${function.qualifiers}``

lldb/include/lldb/Core/DemangledNameInfo.h

@@ -22,16 +22,29 @@ namespace lldb_private {
 struct DemangledNameInfo {
   /// A [start, end) pair for the function basename.
   /// The basename is the name without scope qualifiers
-  /// and without template parameters. E.g.,
+  /// and without template parameters.
+  ///
+  /// E.g.,
   /// \code{.cpp}
   ///    void foo::bar<int>::someFunc<float>(int) const &&
   ///                        ^       ^
   ///                      start    end
   /// \endcode
   std::pair<size_t, size_t> BasenameRange;
 
+  /// A [start, end) pair for the function template arguments.
+  ///
+  /// E.g.,
+  /// \code{.cpp}
+  ///    void foo::bar<int>::someFunc<float>(int) const &&
+  ///                                ^      ^
+  ///                              start   end
+  /// \endcode
+  std::pair<size_t, size_t> TemplateArgumentsRange;
+
   /// A [start, end) pair for the function scope qualifiers.
-  /// E.g., for
+  ///
+  /// E.g.,
   /// \code{.cpp}
   ///    void foo::bar<int>::qux<float>(int) const &&
   ///         ^              ^
@@ -40,6 +53,7 @@ struct DemangledNameInfo {
   std::pair<size_t, size_t> ScopeRange;
 
   /// Indicates the [start, end) of the function argument list.
+  ///
   /// E.g.,
   /// \code{.cpp}
   ///    int (*getFunc<float>(float, double))(int, int)
@@ -59,6 +73,19 @@ struct DemangledNameInfo {
   /// \endcode
   std::pair<size_t, size_t> QualifiersRange;
 
+  /// Indicates the [start, end) of the function's name qualifiers. This is a
+  /// catch-all range for anything in between the basename and the function's
+  /// arguments or template arguments, that is not tracked by the rest of the
+  /// pairs.
+  ///
+  /// E.g.,
+  /// \code{.swift}
+  ///    closure #1 in A.foo<Int>()
+  ///              ^        ^
+  ///            start     end
+  /// \endcode
+  std::pair<size_t, size_t> NameQualifiersRange;
+
   /// Indicates the [start, end) of the function's prefix. This is a
   /// catch-all range for anything that is not tracked by the rest of
   /// the pairs.
@@ -75,6 +102,11 @@ struct DemangledNameInfo {
     return BasenameRange.second > BasenameRange.first;
   }
 
+  /// Returns \c true if this object holds a valid template arguments range.
+  bool hasTemplateArguments() const {
+    return TemplateArgumentsRange.second >= TemplateArgumentsRange.first;
+  }
+
   /// Returns \c true if this object holds a valid scope range.
   bool hasScope() const { return ScopeRange.second >= ScopeRange.first; }
 
@@ -88,6 +120,11 @@ struct DemangledNameInfo {
     return QualifiersRange.second >= QualifiersRange.first;
   }
 
+  /// Returns \c true if this object holds a valid name qualifiers range.
+  bool hasNameQualifiers() const {
+    return NameQualifiersRange.second >= NameQualifiersRange.first;
+  }
+
   /// Returns \c true if this object holds a valid prefix range.
   bool hasPrefix() const { return PrefixRange.second >= PrefixRange.first; }
 

lldb/include/lldb/Core/FormatEntity.h

@@ -91,6 +91,7 @@ struct Entry {
     FunctionPrefix,
     FunctionScope,
     FunctionBasename,
+    FunctionNameQualifiers,
     FunctionTemplateArguments,
     FunctionFormattedArguments,
     FunctionReturnLeft,

lldb/include/lldb/Core/Mangled.h

@@ -39,6 +39,11 @@ class Mangled {
     ePreferDemangledWithoutArguments
   };
 
+  enum NameFormatPreference {
+    eCompactName,
+    eFullName,
+  };
+
   enum ManglingScheme {
     eManglingSchemeNone = 0,
     eManglingSchemeMSVC,
@@ -125,7 +130,9 @@ class Mangled {
   ///
   /// \return
   ///     A const reference to the demangled name string object.
-  ConstString GetDemangledName(const SymbolContext *sc = nullptr) const;
+  ConstString
+  GetDemangledName(const SymbolContext *sc = nullptr,
+                   NameFormatPreference preference = eFullName) const;
 
   /// Display demangled name get accessor.
   ///
@@ -291,7 +298,9 @@ class Mangled {
   /// demangled name (if any). If \c force is \c true (or the mangled name
   /// on this object was not previously demangled), demangle and cache the
   /// name.
-  ConstString GetDemangledNameImpl(bool force, const SymbolContext *sc = nullptr) const;
+  ConstString
+  GetDemangledNameImpl(bool force, const SymbolContext *sc = nullptr,
+                       NameFormatPreference preference = eFullName) const;
 
   /// The mangled version of the name.
   ConstString m_mangled;

lldb/include/lldb/Core/ModuleList.h

@@ -86,6 +86,7 @@ class ModuleListProperties : public Properties {
   bool GetSwiftLoadConformances() const;
   SwiftModuleLoadingMode GetSwiftModuleLoadingMode() const;
   bool SetSwiftModuleLoadingMode(SwiftModuleLoadingMode);
+  bool GetSwiftPreferSerializedBridgingHeader() const;
 
   bool GetEnableSwiftMetadataCache() const;
   uint64_t GetSwiftMetadataCacheMaxByteSize();

lldb/include/lldb/Target/Process.h

@@ -100,6 +100,7 @@ class ProcessProperties : public Properties {
   void SetStopOnSharedLibraryEvents(bool stop);
   bool GetDisableLangRuntimeUnwindPlans() const;
   void SetDisableLangRuntimeUnwindPlans(bool disable);
+  void DisableLanguageRuntimeUnwindPlansCallback();
   bool GetDetachKeepsStopped() const;
   void SetDetachKeepsStopped(bool keep_stopped);
   bool GetWarningsOptimization() const;

lldb/include/lldb/Utility/ThreadSafeStringMap.h

@@ -0,0 +1,61 @@
+//===-- ThreadSafeStringMap.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_UTILITY_THREADSAFESTRINGMAP_H
+#define LLDB_UTILITY_THREADSAFESTRINGMAP_H
+
+#include <mutex>
+
+#include "llvm/ADT/StringMap.h"
+
+namespace lldb_private {
+
+template <typename _ValueType> class ThreadSafeStringMap {
+public:
+  typedef llvm::StringMap<_ValueType> LLVMMapType;
+
+  ThreadSafeStringMap(unsigned map_initial_capacity = 0)
+      : m_map(map_initial_capacity), m_mutex() {}
+
+  void Insert(llvm::StringRef k, _ValueType v) {
+    std::lock_guard<std::mutex> guard(m_mutex);
+    m_map.insert(std::make_pair(k, v));
+  }
+
+  void Erase(llvm::StringRef k) {
+    std::lock_guard<std::mutex> guard(m_mutex);
+    m_map.erase(k);
+  }
+
+  _ValueType Lookup(llvm::StringRef k) {
+    std::lock_guard<std::mutex> guard(m_mutex);
+    return m_map.lookup(k);
+  }
+
+  bool Lookup(llvm::StringRef k, _ValueType &v) {
+    std::lock_guard<std::mutex> guard(m_mutex);
+    auto iter = m_map.find(k), end = m_map.end();
+    if (iter == end)
+      return false;
+    v = iter->second;
+    return true;
+  }
+
+  void Clear() {
+    std::lock_guard<std::mutex> guard(m_mutex);
+    m_map.clear();
+  }
+
+protected:
+  LLVMMapType m_map;
+  std::mutex m_mutex;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_UTILITY_THREADSAFESTRINGMAP_H

lldb/source/Commands/CommandObjectDWIMPrint.cpp

@@ -152,6 +152,8 @@ void CommandObjectDWIMPrint::DoExecute(StringRef command,
         return;
       }
     }
+    m_interpreter.PrintWarningsIfNecessary(result.GetOutputStream(),
+                                           m_cmd_name);
     result.SetStatus(eReturnStatusSuccessFinishResult);
   };
 

lldb/source/Commands/CommandObjectExpression.cpp

@@ -494,6 +494,9 @@ bool CommandObjectExpression::EvaluateExpression(llvm::StringRef expr,
           return false;
         }
 
+        m_interpreter.PrintWarningsIfNecessary(result.GetOutputStream(),
+                                               m_cmd_name);
+
         if (suppress_result)
           if (auto result_var_sp =
                   target.GetPersistentVariable(result_valobj_sp->GetName())) {