Fix resolution conflict between global and class static variables in C++.

[paulherman]

Summary

Consider having a global variable 'a' and a static variable with the same name inside a class. This resolves the arbitrary choice when resolving the name 'a'.

[clayborg]

See inlined comments.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

7389

I would do this as:

const DWARFDebugInfoEntry *parent_die = GetDeclContextDIEContainingDIE(dwarf_cu, die);
if (parent_die->Tag() != DW_TAG_class_type && parent_die->Tag() != DW_TAG_structure_type)
{
    VariableSP var_sp (ParseVariableDIE(sc, dwarf_cu, die, LLDB_INVALID_ADDRESS));
    if (var_sp)
    {
        variables->AddVariableIfUnique (var_sp);
        ++vars_added;
    }

This will avoid parsing extra global variables by figuring out we don't need it _before_ we go and parse a global variable.

I would rather not have the SymbolFileDWARF::ParseGlobalVariableDIE(...) function because it doesn't make sense at as global variables can exist in classes and structures and I would expect a function named SymbolFileDWARF::ParseGlobalVariableDIE(...) to parse that variable, but SymbolFileDWARF:: ParseVariableDIE(...) already does this so there is really no need for SymbolFileDWARF::ParseGlobalVariableDIE().

7413–7437

Remove this. See inlined comment above.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

325–330

Remove this.

[clayborg]

Please make sure that the following works after your changes:

(lldb) r
Process 35421 launched: '/private/tmp/a.out' (x86_64)
Process 35421 stopped
* thread #1: tid = 0xb659be, 0x0000000100000f9d a.out main + 13, stop reason = breakpoint 1.1, queue = com.apple.main-thread
    frame #0: 0x0000000100000f9d a.out main + 13 at main.cpp:24
   21  	
   22  	int main()
   23  	{
-> 24  	    return 0; // break here
   25  	}
(lldb) target variable 
Global variables for /tmp/main.cpp in /private/tmp/a.out:
(int) A::a = 1111
(int) B::a = 2222
(int) C::a = 3333
(int) ::a = 4444

[paulherman]

I've changed the commit so that ParseVariableDIE now detects if a variable is static inside a class or struct. Now "target variable" works since the variables are not removed from the variable list of the compile unit, but filtered when searching for a specific variable.

[clayborg]

Looks fine.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

protected:
     lldb_private::Type*     ResolveTypeUID (DWARFCompileUnit* dwarf_cu, const DWARFDebugInfoEntry* die, bool assert_not_being_parsed);
 
     lldb::VariableSP        ParseVariableDIE(
                                 const lldb_private::SymbolContext& sc,
                                 DWARFCompileUnit* dwarf_cu,
                                 const DWARFDebugInfoEntry *die,
                                 const lldb::addr_t func_low_pc);
 
+    lldb::VariableSP        ParseGlobalVariableDIE(
+                                const lldb_private::SymbolContext& sc,
+                                DWARFCompileUnit* dwarf_cu,
+                                const DWARFDebugInfoEntry *die,
+                                const lldb::addr_t func_low_pc);
+
     size_t                  ParseVariables(
                                 const lldb_private::SymbolContext& sc,
                                 DWARFCompileUnit* dwarf_cu,
                                 const lldb::addr_t func_low_pc,
                                 const DWARFDebugInfoEntry *die,
                                 bool parse_siblings,
                                 bool parse_children,
                                 lldb_private::VariableList* cc_variable_list = NULL);

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (sc.comp_unit != NULL)
                 {
                     DWARFDebugInfo* debug_info = DebugInfo();
                     for (size_t i=0; i<num_matches; ++i)
                     {
                         const dw_offset_t die_offset = die_offsets[i];
                         die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &match_dwarf_cu);
                         if (die)
                         {
-                            VariableSP var_sp (ParseVariableDIE(sc, dwarf_cu, die, LLDB_INVALID_ADDRESS));
+                            VariableSP var_sp (ParseGlobalVariableDIE(sc, dwarf_cu, die, LLDB_INVALID_ADDRESS));
                             if (var_sp)
                             {
                                 variables->AddVariableIfUnique (var_sp);
                                 ++vars_added;
                             }
                         }
                         else
                         {
                             if (m_using_apple_tables)
                             {
                                 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x)\n", die_offset);
                             }
                         }            
 
                     }
                 }
             }
             return vars_added;
         }
     }
     return 0;
 }
 
