Fix SBValue::FindValue for file static variables

[jingham]

Summary

This was just a thinko. The API StackFrame::GetVariableList takes a bool for "get_file_globals" which if true will also find file statics and file globals. But we only were passing that as true if the ValueType was eValueTypeVariableGlobal, which meant that we never find file statics. It's okay if we cast too wide a net when we do GetVariableList as later on we check against the ValueType to filter globals from statics.

There was a test that had a whole bunch of globals and tested FindValue on all of them, but had no statics. So I just made one of the globals a file static, which verifies the fix.

[JDevlieghere]

LGTM

[mib]

LGTM!

lldb/source/API/SBFrame.cpp

if (stop_locker.TryLock(&process->GetRunLock())) {
           const bool stop_if_block_is_inlined_function = true;
 
           if (sc.block)
             sc.block->AppendVariables(
                 can_create, get_parent_variables,
                 stop_if_block_is_inlined_function,
                 [frame](Variable *v) { return v->IsInScope(frame); },
                 &variable_list);
-          if (value_type == eValueTypeVariableGlobal) {
+          if (value_type == eValueTypeVariableGlobal 
+              || value_type == eValueTypeVariableStatic) {
             const bool get_file_globals = true;
             VariableList *frame_vars = frame->GetVariableList(get_file_globals,
                                                               nullptr);
             if (frame_vars)
               frame_vars->AppendVariablesIfUnique(variable_list);
           }
           ConstString const_name(name);
           VariableSP variable_sp(

lldb/test/API/python_api/process/TestProcessAPI.py

def test_read_memory(self):
         process = target.LaunchSimple(None, None, self.get_process_working_directory())
 
         thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(), "There should be a thread stopped due to breakpoint"
         )
         frame = thread.GetFrameAtIndex(0)
 
-        # Get the SBValue for the global variable 'my_char'.
-        val = frame.FindValue("my_char", lldb.eValueTypeVariableGlobal)
+        # Get the SBValue for the file static variable 'my_char'.
+        val = frame.FindValue("my_char", lldb.eValueTypeVariableStatic)
         self.DebugSBValue(val)
 
         # Due to the typemap magic (see lldb.swig), we pass in 1 to ReadMemory and
         # expect to get a Python string as the result object!
         error = lldb.SBError()
         self.assertFalse(val.TypeIsPointerType())
         content = process.ReadMemory(val.AddressOf().GetValueAsUnsigned(), 1, error)
         if not error.Success():
def test_write_memory(self):
         process = target.LaunchSimple(None, None, self.get_process_working_directory())
 
         thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(), "There should be a thread stopped due to breakpoint"
         )
         frame = thread.GetFrameAtIndex(0)
 
-        # Get the SBValue for the global variable 'my_char'.
-        val = frame.FindValue("my_char", lldb.eValueTypeVariableGlobal)
+        # Get the SBValue for the static variable 'my_char'.
+        val = frame.FindValue("my_char", lldb.eValueTypeVariableStatic)
         self.DebugSBValue(val)
 
         # If the variable does not have a load address, there's no sense
         # continuing.
         if not val.GetLocation().startswith("0x"):
             return
 
         # OK, let's get the hex location of the variable.

lldb/test/API/python_api/process/main.cpp

 #include <stdio.h>
 #include <stdint.h>
 
 // This simple program is to test the lldb Python API related to process.
 
-char my_char = 'u';
+static char my_char = 'u';
 char my_cstring[] = "lldb.SBProcess.ReadCStringFromMemory() works!";
 char *my_char_ptr = (char *)"Does it work?";
 uint32_t my_uint32 = 12345;
 int my_int = 0;
 
 int main (int argc, char const *argv[])
 {
     for (int i = 0; i < 3; ++i) {