Support unscoped enumeration members in the expression evaluator.

[werat]

Summary

Add unscoped enumeration members to the "globals" manual dwarf index. This
effectively makes them discoverable as global variables (which they
essentially are).

Before expression evaluator failed to lookup enumerators unless the
enumeration type has been already completed.

Consider the example:

enum MyEnum { eFoo = 1 };
MyEnum my_enum = eFoo;

(lldb) p eFoo
error: <user expression 2>:1:1: use of undeclared identifier 'eFoo'
eFoo
^
(lldb) p my_enum + eFoo
(int) $0 = 2

With this patch all unscoped enumerators can be looked up same as the global
variables and the expression evaluation works as expected.
SBTarget::FindGlobalVariables() now returns unscoped enumerators as well.

[werat]

Fix formatting

[shafik]

We can have unscoped enums in namespace and class scope and the enumerators won't leak out from those scopes. Thus we can have shadowing going on e.g.:

#include <iostream>

enum GEnum {eOne=2,};

namespace A {
   enum AEnum {eOne=0,};

  void g() {std::cout << eOne;}
};

struct B {
  enum CEnum {eOne=1,};

  void f() {std::cout << eOne;}
};

int main() {
   std::cout << eOne ;
   A::g() ;

   B b;
   b.f() ;
}

godbolt: https://godbolt.org/z/h3r76n

How does this change deal with those cases?

[labath]

This suffers from the same problem as the other patch, where the other index classes (apple_names and debug_names) will essentially never be able to implement this feature. (Unless they re-index the dwarf themselves, that is, but this would defeat the purpose of having the index in the first place.)

[werat]

Handle enum constants similar to global variables, support scoped lookup in the expression evaluator.
Add more test cases.

[werat]

In D94077#2479984, @shafik wrote:

We can have unscoped enums in namespace and class scope and the enumerators won't leak out from those scopes. Thus we can have shadowing going on e.g.:

...

How does this change deal with those cases?

Thanks for pointing this out! My first patch didn't really take this into account, so it didn't work properly. I've made some changes to make it work, although I'm not very familiar with these parts of LLDB yet, so I'm not sure whether this approach is how it should be implemented.

Also I've noticed that LLDB's expression evaluator is not perfect with these lookups, e.g. it can find global variables from other scopes if there's no better candidate (not sure if this is a bug of a feature):

Process 3768045 stopped
* thread #1, name = 'a.out', stop reason = breakpoint 1.1
    frame #0: 0x0000000000401116 a.out`main at global.cpp:2:13
   1    namespace Foo { int x = 1; }
-> 2    int main() {};
(lldb) p x
(int) $0 = 1

[werat]

In D94077#2481942, @labath wrote:

This suffers from the same problem as the other patch, where the other index classes (apple_names and debug_names) will essentially never be able to implement this feature. (Unless they re-index the dwarf themselves, that is, but this would defeat the purpose of having the index in the first place.)

I'm not sure I completely understand. Why does changing the manual_dwarf_index mean that the other index classes can't ever implement this feature? If, let's say, debug_names decides to support enum constants, then its data layout should be changed to either include enumerators as globals, or add a new section, or something else. Then it can be properly handled in LLDB too (maybe changing the way manual_dwarf_index works too to keep things consistent). As I understand, manual_dwarf_index can be changed anytime, since we're building it ourselves.

Do I misunderstand how these indexes work and interact with each other?

[werat]

Generate fully qualified names for enum constants.

[jingham]

In D94077#2486225, @werat wrote:

In D94077#2479984, @shafik wrote:

We can have unscoped enums in namespace and class scope and the enumerators won't leak out from those scopes. Thus we can have shadowing going on e.g.:

...

How does this change deal with those cases?

Thanks for pointing this out! My first patch didn't really take this into account, so it didn't work properly. I've made some changes to make it work, although I'm not very familiar with these parts of LLDB yet, so I'm not sure whether this approach is how it should be implemented.

Also I've noticed that LLDB's expression evaluator is not perfect with these lookups, e.g. it can find global variables from other scopes if there's no better candidate (not sure if this is a bug of a feature):

Process 3768045 stopped
* thread #1, name = 'a.out', stop reason = breakpoint 1.1
    frame #0: 0x0000000000401116 a.out`main at global.cpp:2:13
   1    namespace Foo { int x = 1; }