+VariableSP
+SymbolFileDWARF::ParseGlobalVariableDIE
+(
+    const SymbolContext& sc,
+    DWARFCompileUnit* dwarf_cu,
+    const DWARFDebugInfoEntry *die,
+    const lldb::addr_t func_low_pc
+)
+{
+    assert(sc.function == NULL);
+    assert(sc.comp_unit != NULL);
+
+    VariableSP var_sp(ParseVariableDIE(sc, dwarf_cu, die, func_low_pc)); 
+    
+    if (var_sp) 
+    {
+        const DWARFDebugInfoEntry *parent_die = GetDeclContextDIEContainingDIE(dwarf_cu, die);
+        if (parent_die->Tag() != DW_TAG_class_type && parent_die->Tag() != DW_TAG_structure_type)
+            return var_sp;
+        else
+            return VariableSP();
+    }
+
+    return var_sp;
+}
 
 VariableSP
 SymbolFileDWARF::ParseVariableDIE
 (
     const SymbolContext& sc,
     DWARFCompileUnit* dwarf_cu,
     const DWARFDebugInfoEntry *die,
     const lldb::addr_t func_low_pc

test/lang/cpp/scope/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

test/lang/cpp/scope/TestCppScope.py

+"""
+Test scopes in C++.
+"""
+import lldb
+from lldbtest import *
+import lldbutil
+
+class TestCppScopes(TestBase):
+    
+    mydir = TestBase.compute_mydir(__file__)
+    
+    @skipUnlessDarwin
+    @dsym_test
+    def test_with_dsym_and_run_command(self):
+        self.buildDsym()
+        self.check()
+
+    @dwarf_test
+    def test_with_dwarf_and_run_command(self):
+        self.buildDwarf()
+        self.check()
+
+    def setUp(self):
+        TestBase.setUp(self)
+
+    def check(self):
+        # Get main source file
+        src_file = "main.cpp"
+        src_file_spec = lldb.SBFileSpec(src_file)
+        self.assertTrue(src_file_spec.IsValid(), "Main source file")
+        
+        # Get the path of the executable
+        cwd = os.getcwd() 
+        exe_file = "a.out"
+        exe_path  = os.path.join(cwd, exe_file)
+        
+        # Load the executable
+        target = self.dbg.CreateTarget(exe_path)
+        self.assertTrue(target.IsValid(), VALID_TARGET)
+
+        # Break on main function
+        main_breakpoint = target.BreakpointCreateBySourceRegex("// break here", src_file_spec)
+        self.assertTrue(main_breakpoint.IsValid() and main_breakpoint.GetNumLocations() >= 1, VALID_BREAKPOINT)
+
+        # Launch the process
+        args = None
+        env = None
+        process = target.LaunchSimple(args, env, cwd)
+        self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
+
+        # Get the thread of the process
+        self.assertTrue(process.GetState() == lldb.eStateStopped, PROCESS_STOPPED)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+
+        # Get current fream of the thread at the breakpoint 
+        frame = thread.GetSelectedFrame()
+
+        # Test result for scopes of variables 
+        test_result = frame.EvaluateExpression("A::a")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 1111, "A::a = 1111")
+        
+        test_result = frame.EvaluateExpression("B::a")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 2222, "B::a = 2222")
+
+        test_result = frame.EvaluateExpression("C::a")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 3333, "C::a = 3333")
+
+        test_result = frame.EvaluateExpression("a")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 4444, "a = 4444")
+        
+
+if __name__ == '__main__':
+    import atexit
+    lldb.SBDebugger.Initialize()
+    atexit.register(lambda: lldb.SBDebugger.Terminate())
+    unittest2.main()

test/lang/cpp/scope/main.cpp

+class A {
+public:
+    static int a;
+    int b;
+};
+
+class B {
+public:
+    static int a;
+    int b;
+};
+
+struct C {
+    static int a;
+};
+
+int A::a = 1111;
+int B::a = 2222;
+int C::a = 3333;
+int a = 4444;
+
+int main() // break here
+{
+    return 0;
+}