Merged main:fd4c80dec929 into amd-gfx:291c2654279d

Local branch amd-gfx 291c265 Merged main:3df1a64ebad8 into amd-gfx:efed4dce5ec1
Remote branch main fd4c80d [OpenMP] Fix gettid warnings on DragonFly (llvm#65549)

Author: SC llvm team

lldb/test/API/tools/lldb-vscode/variables/TestVSCode_variables.py

@@ -517,6 +517,20 @@ def test_indexedVariables(self):
         }
         self.verify_variables(verify_locals, locals)
 
+        # We also verify that we produce a "[raw]" fake child with the real
+        # SBValue for the synthetic type.
+        verify_children = {
+            "[0]": {"equals": {"type": "int", "value": "0"}},
+            "[1]": {"equals": {"type": "int", "value": "0"}},
+            "[2]": {"equals": {"type": "int", "value": "0"}},
+            "[3]": {"equals": {"type": "int", "value": "0"}},
+            "[4]": {"equals": {"type": "int", "value": "0"}},
+            "[raw]": {"contains": {"type": ["vector"]}},
+        }
+        children = self.vscode.request_variables(locals[2]["variablesReference"])["body"]["variables"]
+        self.verify_variables(verify_children, children)
+
+
     @skipIfWindows
     @skipIfRemote
     def test_registers(self):

lldb/tools/lldb-vscode/JSONUtils.cpp

