Don't type-erase the SymbolContextItem enum

[zturner]

Summary

When we get the resolve_scope parameter from the SB API, it's a uint32_t. We then pass it through all of LLDB this way, as a uint32. This is unfortunate, because it means the user of an API never actually knows what they're dealing with. We can call it something like resolve_scope and have comments saying "this is a value from the SymbolContextItem enumeration, but it makes more sense to just have it actually *be* the correct type in the actual C++ type system to begin with. This way the person reading the code just knows what it is.

There is one thing here which I'm a little uncertain about, which is that I included a file from llvm llvm/ADT/BitmaskEnum.h from lldb/lldb-enumerations.h, which is a public header.` This is only done for convenience, and has two effects.

1. It allows us to use bitwise operations on enums so we don't have to write things like Foo x = Foo(eFoo1 | eFoo2)
2. More subtly, it inserts an enumerator into the enum. But (!) it doesn't change the value of any existing enumerators and it does so with a name that won't cause any clashes, so the important thing is that it shouldn't cause any name clashes.

Putting this all together, I think this should be an ABI-compatible change as far as SWIG is concerned, and I can't see any differences on my end. But if anyone can see any reason why we should be wary of this, speak up.

Assuming all goes well with this patch, I plan to repeat the same thing with SymbolFile::GetTypes which currently has a uint32_t types_mask

[jingham]

It would be great not to have to use comments to express what these values mean. OTOH, having to put in static casts whenever you want to or values together would be a pain, so if there's no way to do it without magic, I'm a little less enthused...

But on the magic: It looks like BitMaskEnum.h pulls in MathTypes.h which pulls in Compiler.h which then pulls in llvm-config.h. You are supposed to be able to build tools on top of lldb with just the headers that go in LLDB.framework, you are not required to have the full source tree for an lldb build. I don't want to impose that restriction without very good reason, and fixing this wart doesn't rise to that level. Anyway, so if we want to include BitMaskEnum.h we would be required to ship a bunch of llvm headers (including some build produced ones IIUC). I don't think that's a very good idea.

It also looks to me like the value of the largest item + 1 gets baked into the operator overloading code. What would happen if we decided to add an element to the enum?

[zturner]

In D53597#1273087, @jingham wrote:

It would be great not to have to use comments to express what these values mean. OTOH, having to put in static casts whenever you want to or values together would be a pain, so if there's no way to do it without magic, I'm a little less enthused...

But on the magic: It looks like BitMaskEnum.h pulls in MathTypes.h which pulls in Compiler.h which then pulls in llvm-config.h. You are supposed to be able to build tools on top of lldb with just the headers that go in LLDB.framework, you are not required to have the full source tree for an lldb build. I don't want to impose that restriction without very good reason, and fixing this wart doesn't rise to that level. Anyway, so if we want to include BitMaskEnum.h we would be required to ship a bunch of llvm headers (including some build produced ones IIUC). I don't think that's a very good idea.

It also looks to me like the value of the largest item + 1 gets baked into the operator overloading code. What would happen if we decided to add an element to the enum?

It's not the largest item +1, it's actually just that the largest item gets a second internal name. If you add a new element to the enum you need to just make sure you update the LLVM_MARK_AS_BITMASK_ENUM() to contain the new largest value.

Anyway, your point about llvm-config.h is a good one, so what I can perhaps do instead is make something called LLDB_DEFINE_BITMASK_ENUM(EnumName) which basically just defines the overloads for a particular enum, then we can have it be a two step process. 1. Make the enum, 2. Call LLDB_DEFINE_BITMASK_ENUM(Enum). This way there's no external header dependencies. I'll upload a new patch shortly.

[jingham]

That would be great!

[zturner]

Remove the reference to llvm/ADT/BitmaskEnu.h and define the operators ourselves. Also, removed a few casts that got left in.

[jingham]

That looks good to me, though you should wait for Greg to weigh in. He might notice something I missed.

[zturner]

Hi Greg, any thoughts on this?

[clayborg]

As long as Swig is happy and the ABI doesn't change I am ok with this. Will we see the variables better when debugging? Or is this solely so the SymbolContextItem type doesn't disappear from the debug info?

[zturner]

In D53597#1276086, @clayborg wrote:

As long as Swig is happy and the ABI doesn't change I am ok with this. Will we see the variables better when debugging? Or is this solely so the SymbolContextItem type doesn't disappear from the debug info?

We will see variables better when debugging too.

[zturner]

In D53597#1276110, @zturner wrote:

In D53597#1276086, @clayborg wrote:

As long as Swig is happy and the ABI doesn't change I am ok with this. Will we see the variables better when debugging? Or is this solely so the SymbolContextItem type doesn't disappear from the debug info?

We will see variables better when debugging too.

(That was actually my primary motivation)

[jingham]

So far as I can tell, this patch will make lookup of exact types faster for PDB, but because of the way DWARF debug_names tables are constructed, I don't think there's any way we can do the same thing for DWARF.

But unless I'm misunderstanding the patch, this doesn't change correctness of the lookup (except for fixing "type lookup 'struct Foo'"). Did I miss something?

Jim

[zturner]

In D53597#1276145, @jingham wrote:

So far as I can tell, this patch will make lookup of exact types faster for PDB, but because of the way DWARF debug_names tables are constructed, I don't think there's any way we can do the same thing for DWARF.

But unless I'm misunderstanding the patch, this doesn't change correctness of the lookup (except for fixing "type lookup 'struct Foo'"). Did I miss something?

Jim