-> 2    int main() {};
(lldb) p x
(int) $0 = 1

That's a feature, not a bug. lldb tries to find the "closest" definition to the frame in which the expression is evaluated, it isn't bound by what the current frame can see. If it can find a unique closest definition for an identifier working out from the current frame, it will that.

This seems the most useful behavior. If your program has a shared library that has a static singleton which stores some interesting information about the library's state, debugger users want to be able to access that variable in the expression evaluator even if they aren't currently stopped in a frame of that library. That's also important for type lookups. If I'm in a frame of library A, which only sees a forward declaration of some type, but library B has the full debug information for that type, it's super useful to be able to keep looking past library A for a full type definition.

[labath]

In D94077#2486232, @werat wrote:

In D94077#2481942, @labath wrote:

This suffers from the same problem as the other patch, where the other index classes (apple_names and debug_names) will essentially never be able to implement this feature. (Unless they re-index the dwarf themselves, that is, but this would defeat the purpose of having the index in the first place.)

I'm not sure I completely understand. Why does changing the manual_dwarf_index mean that the other index classes can't ever implement this feature? If, let's say, debug_names decides to support enum constants, then its data layout should be changed to either include enumerators as globals, or add a new section, or something else. Then it can be properly handled in LLDB too (maybe changing the way manual_dwarf_index works too to keep things consistent). As I understand, manual_dwarf_index can be changed anytime, since we're building it ourselves.

Do I misunderstand how these indexes work and interact with each other?

Maybe "(n)ever" was too strong a word. Still, there is a fundamental difference between the "manual" index and the other two indexes:

• the manual index is entirely an lldb concept. We can change it whenever we want. We don't need to ask anyone for permission to do that, coordinate with anyone, or care about what anyone else is doing.
• the contents of the other two indexes is given by a specification (it case of apple_names, it's a local llvm spec, but it still suffers from similar problems, albeit less pronounced). We cannot unilaterally change anything about them. We first need to change the relevant specification, which requires gathering consensus and convincing people that this use case is really worth the extra amount of space that the new entries will introduce. Then we need to wait until a new version of the standard is published and producers (compilers) to start using it. And even them our job is not finished, because we still need to figure out what do we want to do with debug info produced by older producers which still adhere to the old version of the spec.

This is why I am pushing back against the "simple" solution of having the manual index index more things -- it fragments the feature set for users who have the index vs. those who not.

This doesn't mean we cannot change the manual index at all -- it's possible some feature cannot be implemented differently. But it's also possible the feature can be implemented differently, in a way that makes works with all indexes. Or it's possible the feature is not worth the divergence, or the increase in the manual index memory footprint that it produces (i think it would be interesting to get some measurements on that, particularly as one can also expect a similar increase in the on-disk indexes, if they are to support this). So, I think this deserves a wider discussion and exploration of other alternatives.

[werat]

Thanks for the explanation, this makes sense. I've checked the mailing list archives and it seems there was already a discussion about the enumerators in the .debug_names index back in 2018 -- http://lists.dwarfstd.org/pipermail/dwarf-discuss-dwarfstd.org/2018-April/004443.html. You were the one to bring it up and the consensus was that the enumerators should go into the index too.

But it seems this was never actually implemented, the latest version of the toolchain doesn't add DW_TAG_enumerator entries to the .debug_names index. Is there a reason for that or it just slipped through the cracks? Should I bring it up again on the mailing list or we can assume the consensus is still the same and this should be just implemented?

Regarding the changes in the manual index. Do you think there's a better way to implement enumerators lookup? To be honest, I don't see another way. Assuming .debug_names and apple_names are updated to include the enumerators, manual_index should be updated as well to match the behaviour.

[labath]

In D94077#2489064, @werat wrote:

Thanks for the explanation, this makes sense. I've checked the mailing list archives and it seems there was already a discussion about the enumerators in the .debug_names index back in 2018 -- http://lists.dwarfstd.org/pipermail/dwarf-discuss-dwarfstd.org/2018-April/004443.html. You were the one to bring it up and the consensus was that the enumerators should go into the index too.

But it seems this was never actually implemented, the latest version of the toolchain doesn't add DW_TAG_enumerator entries to the .debug_names index. Is there a reason for that or it just slipped through the cracks? Should I bring it up again on the mailing list or we can assume the consensus is still the same and this should be just implemented?

As I recall, I myself started having doubts about the correctness of that approach, as I started discovering other interesting named objects that were not in the index:

• using bar = foo; // another name for foo
• using foo = bar::foo; // same name but in a different namespace
• using namespace foo; // another name for _everything_ in foo

I started being unsure where should the line be drawn, and (coupled with insufficient time to investigate this in depth) decided to stick to what the spec says. I am also unsure whether that discussion would be sufficiently authoritative to decide on the matter, since this is pretty clearly in contradiction with the wording of the spec. And there's still the question of how much extra space will this feature consume (there's no way to "home" these declarations, so they index entries would have to be emitted for each compile unit that uses them)...