@@ -1103,10 +1103,13 @@ std::string CreateUniqueVariableNameForDisplay(lldb::SBValue v,
 // }
 llvm::json::Value CreateVariable(lldb::SBValue v, int64_t variablesReference,
                                  int64_t varID, bool format_hex,
-                                 bool is_name_duplicated) {
+                                 bool is_name_duplicated,
+                                 std::optional<std::string> custom_name) {
   llvm::json::Object object;
-  EmplaceSafeString(object, "name",
-                    CreateUniqueVariableNameForDisplay(v, is_name_duplicated));
+  EmplaceSafeString(
+      object, "name",
+      custom_name ? *custom_name
+                  : CreateUniqueVariableNameForDisplay(v, is_name_duplicated));
 
   if (format_hex)
     v.SetFormat(lldb::eFormatHex);
@@ -1131,15 +1134,19 @@ llvm::json::Value CreateVariable(lldb::SBValue v, int64_t variablesReference,
   const bool is_synthetic = v.IsSynthetic();
   if (is_array || is_synthetic) {
     const auto num_children = v.GetNumChildren();
+    // We create a "[raw]" fake child for each synthetic type, so we have to
+    // account for it when returning indexed variables. We don't need to do this
+    // for non-indexed ones.
+    int actual_num_children = num_children + (is_synthetic ? 1 : 0);
     if (is_array) {
-      object.try_emplace("indexedVariables", num_children);
+      object.try_emplace("indexedVariables", actual_num_children);
     } else if (num_children > 0) {
       // If a type has a synthetic child provider, then the SBType of "v" won't
       // tell us anything about what might be displayed. So we can check if the
       // first child's name is "[0]" and then we can say it is indexed.
       const char *first_child_name = v.GetChildAtIndex(0).GetName();
       if (first_child_name && strcmp(first_child_name, "[0]") == 0)
-        object.try_emplace("indexedVariables", num_children);
+        object.try_emplace("indexedVariables", actual_num_children);
     }
   }
   EmplaceSafeString(object, "type", type_cstr ? type_cstr : NO_TYPENAME);

lldb/tools/lldb-vscode/JSONUtils.h

@@ -440,12 +440,17 @@ std::string CreateUniqueVariableNameForDisplay(lldb::SBValue v,
 ///     As VSCode doesn't render two of more variables with the same name, we
 ///     apply a suffix to distinguish duplicated variables.
 ///
+/// \param[in] custom_name
+///     A provided custom name that is used instead of the SBValue's when
+///     creating the JSON representation.
+///
 /// \return
 ///     A "Variable" JSON object with that follows the formal JSON
 ///     definition outlined by Microsoft.
 llvm::json::Value CreateVariable(lldb::SBValue v, int64_t variablesReference,
                                  int64_t varID, bool format_hex,
-                                 bool is_name_duplicated = false);
+                                 bool is_name_duplicated = false,
+                                 std::optional<std::string> custom_name = {});
 
 llvm::json::Value CreateCompileUnit(lldb::SBCompileUnit unit);
 

lldb/tools/lldb-vscode/lldb-vscode.cpp

@@ -3251,7 +3251,7 @@ void request_variables(const llvm::json::Object &request) {
         break;
 
       int64_t var_ref = 0;
-      if (variable.MightHaveChildren()) {
+      if (variable.MightHaveChildren() || variable.IsSynthetic()) {
         var_ref = g_vsc.variables.InsertExpandableVariable(
             variable, /*is_permanent=*/false);
       }
@@ -3264,23 +3264,36 @@ void request_variables(const llvm::json::Object &request) {
     // children.
     lldb::SBValue variable = g_vsc.variables.GetVariable(variablesReference);
     if (variable.IsValid()) {
-      const auto num_children = variable.GetNumChildren();
-      const int64_t end_idx = start + ((count == 0) ? num_children : count);
-      for (auto i = start; i < end_idx; ++i) {
-        lldb::SBValue child = variable.GetChildAtIndex(i);
+      auto addChild = [&](lldb::SBValue child,
+                          std::optional<std::string> custom_name = {}) {
         if (!child.IsValid())
-          break;
+          return;
         if (child.MightHaveChildren()) {
           auto is_permanent =
               g_vsc.variables.IsPermanentVariableReference(variablesReference);
           auto childVariablesReferences =
               g_vsc.variables.InsertExpandableVariable(child, is_permanent);
-          variables.emplace_back(CreateVariable(child, childVariablesReferences,
-                                                childVariablesReferences, hex));
+          variables.emplace_back(CreateVariable(
+              child, childVariablesReferences, childVariablesReferences, hex,
+              /*is_name_duplicated=*/false, custom_name));
         } else {
-          variables.emplace_back(CreateVariable(child, 0, INT64_MAX, hex));
+          variables.emplace_back(CreateVariable(child, 0, INT64_MAX, hex,
+                                                /*is_name_duplicated=*/false,
+                                                custom_name));
         }
-      }
+      };
+      const int64_t num_children = variable.GetNumChildren();
+      int64_t end_idx = start + ((count == 0) ? num_children : count);
+      int64_t i = start;
+      for (; i < end_idx && i < num_children; ++i)
+        addChild(variable.GetChildAtIndex(i));
+
+      // If we haven't filled the count quota from the request, we insert a new
+      // "[raw]" child that can be used to inspect the raw version of a
+      // synthetic member. That eliminates the need for the user to go to the
+      // debug console and type `frame var <variable> to get these values.
+      if (variable.IsSynthetic() && i == num_children)
+        addChild(variable.GetNonSyntheticValue(), "[raw]");
     }
   }
   llvm::json::Object body;

llvm/include/llvm/Config/llvm-config.h.cmake

@@ -16,7 +16,7 @@
 
 /* Indicate that this is LLVM compiled from the amd-gfx branch. */
 #define LLVM_HAVE_BRANCH_AMD_GFX
-#define LLVM_MAIN_REVISION 473792
+#define LLVM_MAIN_REVISION 473796
 
 /* Define if LLVM_ENABLE_DUMP is enabled */
 #cmakedefine LLVM_ENABLE_DUMP

llvm/utils/gn/secondary/libcxx/config.gni

@@ -4,4 +4,7 @@ declare_args() {
 
   # libc++ inline ABI namespace. Defaults to __n, where n is the ABI version.
   libcxx_abi_namespace = ""
+
+  # Build timezone database as part of libc++experimental.
+  libcxx_enable_time_zone_database = target_os == "linux"
 }

llvm/utils/gn/secondary/libcxx/include/BUILD.gn

@@ -51,6 +51,11 @@ if (current_toolchain == default_toolchain) {
     } else {
       values += [ "_LIBCPP_ABI_NAMESPACE=__" + libcxx_abi_version ]
     }
+    if (!libcxx_enable_time_zone_database) {
+      values += [ "_LIBCPP_HAS_NO_TIME_ZONE_DATABASE=1" ]
+    } else {
+      values += [ "_LIBCPP_HAS_NO_TIME_ZONE_DATABASE=" ]
+    }
   }
 
   write_cmake_config("write_modulemap") {
@@ -351,6 +356,8 @@ if (current_toolchain == default_toolchain) {
       "__chrono/steady_clock.h",
       "__chrono/system_clock.h",
       "__chrono/time_point.h",
+      "__chrono/tzdb.h",
+      "__chrono/tzdb_list.h",
       "__chrono/weekday.h",
       "__chrono/year.h",
       "__chrono/year_month.h",

llvm/utils/gn/secondary/libcxx/src/BUILD.gn

@@ -12,7 +12,7 @@ declare_args() {
   # Build libc++ as a static library.
   libcxx_enable_static = true
 
-  # Build filesystem as part of libc++fs.a.
+  # Build filesystem as part of libc++.
   libcxx_enable_filesystem = target_os != "win"
 
   # Build libc++experimental.a.
@@ -307,6 +307,12 @@ if (libcxx_enable_experimental) {
     output_dir = runtimes_dir
     output_name = "c++experimental"
     sources = [ "experimental/memory_resource.cpp" ]
+    if (libcxx_enable_filesystem && libcxx_enable_time_zone_database) {
+      sources += [
+        "tz.cpp",
+        "tzdb_list.cpp",
+      ]
+    }
     deps = [ "//libcxx/include" ]
     configs += [ ":cxx_config" ]
     configs -= [

mlir/utils/lldb-scripts/mlirDataFormatters.py

@@ -196,6 +196,7 @@ def __init__(self, valobj: lldb.SBValue, internal_dict):
             valobj, self.abstractVal, internal_dict
         )
         if not self.type:
+            self.impl_type = None
             return
 
         # Grab the ImplTy from the resolved type. This is the 3rd template

openmp/runtime/src/kmp_wrapper_getpid.h

@@ -23,7 +23,7 @@
 #if KMP_OS_DARWIN
 // OS X
 #define __kmp_gettid() pthread_mach_thread_np(pthread_self())
-#elif KMP_OS_FREEBSD
+#elif KMP_OS_FREEBSD || KMP_OS_DRAGONFLY
 #include <pthread_np.h>
 #define __kmp_gettid() pthread_getthreadid_np()
 #elif KMP_OS_NETBSD