That's the other patch. This patch is NFC and just makes debugging nicer because you can see enum values in your debugger as rich enumerators. But for the other patch, if what you said is correct, then I suppose that's correct. I asked Eric Christopher and he said he thought (but wasn't 100% sure) that types were hashed in the accelerator tables by their full name and not their base name. If that is true then it could make exact matches faster. But if it's incorrect then yes, it wouldn't be able to make exact matches faster in DWARF.

[jingham]

Ah, right... Too many patches (a good problem!)

The standard as I read it says that the name entry points into the general string table, but doesn't specify which entry it points to. However, the current DWARF debug_info doesn't ever emit a string for the fully qualified name, so you would have to construct it specially to have an exact name to refer to. I also couldn't see anything that said specifically whether the DW_AT_name for a type has to be the full name or a base name, it just says:

If a name has been given to the structure, union, or class in the source program, then the corresponding structure type, union type, or class type entry has a DW_AT_name attribute whose value is a null-terminated string containing the type name.

But it would bloat the name tables to use the full name, and since you can reconstruct it from the context it's not needed... So I've only seen base names in the name entry for types in the debug_info.

Anyway, current clang for -gdwarf-5 produces:

Bucket 1 [
  Name 2 {
    Hash: 0xB887389
    String: 0x000000c3 "Foo"
    Entry @ 0x92 {
      Abbrev: 0x39
      Tag: DW_TAG_namespace
      DW_IDX_die_offset: 0x0000004c
    }
  }
]
Bucket 2 [
  Name 3 {
    Hash: 0xB8860BA
    String: 0x000000c7 "Bar"
    Entry @ 0x9b {
      Abbrev: 0x13
      Tag: DW_TAG_structure_type
      DW_IDX_die_offset: 0x0000004e
    }
  }
  Name 4 {
    Hash: 0x7C9A7F6A
    String: 0x000000b5 "main"
    Entry @ 0xa4 {
      Abbrev: 0x2E
      Tag: DW_TAG_subprogram
      DW_IDX_die_offset: 0x00000026
    }
  }

For:

namespace Foo
{

struct Bar
{
  int First;
};

}

int
main()
{

Foo::Bar mine = {10};
return mine.First;

}

Jim

[zturner]

I guess the question is, How is that hash and the bucket computed? If it's
based on the full name, then you should be able to get fast exact lookup.
If it's based on the based name, then it will indeed be slow.

include/lldb/Core/Address.h

#endif
   ///
   /// This class doesn't inherit from SymbolContextScope because many address
   /// objects have short lifespans. Address objects that are section offset
   /// can reconstruct their symbol context by looking up the address in the
   /// module found in the section.
   ///
   /// @see SymbolContextScope::CalculateSymbolContext(SymbolContext*)
   //------------------------------------------------------------------
-  uint32_t CalculateSymbolContext(
-      SymbolContext *sc,
-      uint32_t resolve_scope = lldb::eSymbolContextEverything) const;
+  uint32_t CalculateSymbolContext(SymbolContext *sc,
+                                  lldb::SymbolContextItem resolve_scope =
+                                      lldb::eSymbolContextEverything) const;
 
   lldb::ModuleSP CalculateSymbolContextModule() const;
 
   CompileUnit *CalculateSymbolContextCompileUnit() const;
 
   Function *CalculateSymbolContextFunction() const;
 
   Block *CalculateSymbolContextBlock() const;

include/lldb/Core/Module.h

public:
   ///     of a function whose last instruction is a call.  In this case,
   ///     the PC can be one past the address range of the function.
   ///
   /// @return
   ///     The scope that has been resolved (see SymbolContext::Scope).
   ///
   /// @see SymbolContext::Scope
   //------------------------------------------------------------------
-  uint32_t
-  ResolveSymbolContextForAddress(const Address &so_addr, uint32_t resolve_scope,
-                                 SymbolContext &sc,
-                                 bool resolve_tail_call_address = false);
+  uint32_t ResolveSymbolContextForAddress(
+      const Address &so_addr, lldb::SymbolContextItem resolve_scope,
+      SymbolContext &sc, bool resolve_tail_call_address = false);
 
   //------------------------------------------------------------------
   /// Resolve items in the symbol context for a given file and line.
   ///
   /// Tries to resolve \a file_path and \a line to a list of matching symbol
   /// contexts.
   ///
   /// The line table entries contains addresses that can be used to further
public:
   ///     A symbol context list that gets matching symbols contexts
   ///     appended to.
   ///
   /// @return
   ///     The number of matches that were added to \a sc_list.
   ///
   /// @see SymbolContext::Scope
   //------------------------------------------------------------------
-  uint32_t ResolveSymbolContextForFilePath(const char *file_path, uint32_t line,
-                                           bool check_inlines,
-                                           uint32_t resolve_scope,
-                                           SymbolContextList &sc_list);
+  uint32_t ResolveSymbolContextForFilePath(
+      const char *file_path, uint32_t line, bool check_inlines,
+      lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list);
 
   //------------------------------------------------------------------
   /// Resolve items in the symbol context for a given file and line.
   ///
   /// Tries to resolve \a file_spec and \a line to a list of matching symbol
   /// contexts.
   ///
   /// The line table entries contains addresses that can be used to further
public:
   ///     matches.
   ///
   /// @return
   ///     A integer that contains SymbolContext::Scope bits set for
   ///     each item that was successfully resolved.
   ///
   /// @see SymbolContext::Scope
   //------------------------------------------------------------------
-  uint32_t ResolveSymbolContextsForFileSpec(const FileSpec &file_spec,
-                                            uint32_t line, bool check_inlines,
-                                            uint32_t resolve_scope,
-                                            SymbolContextList &sc_list);
+  uint32_t ResolveSymbolContextsForFileSpec(
+      const FileSpec &file_spec, uint32_t line, bool check_inlines,
+      lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list);
 
   void SetFileSpecAndObjectName(const FileSpec &file,
                                 const ConstString &object_name);
 
   bool GetIsDynamicLinkEditor();
 
   TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language);
 
protected:
   /// @return
   ///     A integer that contains SymbolContext::Scope bits set for
   ///     each item that was successfully resolved.
   ///
   /// @see SymbolContext::Scope
   //------------------------------------------------------------------
   uint32_t ResolveSymbolContextForAddress(lldb::addr_t vm_addr,
                                           bool vm_addr_is_file_addr,
-                                          uint32_t resolve_scope,
+                                          lldb::SymbolContextItem resolve_scope,
                                           Address &so_addr, SymbolContext &sc);
 
   void SymbolIndicesToSymbolContextList(Symtab *symtab,
                                         std::vector<uint32_t> &symbol_indexes,
                                         SymbolContextList &sc_list);
 
   bool SetArchitecture(const ArchSpec &new_arch);
 

include/lldb/Core/ModuleList.h

public:
 
   bool ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr) const;
 
   //------------------------------------------------------------------
   /// @copydoc Module::ResolveSymbolContextForAddress (const Address
   /// &,uint32_t,SymbolContext&)
   //------------------------------------------------------------------
   uint32_t ResolveSymbolContextForAddress(const Address &so_addr,
-                                          uint32_t resolve_scope,
+                                          lldb::SymbolContextItem resolve_scope,
                                           SymbolContext &sc) const;
 
   //------------------------------------------------------------------
   /// @copydoc Module::ResolveSymbolContextForFilePath (const char
   /// *,uint32_t,bool,uint32_t,SymbolContextList&)
   //------------------------------------------------------------------
-  uint32_t ResolveSymbolContextForFilePath(const char *file_path, uint32_t line,
-                                           bool check_inlines,
-                                           uint32_t resolve_scope,
-                                           SymbolContextList &sc_list) const;
+  uint32_t ResolveSymbolContextForFilePath(
+      const char *file_path, uint32_t line, bool check_inlines,
+      lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) const;
 
   //------------------------------------------------------------------
   /// @copydoc Module::ResolveSymbolContextsForFileSpec (const FileSpec
   /// &,uint32_t,bool,uint32_t,SymbolContextList&)
   //------------------------------------------------------------------
-  uint32_t ResolveSymbolContextsForFileSpec(const FileSpec &file_spec,
-                                            uint32_t line, bool check_inlines,
-                                            uint32_t resolve_scope,
-                                            SymbolContextList &sc_list) const;
+  uint32_t ResolveSymbolContextsForFileSpec(
+      const FileSpec &file_spec, uint32_t line, bool check_inlines,
+      lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) const;
 
   //------------------------------------------------------------------
   /// Gets the size of the module list.
   ///
   /// @return
   ///     The number of modules in the module list.
   //------------------------------------------------------------------
   size_t GetSize() const;

include/lldb/Symbol/CompileUnit.h

