[ScriptInterpreter] Make sure LLDB's global variables are only available in interactive mode.

[JDevlieghere]

Summary

Jim pointed out that the LLDB global variables should only be available
in interactive mode. When used from a command for example, their values
might be stale or not at all what the user expects. Therefore we want to
explicitly make these variables unavailable.

[jingham]

This looks right.

EnterSession always initializes lldb.debugger, even when it isn't going to set the other globals. That's because one debugger owns one ScriptInterpreter and lldb.debugger always has a unique, valid value. So it isn't strictly necessary to None out lldb.debugger. But since EnterSession always sets it, I don't think it matters one way or the other.

[labath]

Unfortunately, there was a bug here which caused the test to fail on linux and windows. r372222 ought to fix that. From the patch description:

The test was expecting the value of "lldb.frame" to be None, because it
is cleared after each python interpreter session. However, this is not
true in the very first session, because lldb.py sets these values to
invalid objects (lldb.SBFrame(), etc.).

I have not investigated why is it that this test passes on darwin, but
my guess is that this is because we do extra work on darwin (loading the
objc runtime, etc), which causes us to enter the python interpreter
sooner.

This patch changes lldb.py to also initialize these values to None, as
that seems to make more sense.

I am pretty sure this will fix the issue on linux, but I am not sure about windows, because it may fail later due to the use of nested quotes, which mostly doesn't work there. Overall, it's usually better to avoid nested quotes in lit tests.

lldb/trunk/lit/Commands/Inputs/frame.py

 import lldb
-print(lldb.frame)
+print("frame:py: {}".format(lldb.frame))

lldb/trunk/lit/Commands/command-script-import.test

 # RUN: echo 'b main' > %t.in
 # RUN: echo 'run' >> %t.in
 # RUN: echo 'command script import %S/Inputs/frame.py' >> %t.in
 
 # RUN: %clang -g -O0 %S/Inputs/main.c -o %t.out
-# RUN: %lldb -b -s %t.in %t.out | FileCheck %s
+# RUN: %lldb -b -s %t.in -o 'script print("script: {}").format(lldb.frame)' %t.out | FileCheck %s
 
-# CHECK: frame #0
+# Make sure that we don't have access to lldb.frame from the Python script.
+# CHECK: frame:py: None
+
+# Make sure that we do have access to lldb.frame from the script command.
+# CHECK: script: frame #0

lldb/trunk/packages/Python/lldbsuite/test/commands/frame/recognizer/recognizer.py

 # encoding: utf-8
 
 import lldb
 
 class MyFrameRecognizer(object):
     def get_recognized_arguments(self, frame):
         if frame.name == "foo":
             arg1 = frame.EvaluateExpression("$arg1").signed
             arg2 = frame.EvaluateExpression("$arg2").signed
-            val1 = lldb.target.CreateValueFromExpression("a", "%d" % arg1)
-            val2 = lldb.target.CreateValueFromExpression("b", "%d" % arg2)
+            val1 = frame.GetThread().GetProcess().GetTarget().CreateValueFromExpression("a", "%d" % arg1)
+            val2 = frame.GetThread().GetProcess().GetTarget().CreateValueFromExpression("b", "%d" % arg2)
             return [val1, val2]
         elif frame.name == "bar":
             arg1 = frame.EvaluateExpression("$arg1").signed
-            val1 = lldb.target.CreateValueFromExpression("a", "(int *)%d" % arg1)
+            val1 = frame.GetThread().GetProcess().GetTarget().CreateValueFromExpression("a", "(int *)%d" % arg1)
             return [val1]
         return []
 
 class MyOtherFrameRecognizer(object):
     def get_recognized_arguments(self, frame):
         return []

lldb/trunk/packages/Python/lldbsuite/test/python_api/sbvalue_const_addrof/main.cpp

 
 ThreadInfo g_thread2 = { 0x2222, "thread2", { 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, (uintptr_t)&main, 0x2006, 0x2007 }, NULL       };
 ThreadInfo g_thread1 = { 0x1111, "thread1", { 0x1000, 0x1001, 0x1002, 0x1003, 0x1004, (uintptr_t)&main, 0x1006, 0x1007 }, &g_thread2 };
 ThreadInfo *g_thread_list_ptr = &g_thread1;
 
 int main (int argc, char const *argv[], char const *envp[])
 {
     printf ("g_thread_list is %p\n", g_thread_list_ptr);
-    return 0; //% v = lldb.target.FindFirstGlobalVariable('g_thread_list_ptr')
+    return 0; //% v = self.dbg.GetSelectedTarget().FindFirstGlobalVariable('g_thread_list_ptr')
     //% v_gla = v.GetChildMemberWithName('regs').GetLoadAddress()
     //% v_aof = v.GetChildMemberWithName('regs').AddressOf().GetValueAsUnsigned(lldb.LLDB_INVALID_ADDRESS)
     //% expr = '(%s)0x%x' % (v.GetType().GetName(), v.GetValueAsUnsigned(0))
     //% e = v.CreateValueFromExpression('e', expr)
     //% e_gla = e.GetChildMemberWithName('regs').GetLoadAddress()
     //% e_aof = e.GetChildMemberWithName('regs').AddressOf().GetValueAsUnsigned(lldb.LLDB_INVALID_ADDRESS)
     //% self.assertTrue(v_gla == e_gla, "GetLoadAddress() differs")
     //% self.assertTrue(v_aof == e_aof, "AddressOf() differs")
 }

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

 
 void ScriptInterpreterPythonImpl::ResetOutputFileHandle(FILE *fh) {}
 
 void ScriptInterpreterPythonImpl::LeaveSession() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
   if (log)
     log->PutCString("ScriptInterpreterPythonImpl::LeaveSession()");
 
+  // Unset the LLDB global variables.
+  PyRun_SimpleString("lldb.debugger = None; lldb.target = None; lldb.process "
+                     "= None; lldb.thread = None; lldb.frame = None");
+
   // checking that we have a valid thread state - since we use our own
   // threading and locking in some (rare) cases during cleanup Python may end
   // up believing we have no thread state and PyImport_AddModule will crash if
   // that is the case - since that seems to only happen when destroying the
   // SBDebugger, we can make do without clearing up stdout and stderr
 
   // rdar://problem/11292882
   // When the current thread state is NULL, PyThreadState_Get() issues a fatal
bool ScriptInterpreterPythonImpl::LoadScriptingModule(
   {
     FileSpec target_file(pathname);
     FileSystem::Instance().Resolve(target_file);
     std::string basename(target_file.GetFilename().GetCString());
 
     StreamString command_stream;
 
     // Before executing Python code, lock the GIL.
-    Locker py_lock(
-        this,
-        Locker::AcquireLock | (init_session ? Locker::InitSession : 0) |
-            (init_session ? Locker::InitGlobals : 0) | Locker::NoSTDIN,
+    Locker py_lock(this,
+                   Locker::AcquireLock |
+                       (init_session ? Locker::InitSession : 0) |
+                       Locker::NoSTDIN,
                    Locker::FreeAcquiredLock |
                        (init_session ? Locker::TearDownSession : 0));
     namespace fs = llvm::sys::fs;
     fs::file_status st;
     std::error_code ec = status(target_file.GetPath(), st);
 
     if (ec || st.type() == fs::file_type::status_error ||
         st.type() == fs::file_type::type_unknown ||
         st.type() == fs::file_type::file_not_found) {
       // if not a valid file of any sort, check if it might be a filename still