[lldb][TypeSystemClang] Honor DW_AT_rvalue_reference when creating C++ FunctionPrototypes

[Michael137]

Summary

Currently funciton lookup in the expression evaluator
fails to disambiguate member functions the are overloaded
on lvalue/rvalue reference-qualifiers. This happens because
we unconditionally set a FunctionPrototypes
ExtProtoInfo::RefQualifier to RQ_None. We lose
the ref-qualifiers in the synthesized AST and clang::Sema
fails to pick a correct overload candidate.

DWARF emits information about a function's ref-qualifiers
in the form of a boolean DW_AT_rvalue_reference (for rvalues)
and DW_AT_reference (for lvalues).

This patch sets the FunctionPrototype::ExtProtoInfo::RefQualifier
based on the DWARF attributes above.

Testing

• Added API test

llvm/llvm-project issue #57866

[labath]

Looks straight forward enough. Tagging @zequanwu, as he might want to do something similar for PDB.

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

38–39

I guess the clang/AST/Type.h include should be grouped with the other clang includes. I'd recommend deleting this empty line and letting clang-format sort the includes for you.

[Michael137]

• Fix includes

[Michael137]

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

38–39

Thanks, done

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

 //===-- DWARFASTParserClang.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_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSERCLANG_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSERCLANG_H
 
 #include "clang/AST/CharUnits.h"
+#include "clang/AST/Type.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 
 #include "DWARFASTParser.h"
 #include "DWARFDIE.h"
 #include "DWARFDefines.h"
 #include "DWARFFormValue.h"
struct ParsedDWARFTypeAttributes {
   DWARFFormValue specification;
   DWARFFormValue type;
   lldb::LanguageType class_language = lldb::eLanguageTypeUnknown;
   llvm::Optional<uint64_t> byte_size;
   size_t calling_convention = llvm::dwarf::DW_CC_normal;
   uint32_t bit_stride = 0;
   uint32_t byte_stride = 0;
   uint32_t encoding = 0;
+  clang::RefQualifierKind ref_qual =
+      clang::RQ_None; ///< Indicates ref-qualifier of
+                      ///< C++ member function if present.
+                      ///< Is RQ_None otherwise.
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSERCLANG_H

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
-#include "llvm/Demangle/Demangle.h"
-
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
+#include "clang/AST/Type.h"
+#include "llvm/Demangle/Demangle.h"
 
 #include <map>
 #include <memory>
 #include <vector>
 
 //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
 
 #ifdef ENABLE_DEBUG_PRINTF
case DW_AT_APPLE_runtime_class:
       break;
 