public:
   ///
   /// @return
   ///     The number of new matches that were added to \a sc_list.
   ///
   /// @see enum SymbolContext::Scope
   //------------------------------------------------------------------
   uint32_t ResolveSymbolContext(const FileSpec &file_spec, uint32_t line,
                                 bool check_inlines, bool exact,
-                                uint32_t resolve_scope,
+                                lldb::SymbolContextItem resolve_scope,
                                 SymbolContextList &sc_list);
 
   //------------------------------------------------------------------
   /// Get whether compiler optimizations were enabled for this compile unit
   ///
   /// "optimized" means that the debug experience may be difficult for the
   /// user to understand.  Variables may not be available when the developer
   /// would expect them, stepping through the source lines in the function may

include/lldb/Symbol/SymbolFile.h

public:
   }
   virtual CompilerDeclContext GetDeclContextForUID(lldb::user_id_t uid) {
     return CompilerDeclContext();
   }
   virtual CompilerDeclContext GetDeclContextContainingUID(lldb::user_id_t uid) {
     return CompilerDeclContext();
   }
   virtual uint32_t ResolveSymbolContext(const Address &so_addr,
-                                        uint32_t resolve_scope,
+                                        lldb::SymbolContextItem resolve_scope,
                                         SymbolContext &sc) = 0;
   virtual uint32_t ResolveSymbolContext(const FileSpec &file_spec,
                                         uint32_t line, bool check_inlines,
-                                        uint32_t resolve_scope,
+                                        lldb::SymbolContextItem resolve_scope,
                                         SymbolContextList &sc_list);
   virtual uint32_t
   FindGlobalVariables(const ConstString &name,
                       const CompilerDeclContext *parent_decl_ctx,
                       uint32_t max_matches, VariableList &variables);
   virtual uint32_t FindGlobalVariables(const RegularExpression &regex,
                                        uint32_t max_matches,
                                        VariableList &variables);

include/lldb/Symbol/SymbolVendor.h