Regarding the changes in the manual index. Do you think there's a better way to implement enumerators lookup?

Maybe? It depends on what kinds of contexts we'd want these enumerators to be recognised. If we're fine with seeing just the enumerators visible in the current scope, then we could parse the current compile unit, looking for enum declarations -- I believe "using namespace" declarations are handled in this way. If we'd want them to be visible globally, then things get trickier. Though there's always the possibility to say that the feature is not worth the cost it brings...

Assuming .debug_names and apple_names are updated to include the enumerators, manual_index should be updated as well to match the behaviour.

Yep, that much we can agree on. :)

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

void ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
   if (const clang::Type *parser_type = parser_opaque_type.getTypePtr()) {
     if (const TagType *tag_type = dyn_cast<TagType>(parser_type))
       CompleteType(tag_type->getDecl());
     if (const ObjCObjectPointerType *objc_object_ptr_type =
             dyn_cast<ObjCObjectPointerType>(parser_type))
       CompleteType(objc_object_ptr_type->getInterfaceDecl());
   }
 
+  // Check if this variable actually represents an unscoped enumeration
+  // constant. They're stored in the index with global variables and thus can be
+  // looked up as a global variable. But the declarations for the enumeration
+  // members (enumerators) are already generated and exist in the AST context.
+  // We just need to find the one corresponsing to this "variable".
+  if (const clang::EnumType *enum_type =
+          dyn_cast<clang::EnumType>(parser_opaque_type.getTypePtr())) {
+    if (!enum_type->isScopedEnumeralType()) {
+      for (clang::EnumConstantDecl *ecd : enum_type->getDecl()->enumerators()) {
+        if (ecd->getName() == var->GetUnqualifiedName().GetStringRef()) {
+          context.AddNamedDecl(ecd);
+          return;
+        }
+      }
+    }
+  }
+
   bool is_reference = pt.IsReferenceType();
 
   NamedDecl *var_decl = nullptr;
   if (is_reference)
     var_decl = context.AddVarDecl(pt);
   else
     var_decl = context.AddVarDecl(pt.GetLValueReferenceType());
 

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

if (num_child_attributes > 0) {
       array_info.element_orders.push_back(num_elements);
     }
   }
   return array_info;
 }
 
 Type *DWARFASTParserClang::GetTypeForDIE(const DWARFDIE &die) {
   if (die) {
-    SymbolFileDWARF *dwarf = die.GetDWARF();
+    if (die.Tag() == DW_TAG_enumerator) {
+      return die.GetDWARF()->ResolveTypeUID(die.GetParent(), true);
+    }
+
     DWARFAttributes attributes;
     const size_t num_attributes = die.GetAttributes(attributes);
     if (num_attributes > 0) {
       DWARFFormValue type_die_form;
       for (size_t i = 0; i < num_attributes; ++i) {
         dw_attr_t attr = attributes.AttributeAtIndex(i);
         DWARFFormValue form_value;
 
         if (attr == DW_AT_type &&
             attributes.ExtractFormValueAtIndex(i, form_value))
-          return dwarf->ResolveTypeUID(form_value.Reference(), true);
+          return die.GetDWARF()->ResolveTypeUID(form_value.Reference(), true);
       }
     }
   }
 
   return nullptr;
 }
 
 clang::Decl *DWARFASTParserClang::GetClangDeclForDIE(const DWARFDIE &die) {
   if (!die)
     return nullptr;
 
   switch (die.Tag()) {
   case DW_TAG_variable:
   case DW_TAG_constant:
+  case DW_TAG_enumerator:
   case DW_TAG_formal_parameter:
   case DW_TAG_imported_declaration:
   case DW_TAG_imported_module:
     break;
   default:
     return nullptr;
   }
 
if (dwarf && type) {
           TypeSystemClang::DeclContextGetAsDeclContext(
               dwarf->GetDeclContextContainingUID(die.GetID()));
       decl = m_ast.CreateVariableDeclaration(
           decl_context, GetOwningClangModule(die), name,
           ClangUtil::GetQualType(type->GetForwardCompilerType()));
     }
     break;
   }