     case DW_AT_GNU_vector:
       is_vector = form_value.Boolean();
       break;
     case DW_AT_export_symbols:
       exports_symbols = form_value.Boolean();
       break;
+    case DW_AT_rvalue_reference:
+      ref_qual = clang::RQ_RValue;
+      break;
+    case DW_AT_reference:
+      ref_qual = clang::RQ_LValue;
+      break;
     }
   }
 }
 
 static std::string GetUnitName(const DWARFDIE &die) {
   if (DWARFUnit *unit = die.GetCU())
     return unit->GetAbsolutePath().GetPath();
   return "<missing DWARF unit path>";
if (is_cxx_method && has_template_params) {
     is_cxx_method = false;
   }
 
   clang::CallingConv calling_convention =
       ConvertDWARFCallingConventionToClang(attrs);
 
   // clang_type will get the function prototype clang type after this
   // call
-  CompilerType clang_type = m_ast.CreateFunctionType(
-      return_clang_type, function_param_types.data(),
-      function_param_types.size(), is_variadic, type_quals, calling_convention);
+  CompilerType clang_type =
+      m_ast.CreateFunctionType(return_clang_type, function_param_types.data(),
+                               function_param_types.size(), is_variadic,
+                               type_quals, calling_convention, attrs.ref_qual);
 
   if (attrs.name) {
     bool type_handled = false;
     if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
       ObjCLanguage::MethodName objc_method(attrs.name.GetStringRef(), true);
       if (objc_method.IsValid(true)) {
         CompilerType class_opaque_type;
         ConstString class_name(objc_method.GetClassName());

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTFwd.h"
 #include "clang/AST/TemplateBase.h"
+#include "clang/AST/Type.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallVector.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/TypeSystem.h"
public:
 
   // Function Types
 
   clang::FunctionDecl *CreateFunctionDeclaration(
       clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
       llvm::StringRef name, const CompilerType &function_Type,
       clang::StorageClass storage, bool is_inline);
 
-  CompilerType CreateFunctionType(const CompilerType &result_type,
-                                  const CompilerType *args, unsigned num_args,
-                                  bool is_variadic, unsigned type_quals,
-                                  clang::CallingConv cc = clang::CC_C);
+  CompilerType
+  CreateFunctionType(const CompilerType &result_type, const CompilerType *args,
+                     unsigned num_args, bool is_variadic, unsigned type_quals,
+                     clang::CallingConv cc = clang::CC_C,
+                     clang::RefQualifierKind ref_qual = clang::RQ_None);
 
   clang::ParmVarDecl *
   CreateParameterDeclaration(clang::DeclContext *decl_ctx,
                              OptionalClangModuleID owning_module,
                              const char *name, const CompilerType &param_type,
                              int storage, bool add_decl = false);
 
   void SetFunctionParameters(clang::FunctionDecl *function_decl,

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

FunctionDecl *TypeSystemClang::CreateFunctionDeclaration(
   SetOwningModule(func_decl, owning_module);
   decl_ctx->addDecl(func_decl);
 
   VerifyDecl(func_decl);
 
   return func_decl;
 }
 
-CompilerType
-TypeSystemClang::CreateFunctionType(const CompilerType &result_type,
-                                    const CompilerType *args, unsigned num_args,
-                                    bool is_variadic, unsigned type_quals,
-                                    clang::CallingConv cc) {
+CompilerType TypeSystemClang::CreateFunctionType(
+    const CompilerType &result_type, const CompilerType *args,
+    unsigned num_args, bool is_variadic, unsigned type_quals,
+    clang::CallingConv cc, clang::RefQualifierKind ref_qual) {
   if (!result_type || !ClangUtil::IsClangType(result_type))
     return CompilerType(); // invalid return type
 
   std::vector<QualType> qual_type_args;
   if (num_args > 0 && args == nullptr)
     return CompilerType(); // invalid argument array passed in
 
   // Verify that all arguments are valid and the right type
CompilerType TypeSystemClang::CreateFunctionType(
   }
 
   // TODO: Detect calling convention in DWARF?
   FunctionProtoType::ExtProtoInfo proto_info;
   proto_info.ExtInfo = cc;
   proto_info.Variadic = is_variadic;
   proto_info.ExceptionSpec = EST_None;
   proto_info.TypeQuals = clang::Qualifiers::fromFastMask(type_quals);
-  proto_info.RefQualifier = RQ_None;
+  proto_info.RefQualifier = ref_qual;
 
   return GetType(getASTContext().getFunctionType(
       ClangUtil::GetQualType(result_type), qual_type_args, proto_info));
 }
 
 ParmVarDecl *TypeSystemClang::CreateParameterDeclaration(
     clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
     const char *name, const CompilerType &param_type, int storage,

lldb/test/API/lang/cpp/function-ref-qualifiers/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/lang/cpp/function-ref-qualifiers/TestCppFunctionQualifiers.py

+"""
+Tests that C++ expression evaluation can
+disambiguate between rvalue and lvalue
+reference-qualified functions.
+"""
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestCase(TestBase):
+
+    def test(self):
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, "Break here", lldb.SBFileSpec("main.cpp"))
+
+        # const lvalue
+        self.expect_expr("const_foo.func()", result_type="uint32_t", result_value="0")
+
+        # const rvalue
+        self.expect_expr("static_cast<Foo const&&>(Foo{}).func()",
+                         result_type="int64_t", result_value="1")
+
+        # non-const lvalue
+        self.expect_expr("foo.func()", result_type="uint32_t", result_value="2")
+
+        # non-const rvalue
+        self.expect_expr("Foo{}.func()", result_type="int64_t", result_value="3")
+
+        self.filecheck("target modules dump ast", __file__)
+        # CHECK:      |-CXXMethodDecl {{.*}} func 'uint32_t () const &'
+        # CHECK-NEXT: | `-AsmLabelAttr {{.*}}
+        # CHECK-NEXT: |-CXXMethodDecl {{.*}} func 'int64_t () const &&'
+        # CHECK-NEXT: | `-AsmLabelAttr {{.*}}
+        # CHECK-NEXT: |-CXXMethodDecl {{.*}} func 'uint32_t () &'
+        # CHECK-NEXT: | `-AsmLabelAttr {{.*}}
+        # CHECK-NEXT: `-CXXMethodDecl {{.*}} func 'int64_t () &&'
+        # CHECK-NEXT:   `-AsmLabelAttr {{.*}}

lldb/test/API/lang/cpp/function-ref-qualifiers/main.cpp

+#include <cstdint>
+#include <cstdio>
+
+struct Foo {
+  uint32_t func() const & { return 0; }
+  int64_t func() const && { return 1; }
+  uint32_t func() & { return 2; }
+  int64_t func() && { return 3; }
+};
+
+int main() {
+  Foo foo;
+  const Foo const_foo;
+  auto res = foo.func() + const_foo.func() + Foo{}.func() +
+             static_cast<Foo const &&>(Foo{}).func();
+
+  std::puts("Break here");
+  return res;
+}