public:
 
   virtual size_t ParseTypes(const SymbolContext &sc);
 
   virtual size_t ParseVariablesForContext(const SymbolContext &sc);
 
   virtual Type *ResolveTypeUID(lldb::user_id_t type_uid);
 
   virtual uint32_t ResolveSymbolContext(const Address &so_addr,
-                                        uint32_t resolve_scope,
+                                        lldb::SymbolContextItem resolve_scope,
                                         SymbolContext &sc);
 
   virtual uint32_t ResolveSymbolContext(const FileSpec &file_spec,
                                         uint32_t line, bool check_inlines,
-                                        uint32_t resolve_scope,
+                                        lldb::SymbolContextItem resolve_scope,
                                         SymbolContextList &sc_list);
 
   virtual size_t FindGlobalVariables(const ConstString &name,
                                      const CompilerDeclContext *parent_decl_ctx,
                                      size_t max_matches,
                                      VariableList &variables);
 
   virtual size_t FindGlobalVariables(const RegularExpression &regex,

include/lldb/Target/StackFrame.h

public:
   /// @params [in] resolve_scope
   ///   Flags from the SymbolContextItem enumerated type which specify what
   ///   type of symbol context is needed by this caller.
   ///
   /// @return
   ///   A SymbolContext reference which includes the types of information
   ///   requested by resolve_scope, if they are available.
   //------------------------------------------------------------------
-  const SymbolContext &GetSymbolContext(uint32_t resolve_scope);
+  const SymbolContext &GetSymbolContext(lldb::SymbolContextItem resolve_scope);
 
   //------------------------------------------------------------------
   /// Return the Canonical Frame Address (DWARF term) for this frame.
   ///
   /// The CFA is typically the value of the stack pointer register before the
   /// call invocation is made.  It will not change during the lifetime of a
   /// stack frame.  It is often not the same thing as the frame pointer
   /// register value.

include/lldb/lldb-enumerations.h

 //===-- lldb-enumerations.h -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_lldb_enumerations_h_
 #define LLDB_lldb_enumerations_h_
 
+#include <type_traits>
+
+// Macro to enable bitmask operations on an enum.  Without this, Enum | Enum
+// gets promoted to an int, so you have to say Enum a = Enum(eFoo | eBar).  If
+// you mark Enum with LLDB_MARK_AS_BITMASK_ENUM(Enum), however, you can simply
+// write Enum a = eFoo | eBar.
+#define LLDB_MARK_AS_BITMASK_ENUM(Enum)                                        \
+  inline Enum operator|(Enum a, Enum b) {                                      \
+    return static_cast<Enum>(                                                  \
+        static_cast<std::underlying_type<Enum>::type>(a) |                     \
+        static_cast<std::underlying_type<Enum>::type>(b));                     \
+  }                                                                            \
+  inline Enum operator&(Enum a, Enum b) {                                      \
+    return static_cast<Enum>(                                                  \
+        static_cast<std::underlying_type<Enum>::type>(a) &                     \
+        static_cast<std::underlying_type<Enum>::type>(b));                     \
+  }                                                                            \
+  inline Enum operator~(Enum a) {                                              \
+    return static_cast<Enum>(                                                  \
+        ~static_cast<std::underlying_type<Enum>::type>(a));                    \
+  }                                                                            \
+  inline Enum &operator|=(Enum &a, Enum b) {                                   \
+    a = a | b;                                                                 \
+    return a;                                                                  \
+  }                                                                            \
+  inline Enum &operator&=(Enum &a, Enum b) {                                   \
+    a = a & b;                                                                 \
+    return a;                                                                  \
+  }
+
 #ifndef SWIG
 // With MSVC, the default type of an enum is always signed, even if one of the
 // enumerator values is too large to fit into a signed integer but would
 // otherwise fit into an unsigned integer.  As a result of this, all of LLDB's
 // flag-style enumerations that specify something like eValueFoo = 1u << 31
 // result in negative values.  This usually just results in a benign warning,
 // but in a few places we actually do comparisons on the enum values, which
 // would cause a real bug.  Furthermore, there's no way to silence only this

 /// actually did get resolved during query function calls.
 ///
 /// Each definition corresponds to a one of the member variables
 /// in this class, and requests that that item be resolved, or
 /// indicates that the member did get resolved.
 //------------------------------------------------------------------
 FLAGS_ENUM(SymbolContextItem){
     eSymbolContextTarget = (1u << 0), ///< Set when \a target is requested from
-                                      ///a query, or was located in query
-                                      ///results
+                                      /// a query, or was located in query
+                                      /// results
     eSymbolContextModule = (1u << 1), ///< Set when \a module is requested from
-                                      ///a query, or was located in query
-                                      ///results
+                                      /// a query, or was located in query
+                                      /// results
     eSymbolContextCompUnit = (1u << 2), ///< Set when \a comp_unit is requested
-                                        ///from a query, or was located in query
-                                        ///results
+                                        /// from a query, or was located in
+                                        /// query results
     eSymbolContextFunction = (1u << 3), ///< Set when \a function is requested
-                                        ///from a query, or was located in query
-                                        ///results
+                                        /// from a query, or was located in
+                                        /// query results
     eSymbolContextBlock = (1u << 4),    ///< Set when the deepest \a block is
-                                     ///requested from a query, or was located
-                                     ///in query results
+                                     /// requested from a query, or was located
+                                     /// in query results
     eSymbolContextLineEntry = (1u << 5), ///< Set when \a line_entry is
-                                         ///requested from a query, or was
-                                         ///located in query results
+                                         /// requested from a query, or was
+                                         /// located in query results
     eSymbolContextSymbol = (1u << 6), ///< Set when \a symbol is requested from
-                                      ///a query, or was located in query
-                                      ///results
+                                      /// a query, or was located in query
+                                      /// results
     eSymbolContextEverything = ((eSymbolContextSymbol << 1) -
                                 1u), ///< Indicates to try and lookup everything
-                                     ///up during a routine symbol context
-                                     ///query.
-    eSymbolContextVariable = (1u << 7) ///< Set when \a global or static
-                                       ///variable is requested from a query, or
-                                       ///was located in query results.
+                                     /// up during a routine symbol context
+                                     /// query.
+    eSymbolContextVariable = (1u << 7), ///< Set when \a global or static
+                                        /// variable is requested from a query,
+                                        /// or was located in query results.
     ///< eSymbolContextVariable is potentially expensive to lookup so it isn't
-    ///included in
+    /// included in
     ///< eSymbolContextEverything which stops it from being used during frame PC
-    ///lookups and
+    /// lookups and
     ///< many other potential address to symbol context lookups.
 };
+LLDB_MARK_AS_BITMASK_ENUM(SymbolContextItem)
 
 FLAGS_ENUM(Permissions){ePermissionsWritable = (1u << 0),
                         ePermissionsReadable = (1u << 1),
                         ePermissionsExecutable = (1u << 2)};
 
 enum InputReaderAction {
   eInputReaderActivate, // reader is newly pushed onto the reader stack
   eInputReaderAsynchronousOutputWritten, // an async output event occurred; the

 
 //----------------------------------------------------------------------
 // Whether a summary should cap how much data it returns to users or not
 //----------------------------------------------------------------------
 enum TypeSummaryCapping {
   eTypeSummaryCapped = true,
   eTypeSummaryUncapped = false
 };
-
 } // namespace lldb
 
 #endif // LLDB_lldb_enumerations_h_

source/API/SBAddress.cpp

SBModule SBAddress::GetModule() {
   SBModule sb_module;
   if (m_opaque_ap->IsValid())
     sb_module.SetSP(m_opaque_ap->GetModule());
   return sb_module;
 }
 
 SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) {
   SBSymbolContext sb_sc;
+  SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
   if (m_opaque_ap->IsValid())
-    m_opaque_ap->CalculateSymbolContext(&sb_sc.ref(), resolve_scope);
+    m_opaque_ap->CalculateSymbolContext(&sb_sc.ref(), scope);
   return sb_sc;
 }
 
 SBCompileUnit SBAddress::GetCompileUnit() {
   SBCompileUnit sb_comp_unit;
   if (m_opaque_ap->IsValid())
     sb_comp_unit.reset(m_opaque_ap->CalculateSymbolContextCompileUnit());
   return sb_comp_unit;

source/API/SBFrame.cpp

bool SBFrame::IsValid() const {
   return false;
 }
 
 SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBSymbolContext sb_sym_ctx;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
-
+  SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
-        sb_sym_ctx.SetSymbolContext(&frame->GetSymbolContext(resolve_scope));
+        sb_sym_ctx.SetSymbolContext(&frame->GetSymbolContext(scope));
       } else {
         if (log)
           log->Printf("SBFrame::GetVariables () => error: could not "
                       "reconstruct frame object for this SBFrame.");
       }
     } else {
       if (log)
         log->Printf(

source/API/SBModule.cpp

SBAddress SBModule::ResolveFileAddress(lldb::addr_t vm_addr) {
   return sb_addr;
 }
 
 SBSymbolContext
 SBModule::ResolveSymbolContextForAddress(const SBAddress &addr,
                                          uint32_t resolve_scope) {
   SBSymbolContext sb_sc;
   ModuleSP module_sp(GetSP());
+  SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
   if (module_sp && addr.IsValid())
-    module_sp->ResolveSymbolContextForAddress(addr.ref(), resolve_scope,
-                                              *sb_sc);
+    module_sp->ResolveSymbolContextForAddress(addr.ref(), scope, *sb_sc);
   return sb_sc;
 }
 
 bool SBModule::GetDescription(SBStream &description) {
   Stream &strm = description.ref();
 
   ModuleSP module_sp(GetSP());
   if (module_sp) {

source/API/SBTarget.cpp

lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id,
   addr.SetRawAddress(vm_addr);
   return sb_addr;
 }
 
 SBSymbolContext
 SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr,
                                          uint32_t resolve_scope) {
   SBSymbolContext sc;
+  SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
   if (addr.IsValid()) {
     TargetSP target_sp(GetSP());
     if (target_sp)
-      target_sp->GetImages().ResolveSymbolContextForAddress(
-          addr.ref(), resolve_scope, sc.ref());
+      target_sp->GetImages().ResolveSymbolContextForAddress(addr.ref(), scope,
+                                                            sc.ref());
   }
   return sc;
 }
 
 size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size,
                             lldb::SBError &error) {
   SBError sb_error;
   size_t bytes_read = 0;

source/Commands/CommandObjectSource.cpp

if (!m_options.symbol_name.empty()) {
         for (size_t i = 0, e = m_options.modules.size(); i < e; ++i) {
           FileSpec module_file_spec(m_options.modules[i], false);
           if (module_file_spec) {
             ModuleSpec module_spec(module_file_spec);
             matching_modules.Clear();
             target->GetImages().FindModules(module_spec, matching_modules);
             num_matches += matching_modules.ResolveSymbolContextForFilePath(
                 filename, 0, check_inlines,
-                eSymbolContextModule | eSymbolContextCompUnit, sc_list);
+                SymbolContextItem(eSymbolContextModule |
+                                  eSymbolContextCompUnit),
+                sc_list);
           }
         }
       } else {
         num_matches = target->GetImages().ResolveSymbolContextForFilePath(
             filename, 0, check_inlines,
             eSymbolContextModule | eSymbolContextCompUnit, sc_list);
       }
 

source/Core/Address.cpp

bool Address::SectionWasDeletedPrivate() const {
   // reference to a valid shared pointer. This helps us know if we had a valid
   // reference to a section which is now invalid because the module it was in
   // was unloaded/deleted, or if the address doesn't have a valid reference to
   // a section.
   return empty_section_wp.owner_before(m_section_wp) ||
          m_section_wp.owner_before(empty_section_wp);
 }
 
-uint32_t Address::CalculateSymbolContext(SymbolContext *sc,
-                                         uint32_t resolve_scope) const {
+uint32_t
+Address::CalculateSymbolContext(SymbolContext *sc,
+                                SymbolContextItem resolve_scope) const {
   sc->Clear(false);
   // Absolute addresses don't have enough information to reconstruct even their
   // target.
 
   SectionSP section_sp(GetSection());
   if (section_sp) {
     ModuleSP module_sp(section_sp->GetModule());
     if (module_sp) {

source/Core/Disassembler.cpp

bool Disassembler::PrintInstructions(Disassembler *disasm_ptr,
   size_t address_text_size = 0;
   for (size_t i = 0; i < num_instructions_found; ++i) {
     Instruction *inst =
         disasm_ptr->GetInstructionList().GetInstructionAtIndex(i).get();
     if (inst) {
       const Address &addr = inst->GetAddress();
       ModuleSP module_sp(addr.GetModule());
       if (module_sp) {
-        const uint32_t resolve_mask = eSymbolContextFunction |
+        const SymbolContextItem resolve_mask = eSymbolContextFunction |
                                                eSymbolContextSymbol |
                                                eSymbolContextLineEntry;
         uint32_t resolved_mask =
             module_sp->ResolveSymbolContextForAddress(addr, resolve_mask, sc);
         if (resolved_mask) {
           StreamString strmstr;
           Debugger::FormatDisassemblerAddress(disassembly_format, &sc, nullptr,
                                               &exe_ctx, &addr, strmstr);
           size_t cur_line = strmstr.GetSizeOfLastLine();
           if (cur_line > address_text_size)

source/Core/Module.cpp

Timer scoped_timer(func_cat,
                      vm_addr);
   SectionList *section_list = GetSectionList();
   if (section_list)
     return so_addr.ResolveAddressUsingFileSections(vm_addr, section_list);
   return false;
 }
 
 uint32_t Module::ResolveSymbolContextForAddress(
-    const Address &so_addr, uint32_t resolve_scope, SymbolContext &sc,
-    bool resolve_tail_call_address) {
+    const Address &so_addr, lldb::SymbolContextItem resolve_scope,
+    SymbolContext &sc, bool resolve_tail_call_address) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   uint32_t resolved_flags = 0;
 
   // Clear the result symbol context in case we don't find anything, but don't
   // clear the target
   sc.Clear(false);
 
   // Get the section from the section/offset address.
if (resolve_scope & eSymbolContextSymbol &&
           }
         }
       }
     }
   }
   return resolved_flags;
 }
 
-uint32_t Module::ResolveSymbolContextForFilePath(const char *file_path,
-                                                 uint32_t line,
-                                                 bool check_inlines,
-                                                 uint32_t resolve_scope,
-                                                 SymbolContextList &sc_list) {
+uint32_t Module::ResolveSymbolContextForFilePath(
+    const char *file_path, uint32_t line, bool check_inlines,
+    lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
   FileSpec file_spec(file_path, false);
   return ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
                                           resolve_scope, sc_list);
 }
 
-uint32_t Module::ResolveSymbolContextsForFileSpec(const FileSpec &file_spec,
-                                                  uint32_t line,
-                                                  bool check_inlines,
-                                                  uint32_t resolve_scope,
-                                                  SymbolContextList &sc_list) {
+uint32_t Module::ResolveSymbolContextsForFileSpec(
+    const FileSpec &file_spec, uint32_t line, bool check_inlines,
+    lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat,
                      "Module::ResolveSymbolContextForFilePath (%s:%u, "
                      "check_inlines = %s, resolve_scope = 0x%8.8x)",
                      file_spec.GetPath().c_str(), line,
                      check_inlines ? "yes" : "no", resolve_scope);
 

source/Core/ModuleList.cpp

bool ModuleList::ResolveFileAddress(lldb::addr_t vm_addr,
   for (pos = m_modules.begin(); pos != end; ++pos) {
     if ((*pos)->ResolveFileAddress(vm_addr, so_addr))
       return true;
   }
 
   return false;
 }
 
-uint32_t ModuleList::ResolveSymbolContextForAddress(const Address &so_addr,
-                                                    uint32_t resolve_scope,
-                                                    SymbolContext &sc) const {
+uint32_t
+ModuleList::ResolveSymbolContextForAddress(const Address &so_addr,
+                                           SymbolContextItem resolve_scope,
   // The address is already section offset so it has a module
   uint32_t resolved_flags = 0;
   ModuleSP module_sp(so_addr.GetModule());
   if (module_sp) {
     resolved_flags =
         module_sp->ResolveSymbolContextForAddress(so_addr, resolve_scope, sc);
   } else {
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos) {
       resolved_flags =
           (*pos)->ResolveSymbolContextForAddress(so_addr, resolve_scope, sc);
       if (resolved_flags != 0)
         break;
     }
   }
 
   return resolved_flags;
 }
 
 uint32_t ModuleList::ResolveSymbolContextForFilePath(
     const char *file_path, uint32_t line, bool check_inlines,
-    uint32_t resolve_scope, SymbolContextList &sc_list) const {
+    SymbolContextItem resolve_scope, SymbolContextList &sc_list) const {
   FileSpec file_spec(file_path, false);
   return ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
                                           resolve_scope, sc_list);
 }
 
 uint32_t ModuleList::ResolveSymbolContextsForFileSpec(
     const FileSpec &file_spec, uint32_t line, bool check_inlines,
-    uint32_t resolve_scope, SymbolContextList &sc_list) const {
+    SymbolContextItem resolve_scope, SymbolContextList &sc_list) const {
   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
   collection::const_iterator pos, end = m_modules.end();
   for (pos = m_modules.begin(); pos != end; ++pos) {
     (*pos)->ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
                                              resolve_scope, sc_list);
   }
 
   return sc_list.GetSize();

source/Core/SourceManager.cpp

if (target) {
       if (!file_spec.GetDirectory() && file_spec.GetFilename()) {
         // If this is just a file name, lets see if we can find it in the
         // target:
         bool check_inlines = false;
         SymbolContextList sc_list;
         size_t num_matches =
             target->GetImages().ResolveSymbolContextForFilePath(
                 file_spec.GetFilename().AsCString(), 0, check_inlines,
-                lldb::eSymbolContextModule | lldb::eSymbolContextCompUnit,
+                SymbolContextItem(eSymbolContextModule |
+                                  eSymbolContextCompUnit),
                 sc_list);
         bool got_multiple = false;
         if (num_matches != 0) {
           if (num_matches > 1) {
             SymbolContext sc;
             FileSpec *test_cu_spec = NULL;
 
             for (unsigned i = 0; i < num_matches; i++) {

source/Plugins/Architecture/Mips/ArchitectureMips.cpp

lldb::addr_t ArchitectureMips::GetBreakableLoadAddress(lldb::addr_t addr,
 
   addr_t current_offset = 0;
 
   // Get the function boundaries to make sure we don't scan back before the
   // beginning of the current function.
   ModuleSP temp_addr_module_sp(resolved_addr.GetModule());
   if (temp_addr_module_sp) {
     SymbolContext sc;
-    uint32_t resolve_scope = eSymbolContextFunction | eSymbolContextSymbol;
+    SymbolContextItem resolve_scope =
+        eSymbolContextFunction | eSymbolContextSymbol;
     temp_addr_module_sp->ResolveSymbolContextForAddress(resolved_addr,
       resolve_scope, sc);
     Address sym_addr;
     if (sc.function)
       sym_addr = sc.function->GetAddressRange().GetBaseAddress();
     else if (sc.symbol)
       sym_addr = sc.symbol->GetAddress();
 

source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp

if (m_exe_ctx && m_inst) {
           module_sp->ResolveFileAddress(pc, pc_so_addr);
         }
       } else if (target && !target->GetSectionLoadList().IsEmpty()) {
         target->GetSectionLoadList().ResolveLoadAddress(value, value_so_addr);
         target->GetSectionLoadList().ResolveLoadAddress(pc, pc_so_addr);
       }
 
       SymbolContext sym_ctx;
-      const uint32_t resolve_scope =
+      const SymbolContextItem resolve_scope =
           eSymbolContextFunction | eSymbolContextSymbol;
       if (pc_so_addr.IsValid() && pc_so_addr.GetModule()) {
         pc_so_addr.GetModule()->ResolveSymbolContextForAddress(
             pc_so_addr, resolve_scope, sym_ctx);
       }
 
       if (value_so_addr.IsValid() && value_so_addr.GetSection()) {
         StreamString ss;

source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

for (uint32_t i = 0; i < thread_ptr->GetStackFrameCount(); ++i) {
     if (!thread_ptr->SetSelectedFrameByIndex(i))
       continue;
 
     StackFrameSP frame_sp = thread_ptr->GetSelectedFrame();
     if (!frame_sp)
       continue;
 
     // Find the function name
-    const SymbolContext sym_ctx = frame_sp->GetSymbolContext(false);
+    const SymbolContext sym_ctx =
+        frame_sp->GetSymbolContext(eSymbolContextFunction);
     const ConstString func_name = sym_ctx.GetFunctionName();
     if (!func_name)
       continue;
 
     if (log)
       log->Printf("%s - Inspecting function '%s'", __FUNCTION__,
                   func_name.GetCString());
 

source/Plugins/Process/Utility/RegisterContextLLDB.cpp

void RegisterContextLLDB::InitializeZerothFrame() {
   // hope we can unwind past this frame.
   ModuleSP pc_module_sp(m_current_pc.GetModule());
   if (!m_current_pc.IsValid() || !pc_module_sp) {
     UnwindLogMsg("using architectural default unwind method");
   }
 
   // We require either a symbol or function in the symbols context to be
   // successfully filled in or this context is of no use to us.
-  const uint32_t resolve_scope = eSymbolContextFunction | eSymbolContextSymbol;
+  const SymbolContextItem resolve_scope =
+      eSymbolContextFunction | eSymbolContextSymbol;
   if (pc_module_sp.get() && (pc_module_sp->ResolveSymbolContextForAddress(
                                  m_current_pc, resolve_scope, m_sym_ctx) &
                              resolve_scope)) {
     m_sym_ctx_valid = true;
   }
 
   if (m_sym_ctx.symbol) {
     UnwindLogMsg("with pc value of 0x%" PRIx64 ", symbol name is '%s'",
void RegisterContextLLDB::InitializeNonZerothFrame() {
   bool resolve_tail_call_address = false; // m_current_pc can be one past the
                                           // address range of the function...
   // If the saved pc does not point to a function/symbol because it is beyond
   // the bounds of the correct function and there's no symbol there, we do
   // *not* want ResolveSymbolContextForAddress to back up the pc by 1, because
   // then we might not find the correct unwind information later. Instead, let
   // ResolveSymbolContextForAddress fail, and handle the case via
   // decr_pc_and_recompute_addr_range below.
-  const uint32_t resolve_scope = eSymbolContextFunction | eSymbolContextSymbol;
+  const SymbolContextItem resolve_scope =
+      eSymbolContextFunction | eSymbolContextSymbol;
   uint32_t resolved_scope = pc_module_sp->ResolveSymbolContextForAddress(
       m_current_pc, resolve_scope, m_sym_ctx, resolve_tail_call_address);
 
   // We require either a symbol or function in the symbols context to be
   // successfully filled in or this context is of no use to us.
   if (resolve_scope & resolved_scope) {
     m_sym_ctx_valid = true;
   }
void RegisterContextLLDB::InitializeNonZerothFrame() {
   if (decr_pc_and_recompute_addr_range) {
     UnwindLogMsg("Backing up the pc value of 0x%" PRIx64
                  " by 1 and re-doing symbol lookup; old symbol was %s",
                  pc, GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
     Address temporary_pc;
     temporary_pc.SetLoadAddress(pc - 1, &process->GetTarget());
     m_sym_ctx.Clear(false);
     m_sym_ctx_valid = false;
-    uint32_t resolve_scope = eSymbolContextFunction | eSymbolContextSymbol;
+    SymbolContextItem resolve_scope =
+        eSymbolContextFunction | eSymbolContextSymbol;
 
     ModuleSP temporary_module_sp = temporary_pc.GetModule();
     if (temporary_module_sp &&
         temporary_module_sp->ResolveSymbolContextForAddress(
             temporary_pc, resolve_scope, m_sym_ctx) &
             resolve_scope) {
       if (m_sym_ctx.GetAddressRange(resolve_scope, 0, false, addr_range))
         m_sym_ctx_valid = true;

source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.cpp

if (frame.pc >= 0x1000) {
       cursor.pc = frame.pc;
       cursor.fp = frame.fp;
       m_cursors.push_back(cursor);
     }
   }
   if (!m_cursors.empty()) {
     lldb::addr_t first_frame_pc = m_cursors.front().pc;
     if (first_frame_pc != LLDB_INVALID_ADDRESS) {
-      const uint32_t resolve_scope =
+      const SymbolContextItem resolve_scope =
           eSymbolContextModule | eSymbolContextCompUnit |
           eSymbolContextFunction | eSymbolContextSymbol;
 
       SymbolContext first_frame_sc(
           first_frame->GetSymbolContext(resolve_scope));
       const AddressRange *addr_range_ptr = NULL;
       AddressRange range;
       if (first_frame_sc.function)
if (frame.pc >= 0x1000) {
       cursor.pc = frame.pc;
       cursor.fp = frame.fp;
       m_cursors.push_back(cursor);
     }
   }
   if (!m_cursors.empty()) {
     lldb::addr_t first_frame_pc = m_cursors.front().pc;
     if (first_frame_pc != LLDB_INVALID_ADDRESS) {
-      const uint32_t resolve_scope =
+      const SymbolContextItem resolve_scope =
           eSymbolContextModule | eSymbolContextCompUnit |
           eSymbolContextFunction | eSymbolContextSymbol;
 
       SymbolContext first_frame_sc(
           first_frame->GetSymbolContext(resolve_scope));
       const AddressRange *addr_range_ptr = NULL;
       AddressRange range;
       if (first_frame_sc.function)

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
 
   lldb_private::CompilerDeclContext
   GetDeclContextContainingUID(lldb::user_id_t uid) override;
 
   void
   ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx) override;
 
   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
-                                uint32_t resolve_scope,
+                                lldb::SymbolContextItem resolve_scope,
                                 lldb_private::SymbolContext &sc) override;
 
   uint32_t
   ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line,
-                       bool check_inlines, uint32_t resolve_scope,
+                       bool check_inlines,
+                       lldb::SymbolContextItem resolve_scope,
                        lldb_private::SymbolContextList &sc_list) override;
 
   uint32_t
   FindGlobalVariables(const lldb_private::ConstString &name,
                       const lldb_private::CompilerDeclContext *parent_decl_ctx,
                       uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
 

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (module_sp) {
       }
     }
     m_global_aranges_ap->Sort();
   }
   return *m_global_aranges_ap;
 }
 
 uint32_t SymbolFileDWARF::ResolveSymbolContext(const Address &so_addr,
-                                               uint32_t resolve_scope,
+                                               SymbolContextItem resolve_scope,
                                                SymbolContext &sc) {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat,
                      "SymbolFileDWARF::"
                      "ResolveSymbolContext (so_addr = { "
                      "section = %p, offset = 0x%" PRIx64
                      " }, resolve_scope = 0x%8.8x)",
                      static_cast<void *>(so_addr.GetSection().get()),
if (resolve_scope &
     }
   }
   return resolved;
 }
 
 uint32_t SymbolFileDWARF::ResolveSymbolContext(const FileSpec &file_spec,
                                                uint32_t line,
                                                bool check_inlines,
-                                               uint32_t resolve_scope,
+                                               SymbolContextItem resolve_scope,
                                                SymbolContextList &sc_list) {
   const uint32_t prev_size = sc_list.GetSize();
   if (resolve_scope & eSymbolContextCompUnit) {
     DWARFDebugInfo *debug_info = DebugInfo();
     if (debug_info) {
       uint32_t cu_idx;
       DWARFUnit *dwarf_cu = NULL;
 

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

public:
   GetDeclContextForUID(lldb::user_id_t uid) override;
   lldb_private::CompilerDeclContext
   GetDeclContextContainingUID(lldb::user_id_t uid) override;
   void
   ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx) override;
 
   bool CompleteType(lldb_private::CompilerType &compiler_type) override;
   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
-                                uint32_t resolve_scope,
+                                lldb::SymbolContextItem resolve_scope,
                                 lldb_private::SymbolContext &sc) override;
   uint32_t
   ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line,
-                       bool check_inlines, uint32_t resolve_scope,
+                       bool check_inlines,
+                       lldb::SymbolContextItem resolve_scope,
                        lldb_private::SymbolContextList &sc_list) override;
   uint32_t
   FindGlobalVariables(const lldb_private::ConstString &name,
                       const lldb_private::CompilerDeclContext *parent_decl_ctx,
                       uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
   uint32_t FindGlobalVariables(const lldb_private::RegularExpression &regex,
                                uint32_t max_matches,

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
         return true;
       }
       return false;
     });
   }
   return success;
 }
 
-uint32_t SymbolFileDWARFDebugMap::ResolveSymbolContext(
-    const Address &exe_so_addr, uint32_t resolve_scope, SymbolContext &sc) {
+uint32_t
+SymbolFileDWARFDebugMap::ResolveSymbolContext(const Address &exe_so_addr,
+                                              SymbolContextItem resolve_scope,
+                                              SymbolContext &sc) {
   uint32_t resolved_flags = 0;
   Symtab *symtab = m_obj_file->GetSymtab();
   if (symtab) {
     const addr_t exe_file_addr = exe_so_addr.GetFileAddress();
 
     const DebugMap::Entry *debug_map_entry =
         m_debug_map.FindEntryThatContains(exe_file_addr);
     if (debug_map_entry) {
if (debug_map_entry) {
       }
     }
   }
   return resolved_flags;
 }
 
 uint32_t SymbolFileDWARFDebugMap::ResolveSymbolContext(
     const FileSpec &file_spec, uint32_t line, bool check_inlines,
-    uint32_t resolve_scope, SymbolContextList &sc_list) {
+    SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
   const uint32_t initial = sc_list.GetSize();
   const uint32_t cu_count = GetNumCompileUnits();
 
   for (uint32_t i = 0; i < cu_count; ++i) {
     // If we are checking for inlines, then we need to look through all compile
     // units no matter if "file_spec" matches.
     bool resolve = check_inlines;
 

source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

public:
   size_t ParseFunctionBlocks(const SymbolContext &sc) override;
 
   size_t ParseTypes(const SymbolContext &sc) override;
   size_t ParseVariablesForContext(const SymbolContext &sc) override {
     return 0;
   }
   Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
   bool CompleteType(CompilerType &compiler_type) override;
-  uint32_t ResolveSymbolContext(const Address &so_addr, uint32_t resolve_scope,
+  uint32_t ResolveSymbolContext(const Address &so_addr,
+                                lldb::SymbolContextItem resolve_scope,
                                 SymbolContext &sc) override;
 
   size_t GetTypes(SymbolContextScope *sc_scope, uint32_t type_mask,
                   TypeList &type_list) override;
 
   uint32_t FindFunctions(const ConstString &name,
                          const CompilerDeclContext *parent_decl_ctx,
                          uint32_t name_type_mask, bool include_inlines,

source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

static bool NeedsResolvedCompileUnit(uint32_t resolve_scope) {
   uint32_t flags = eSymbolContextCompUnit;
   flags |= eSymbolContextVariable;
   flags |= eSymbolContextFunction;
   flags |= eSymbolContextBlock;
   flags |= eSymbolContextLineEntry;
   return (resolve_scope & flags) != 0;
 }
 
-uint32_t SymbolFileNativePDB::ResolveSymbolContext(const Address &addr,
-                                                   uint32_t resolve_scope,
-                                                   SymbolContext &sc) {
+uint32_t SymbolFileNativePDB::ResolveSymbolContext(
+    const Address &addr, SymbolContextItem resolve_scope, SymbolContext &sc) {
   uint32_t resolved_flags = 0;
   lldb::addr_t file_addr = addr.GetFileAddress();
 
   if (NeedsResolvedCompileUnit(resolve_scope)) {
     llvm::Optional<uint16_t> modi = m_index->GetModuleIndexForVa(file_addr);
     if (!modi)
       return 0;
     PdbSymUid cuid = PdbSymUid::makeCompilandId(*modi);

source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

public:
 
   lldb_private::CompilerDeclContext
   GetDeclContextContainingUID(lldb::user_id_t uid) override;
 
   void
   ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx) override;
 
   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
-                                uint32_t resolve_scope,
+                                lldb::SymbolContextItem resolve_scope,
                                 lldb_private::SymbolContext &sc) override;
 
   uint32_t
   ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line,
-                       bool check_inlines, uint32_t resolve_scope,
+                       bool check_inlines,
+                       lldb::SymbolContextItem resolve_scope,
                        lldb_private::SymbolContextList &sc_list) override;
 
   uint32_t
   FindGlobalVariables(const lldb_private::ConstString &name,
                       const lldb_private::CompilerDeclContext *parent_decl_ctx,
                       uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
 

source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

if (!pdb)
     return;
 
   pdb->ParseDeclsForDeclContext(
       static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext()));
 }
 
 uint32_t
 SymbolFilePDB::ResolveSymbolContext(const lldb_private::Address &so_addr,
-                                    uint32_t resolve_scope,
+                                    SymbolContextItem resolve_scope,
                                     lldb_private::SymbolContext &sc) {
   uint32_t resolved_flags = 0;
   if (resolve_scope & eSymbolContextCompUnit ||
       resolve_scope & eSymbolContextVariable ||
       resolve_scope & eSymbolContextFunction ||
       resolve_scope & eSymbolContextBlock ||
       resolve_scope & eSymbolContextLineEntry) {
     auto cu_sp = GetCompileUnitContainsAddress(so_addr);
if (resolve_scope & eSymbolContextLineEntry) {
     }
   }
 
   return resolved_flags;
 }
 
 uint32_t SymbolFilePDB::ResolveSymbolContext(
     const lldb_private::FileSpec &file_spec, uint32_t line, bool check_inlines,
-    uint32_t resolve_scope, lldb_private::SymbolContextList &sc_list) {
+    SymbolContextItem resolve_scope, lldb_private::SymbolContextList &sc_list) {
   const size_t old_size = sc_list.GetSize();
   if (resolve_scope & lldb::eSymbolContextCompUnit) {
     // Locate all compilation units with line numbers referencing the specified
     // file.  For example, if `file_spec` is <vector>, then this should return
     // all source files and header files that reference <vector>, either
     // directly or indirectly.
     auto compilands = m_session_up->findCompilandsForSourceFile(
         file_spec.GetPath(), PDB_NameSearchFlags::NS_CaseInsensitive);

source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h

public:
   size_t
   ParseVariablesForContext(const lldb_private::SymbolContext &sc) override;
 
   lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
 
   bool CompleteType(lldb_private::CompilerType &compiler_type) override;
 
   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
-                                uint32_t resolve_scope,
+                                lldb::SymbolContextItem resolve_scope,
                                 lldb_private::SymbolContext &sc) override;
 
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                   uint32_t type_mask,
                   lldb_private::TypeList &type_list) override;
 
   //------------------------------------------------------------------
   // PluginInterface protocol

source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

Type *SymbolFileSymtab::ResolveTypeUID(lldb::user_id_t type_uid) {
   return NULL;
 }
 
 bool SymbolFileSymtab::CompleteType(lldb_private::CompilerType &compiler_type) {
   return false;
 }
 
 uint32_t SymbolFileSymtab::ResolveSymbolContext(const Address &so_addr,
-                                                uint32_t resolve_scope,
+                                                SymbolContextItem resolve_scope,
                                                 SymbolContext &sc) {
   if (m_obj_file->GetSymtab() == NULL)
     return 0;
 
   uint32_t resolved_flags = 0;
   if (resolve_scope & eSymbolContextSymbol) {
     sc.symbol = m_obj_file->GetSymtab()->FindSymbolContainingFileAddress(
         so_addr.GetFileAddress());

source/Symbol/CompileUnit.cpp

uint32_t CompileUnit::FindLineEntry(uint32_t start_idx, uint32_t line,
   if (line_table)
     return line_table->FindLineEntryIndexByFileIndex(start_idx, file_idx, line,
                                                      exact, line_entry_ptr);
   return UINT32_MAX;
 }
 
 uint32_t CompileUnit::ResolveSymbolContext(const FileSpec &file_spec,
                                            uint32_t line, bool check_inlines,
-                                           bool exact, uint32_t resolve_scope,
+                                           bool exact,
+                                           SymbolContextItem resolve_scope,
                                            SymbolContextList &sc_list) {
   // First find all of the file indexes that match our "file_spec". If
   // "file_spec" has an empty directory, then only compare the basenames when
   // finding file indexes
   std::vector<uint32_t> file_indexes;
   const bool full_match = (bool)file_spec.GetDirectory();
   bool file_spec_matches_cu_file_spec =
       FileSpec::Equal(file_spec, *this, full_match);

source/Symbol/SymbolFile.cpp

TypeSystem *type_system =
       m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
   if (type_system)
     type_system->SetSymbolFile(this);
   return type_system;
 }
 
 uint32_t SymbolFile::ResolveSymbolContext(const FileSpec &file_spec,
                                           uint32_t line, bool check_inlines,
-                                          uint32_t resolve_scope,
+                                          lldb::SymbolContextItem resolve_scope,
                                           SymbolContextList &sc_list) {
   return 0;
 }
 
 uint32_t
 SymbolFile::FindGlobalVariables(const ConstString &name,
                                 const CompilerDeclContext *parent_decl_ctx,
                                 uint32_t max_matches, VariableList &variables) {

source/Symbol/SymbolVendor.cpp

if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_ap.get())
       return m_sym_file_ap->ResolveTypeUID(type_uid);
   }
   return nullptr;
 }
 
 uint32_t SymbolVendor::ResolveSymbolContext(const Address &so_addr,
-                                            uint32_t resolve_scope,
+                                            SymbolContextItem resolve_scope,
                                             SymbolContext &sc) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_ap.get())
       return m_sym_file_ap->ResolveSymbolContext(so_addr, resolve_scope, sc);
   }
   return 0;
 }
 
 uint32_t SymbolVendor::ResolveSymbolContext(const FileSpec &file_spec,
                                             uint32_t line, bool check_inlines,
-                                            uint32_t resolve_scope,
+                                            SymbolContextItem resolve_scope,
                                             SymbolContextList &sc_list) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_ap.get())
       return m_sym_file_ap->ResolveSymbolContext(file_spec, line, check_inlines,
                                                  resolve_scope, sc_list);
   }

source/Target/StackFrame.cpp

 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/RegisterValue.h"
 
+#include "lldb/lldb-enumerations.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 // The first bits in the flags are reserved for the SymbolContext::Scope bits
 // so we know if we have tried to look up information in our internal symbol
 // context (m_sc) already.
 #define RESOLVED_FRAME_CODE_ADDR (uint32_t(eSymbolContextEverything + 1))
 #define RESOLVED_FRAME_ID_SYMBOL_SCOPE (RESOLVED_FRAME_CODE_ADDR << 1)

 }
 
 //----------------------------------------------------------------------
 // Get the symbol context if we already haven't done so by resolving the
 // PC address as much as possible. This way when we pass around a
 // StackFrame object, everyone will have as much information as possible and no
 // one will ever have to look things up manually.
 //----------------------------------------------------------------------
-const SymbolContext &StackFrame::GetSymbolContext(uint32_t resolve_scope) {
+const SymbolContext &
+StackFrame::GetSymbolContext(SymbolContextItem resolve_scope) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   // Copy our internal symbol context into "sc".
   if ((m_flags.Get() & resolve_scope) != resolve_scope) {
     uint32_t resolved = 0;
 
     // If the target was requested add that:
     if (!m_sc.target_sp) {
       m_sc.target_sp = CalculateTarget();
if (m_frame_index > 0 && lookup_addr.IsValid()) {
       }
     }
 
     if (m_sc.module_sp) {
       // We have something in our stack frame symbol context, lets check if we
       // haven't already tried to lookup one of those things. If we haven't
       // then we will do the query.
 
-      uint32_t actual_resolve_scope = 0;
+      SymbolContextItem actual_resolve_scope = SymbolContextItem(0);
 
       if (resolve_scope & eSymbolContextCompUnit) {
         if (m_flags.IsClear(eSymbolContextCompUnit)) {
           if (m_sc.comp_unit)
             resolved |= eSymbolContextCompUnit;
           else
             actual_resolve_scope |= eSymbolContextCompUnit;
         }