+  case DW_TAG_enumerator: {
+    Type *type = GetTypeForDIE(die);
+    if (type) {
+      CompilerType compiler_type = type->GetForwardCompilerType();
+      clang::QualType qual_type = ClangUtil::GetQualType(compiler_type);
+      const clang::Type *clang_type = qual_type.getTypePtrOrNull();
+      if (clang_type) {
+        clang::EnumDecl *enum_decl =
+            llvm::dyn_cast_or_null<clang::EnumDecl>(clang_type->getAsTagDecl());
+        if (enum_decl) {
+          const char *name = die.GetName();
+          for (clang::EnumConstantDecl *ecd : enum_decl->enumerators()) {
+            if (ecd->getName() == name) {
+              decl = ecd;
+              break;
+            }
+          }
+        }
+      }
+    }
+    break;
+  }
   case DW_TAG_imported_declaration: {
     SymbolFileDWARF *dwarf = die.GetDWARF();
     DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
     if (imported_uid) {
       CompilerDecl imported_decl = SymbolFileDWARF::GetDecl(imported_uid);
       if (imported_decl) {
         clang::DeclContext *decl_context =
             TypeSystemClang::DeclContextGetAsDeclContext(

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

 //===-- ManualDWARFIndex.cpp ----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/SymbolFile/DWARF/ManualDWARFIndex.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDebugInfo.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDeclContext.h"
 #include "Plugins/SymbolFile/DWARF/LogChannelDWARF.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/Stream.h"
for (const DWARFDebugInfoEntry &die : unit.dies()) {
     }
 
     DWARFAttributes attributes;
     const char *name = nullptr;
     const char *mangled_cstr = nullptr;
     bool is_declaration = false;
     // bool is_artificial = false;
     bool has_address = false;
+    bool is_enum_class = false;
     bool has_location_or_const_value = false;
     bool is_global_or_static_variable = false;
 
     DWARFFormValue specification_die_form;
     const size_t num_attributes = die.GetAttributes(&unit, attributes);
     if (num_attributes > 0) {
       for (uint32_t i = 0; i < num_attributes; ++i) {
         dw_attr_t attr = attributes.AttributeAtIndex(i);
         DWARFFormValue form_value;
         switch (attr) {
         case DW_AT_name:
           if (attributes.ExtractFormValueAtIndex(i, form_value))
             name = form_value.AsCString();
           break;
 
         case DW_AT_declaration:
           if (attributes.ExtractFormValueAtIndex(i, form_value))
             is_declaration = form_value.Unsigned() != 0;
           break;
 
+        case DW_AT_enum_class:
+          if (attributes.ExtractFormValueAtIndex(i, form_value))
+            is_enum_class = form_value.Boolean();
+          break;
+
         case DW_AT_MIPS_linkage_name:
         case DW_AT_linkage_name:
           if (attributes.ExtractFormValueAtIndex(i, form_value))
             mangled_cstr = form_value.AsCString();
           break;
 
         case DW_AT_low_pc:
         case DW_AT_high_pc:
for (const DWARFDebugInfoEntry &die : unit.dies()) {
     case DW_TAG_subroutine_type:
     case DW_TAG_typedef:
     case DW_TAG_union_type:
     case DW_TAG_unspecified_type:
       if (name && !is_declaration)
         set.types.Insert(ConstString(name), ref);
       if (mangled_cstr && !is_declaration)
         set.types.Insert(ConstString(mangled_cstr), ref);
+      // Unscoped enumerators are basically constants in the surrounding scope.
+      if (tag == DW_TAG_enumeration_type && !is_enum_class) {
+        for (const DWARFDebugInfoEntry *value = die.GetFirstChild();
+             value != nullptr; value = value->GetSibling()) {
+          if (value->Tag() == DW_TAG_enumerator) {
+            DIERef value_ref = DWARFDIE(&unit, value).GetDIERef().getValue();
+            set.globals.Insert(ConstString(value->GetName(&unit)), value_ref);
+          }
+        }
+      }
       break;
 
     case DW_TAG_namespace:
       if (name)
         set.namespaces.Insert(ConstString(name), ref);
       break;
 
     case DW_TAG_variable:

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

void SymbolFileDWARF::FindGlobalVariables(
   uint32_t pruned_idx = original_size;
 
   SymbolContext sc;
   m_index->GetGlobalVariables(ConstString(basename), [&](DWARFDIE die) {
     if (!sc.module_sp)
       sc.module_sp = m_objfile_sp->GetModule();
     assert(sc.module_sp);
 
-    if (die.Tag() != DW_TAG_variable)
+    if (die.Tag() != DW_TAG_variable && die.Tag() != DW_TAG_enumerator)
       return true;
 
     auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU());
     if (!dwarf_cu)
       return true;
     sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
 
     if (parent_decl_ctx) {
VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc,
 
   if (VariableSP var_sp = GetDIEToVariable()[die.GetDIE()])
     return var_sp; // Already been parsed!
 
   const dw_tag_t tag = die.Tag();
   ModuleSP module = GetObjectFile()->GetModule();
 
   if (tag != DW_TAG_variable && tag != DW_TAG_constant &&
+      tag != DW_TAG_enumerator &&
       (tag != DW_TAG_formal_parameter || !sc.function))
     return nullptr;
 
   DWARFAttributes attributes;
   const size_t num_attributes = die.GetAttributes(attributes);
   DWARFDIE spec_die;
   VariableSP var_sp;
   const char *name = nullptr;
   const char *mangled = nullptr;
   Declaration decl;
-  DWARFFormValue type_die_form;
+  DWARFDIE type_die;
   DWARFExpression location;
   bool is_external = false;
   bool is_artificial = false;
   DWARFFormValue const_value_form, location_form;
   Variable::RangeList scope_ranges;
 
   for (size_t i = 0; i < num_attributes; ++i) {
     dw_attr_t attr = attributes.AttributeAtIndex(i);
for (size_t i = 0; i < num_attributes; ++i) {
     case DW_AT_name:
       name = form_value.AsCString();
       break;
     case DW_AT_linkage_name:
     case DW_AT_MIPS_linkage_name:
       mangled = form_value.AsCString();
       break;
     case DW_AT_type:
-      type_die_form = form_value;
+      type_die = form_value.Reference();
       break;
     case DW_AT_external:
       is_external = form_value.Boolean();
       break;
     case DW_AT_const_value:
       const_value_form = form_value;
       break;
     case DW_AT_location:
for (size_t i = 0; i < num_attributes; ++i) {
     case DW_AT_visibility:
     default:
     case DW_AT_abstract_origin:
     case DW_AT_sibling:
       break;
     }
   }
 
+  // For enumerators the type is their parent (DW_TAG_enumeration_type).
+  if (tag == DW_TAG_enumerator) {
+    type_die = die.GetParent();
+  }
+
   // Prefer DW_AT_location over DW_AT_const_value. Both can be emitted e.g.
   // for static constexpr member variables -- DW_AT_const_value will be
   // present in the class declaration and DW_AT_location in the DIE defining
   // the member.
   bool location_is_const_value_data = false;
   bool has_explicit_location = false;
   bool use_type_size_for_value = false;
   if (location_form.IsValid()) {
if (!mangled) {
     // example, if j were an int variable holding a value 4 and
     // declared in a namespace B which in turn is contained in a
     // namespace A, the command "frame var j" returns
     //   "(int) A::B::j = 4".
     // If the compiler does not emit a linkage name, we should be
     // able to generate a fully qualified name from the
     // declaration context.
     if ((parent_tag == DW_TAG_compile_unit ||
-         parent_tag == DW_TAG_partial_unit) &&
+         parent_tag == DW_TAG_partial_unit ||
+         parent_tag == DW_TAG_enumeration_type) &&
         Language::LanguageIsCPlusPlus(GetLanguage(*die.GetCU())))
       mangled =
           GetDWARFDeclContext(die).GetQualifiedNameAsConstString().GetCString();
   }
 
   if (tag == DW_TAG_formal_parameter)
     scope = eValueTypeVariableArgument;
+  else if (tag == DW_TAG_enumerator)
+    scope = eValueTypeVariableGlobal;
   else {
     // DWARF doesn't specify if a DW_TAG_variable is a local, global
     // or static variable, so we have to do a little digging:
     // 1) DW_AT_linkage_name implies static lifetime (but may be missing)
     // 2) An empty DW_AT_location is an (optimized-out) static lifetime var.
     // 3) DW_AT_location containing a DW_OP_addr implies static lifetime.
     // Clang likes to combine small global variables into the same symbol
     // with locations like: DW_OP_addr(0x1000), DW_OP_constu(2), DW_OP_plus
if (symbol_context_scope == nullptr) {
 
     default:
       symbol_context_scope = sc.comp_unit;
       break;
     }
   }
 
   if (symbol_context_scope) {
-    auto type_sp = std::make_shared<SymbolFileType>(
-        *this, GetUID(type_die_form.Reference()));
+    auto type_sp = std::make_shared<SymbolFileType>(*this, GetUID(type_die));
 
     if (use_type_size_for_value && type_sp->GetType())
       location.UpdateValue(
           const_value_form.Unsigned(),
           type_sp->GetType()->GetByteSize(nullptr).getValueOr(0),
           die.GetCU()->GetAddressByteSize());
 
     var_sp = std::make_shared<Variable>(
while (die) {
     // Check to see if we have already parsed this variable or constant?
     VariableSP var_sp = GetDIEToVariable()[die.GetDIE()];
     if (var_sp) {
       if (cc_variable_list)
         cc_variable_list->AddVariableIfUnique(var_sp);
     } else {
       // We haven't already parsed it, lets do that now.
       if ((tag == DW_TAG_variable) || (tag == DW_TAG_constant) ||
+          (tag == DW_TAG_enumerator) ||
           (tag == DW_TAG_formal_parameter && sc.function)) {
         if (variable_list_sp.get() == nullptr) {
           DWARFDIE sc_parent_die = GetParentSymbolContextDIE(orig_die);
           dw_tag_t parent_tag = sc_parent_die.Tag();
           switch (parent_tag) {
           case DW_TAG_compile_unit:
           case DW_TAG_partial_unit:
             if (sc.comp_unit != nullptr) {

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

for (clang::DeclContext *decl_context = root_decl_ctx;
               if (clang::NamedDecl *nd =
                       llvm::dyn_cast<clang::NamedDecl>(target)) {
                 IdentifierInfo *ii = nd->getIdentifier();
                 if (ii != nullptr &&
                     ii->getName().equals(name.AsCString(nullptr)))
                   found_decls.push_back(GetCompilerDecl(nd));
               }
             }
+          } else if (clang::EnumDecl *ed =
+                         llvm::dyn_cast<clang::EnumDecl>(child)) {
+            for (clang::EnumConstantDecl *ecd : ed->enumerators()) {
+              IdentifierInfo *ii = ecd->getIdentifier();
+              if (ii != nullptr &&
+                  ii->getName().equals(name.AsCString(nullptr)))
+                found_decls.push_back(GetCompilerDecl(ecd));
+            }
           } else if (clang::NamedDecl *nd =
                          llvm::dyn_cast<clang::NamedDecl>(child)) {
             IdentifierInfo *ii = nd->getIdentifier();
             if (ii != nullptr && ii->getName().equals(name.AsCString(nullptr)))
               found_decls.push_back(GetCompilerDecl(nd));
           }
         }
       }

lldb/test/API/lang/cpp/enum_types/TestCPP11EnumTypes.py

 """Look up enum type information and check for correct display."""
 
-import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
 
 
 class CPP11EnumTypesTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def check_enum(self, suffix):
         """
def test(self):
         self.check_enum("us")
         self.check_enum("s")
         self.check_enum("ui")
         self.check_enum("i")
         self.check_enum("ul")
         self.check_enum("l")
         self.check_enum("ull")
         self.check_enum("ll")
+
+        self.expect_expr("eFoo", result_type="MyEnum", result_value="eFoo")
+        self.expect_expr("MyEnum::eFoo", result_type="MyEnum", result_value="eFoo")
+        self.expect_expr("my_enum + eFoo + MyEnum::eFoo", result_value="3")
+
+        self.expect("p eBar", error=True,
+                    substrs=["use of undeclared identifier 'eBar'"])
+
+    @skipIf(dwarf_version=['<', '4'])
+    def test_enums_from_different_scopes(self):
+        self.build()
+        _ = self.dbg.CreateTarget(self.getBuildArtifact())
+
+        lldbutil.run_break_set_by_source_regexp(
+            self, "// break here", num_expected_locations=3)
+
+        # Break in A::g()
+        self.runCmd("run")
+        self.expect_expr("eValue", result_type="A::AEnum", result_value="eValue")
+
+        # Break in B::f()
+        self.runCmd("continue")
+        self.expect_expr("eValue", result_type="B::BEnum", result_value="eValue")
+
+        # Break in main()
+        self.runCmd("continue")
+        self.expect_expr("eValue", result_type="CEnum", result_value="eValue")
+
+        self.runCmd("kill")

lldb/test/API/lang/cpp/enum_types/main.cpp

 DEFINE_SIGNED_ENUM(s, signed short int)
 DEFINE_UNSIGNED_ENUM(ui, unsigned int)
 DEFINE_SIGNED_ENUM(i, signed int)
 DEFINE_UNSIGNED_ENUM(ul, unsigned long)
 DEFINE_SIGNED_ENUM(l, signed long)
 DEFINE_UNSIGNED_ENUM(ull, unsigned long long)
 DEFINE_SIGNED_ENUM(ll, signed long long)
 
-int main(int argc, char const *argv[]) { return 0; }
+enum MyEnum {
+  eFoo = 1,
+};
+MyEnum my_enum = eFoo;
+
+enum class MyScopedEnum {
+  eBar = 1,
+};
+MyScopedEnum my_scoped_enum = MyScopedEnum::eBar;
+
+int x = 2;
+
+enum CEnum { eValue = 2 } ce;
+
+namespace A {
+
+enum AEnum { eValue = 0 } ae;
+
+void g() {
+  // break here
+}
+
+}; // namespace A
+
+struct B {
+  enum BEnum { eValue = 1 } be;
+
+  void f() {
+    // break here
+  }
+};
+
+int main() {
+  A::g();
+
+  B b;
+  b.f();
+
+  // break here
+  return 0;
+}

lldb/test/API/python_api/target/globals/Makefile

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

lldb/test/API/python_api/target/globals/TestTargetGlobals.py

+"""
+Test SBTarget::FindGlobalVariables API.
+"""
+
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+
+class TargetAPITestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @add_test_categories(['pyapi'])
+    def test_find_global_variables(self):
+        """Exercise SBTarget.FindGlobalVariables() API."""
+        self.build()
+
+        # Don't need to launch a process, since we're only interested in
+        # looking up global variables.
+        target = self.dbg.CreateTarget(self.getBuildArtifact())
+
+        def test_global_var(query, name, type_name, value):
+            value_list = target.FindGlobalVariables(query, 1)
+            self.assertEqual(value_list.GetSize(), 1)
+            var = value_list.GetValueAtIndex(0)
+            self.DebugSBValue(var)
+            self.assertTrue(var)
+            self.assertEqual(var.GetName(), name)
+            self.assertEqual(var.GetTypeName(), type_name)
+            self.assertEqual(var.GetValue(), value)
+
+        test_global_var("eFirst", "::eFirst", "MyEnum", "eFirst")
+        test_global_var("A::eMany", "A::eMany", "A::AEnum", "eMany")
+
+        # Global variable eFoo is looked up fine, since scoped enumeration
+        # members are not available as constants in the surrounding scope.
+        test_global_var("eFoo", "::eFoo", "int", "2")
+
+        # eBar is not available since it's a member of a scoped enumeration.
+        value_list = target.FindGlobalVariables("eBar", 1)
+        self.assertEqual(value_list.GetSize(), 0)
+
+        # Get enumerator values from all scopes.
+        value_list = target.FindGlobalVariables("eMany", 100500)
+        self.assertEqual(value_list.GetSize(), 3)
+        value_types = {value.GetTypeName() for value in value_list}
+        self.assertEqual(value_types, {"A::AEnum", "B::BEnum", "CEnum"})

lldb/test/API/python_api/target/globals/main.cpp

+namespace A {
+enum AEnum { eMany = 0 } ae;
+};
+
+struct B {
+  enum BEnum { eMany = 1 } be;
+} b;
+
+enum CEnum { eMany = 2 } ce;
+
+enum MyEnum {
+  eFirst,
+} my_enum;
+
+enum class MyScopedEnum {
+  eFoo = 1,
+  eBar,
+} my_scoped_enum;
+
+int eFoo = 2;
+
+int main() {}