contrib/llvm/tools/lldb/include/lldb/Interpreter/ScriptInterpreterPython.h

   1 //===-- ScriptInterpreterPython.h -------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10
  11 #ifndef liblldb_ScriptInterpreterPython_h_
  12 #define liblldb_ScriptInterpreterPython_h_
  13
  14 #ifdef LLDB_DISABLE_PYTHON
  15
  16 // Python is disabled in this build
  17
  18 #else
  19
  20 #include "lldb/lldb-python.h"
  21 #include "lldb/lldb-private.h"
  22 #include "lldb/Core/IOHandler.h"
  23 #include "lldb/Interpreter/ScriptInterpreter.h"
  24 #include "lldb/Interpreter/PythonDataObjects.h"
  25 #include "lldb/Host/Terminal.h"
  26
  27 namespace lldb_private {
  28
  29 class ScriptInterpreterPython :
  30     public ScriptInterpreter,
  31     public IOHandlerDelegateMultiline
  32 {
  33 public:
  34
  35     friend class IOHandlerPythonInterpreter;
  36
  37     ScriptInterpreterPython (CommandInterpreter &interpreter);
  38
  39     ~ScriptInterpreterPython ();
  40
  41     bool
  42     ExecuteOneLine (const char *command,
  43                     CommandReturnObject *result,
  44                     const ExecuteScriptOptions &options = ExecuteScriptOptions());
  45
  46     void
  47     ExecuteInterpreterLoop ();
  48
  49     bool
  50     ExecuteOneLineWithReturn (const char *in_string,
  51                               ScriptInterpreter::ScriptReturnType return_type,
  52                               void *ret_value,
  53                               const ExecuteScriptOptions &options = ExecuteScriptOptions());
  54
  55     lldb_private::Error
  56     ExecuteMultipleLines (const char *in_string,
  57                           const ExecuteScriptOptions &options = ExecuteScriptOptions());
  58
  59     bool
  60     ExportFunctionDefinitionToInterpreter (StringList &function_def);
  61
  62     bool
  63     GenerateTypeScriptFunction (StringList &input, std::string& output, void* name_token = NULL);
  64
  65     bool
  66     GenerateTypeSynthClass (StringList &input, std::string& output, void* name_token = NULL);
  67
  68     bool
  69     GenerateTypeSynthClass (const char* oneliner, std::string& output, void* name_token = NULL);
  70
  71     // use this if the function code is just a one-liner script
  72     bool
  73     GenerateTypeScriptFunction (const char* oneliner, std::string& output, void* name_token = NULL);
  74
  75     virtual bool
  76     GenerateScriptAliasFunction (StringList &input, std::string& output);
  77
  78     lldb::ScriptInterpreterObjectSP
  79     CreateSyntheticScriptedProvider (const char *class_name,
  80                                      lldb::ValueObjectSP valobj);
  81
  82     virtual lldb::ScriptInterpreterObjectSP
  83     OSPlugin_CreatePluginObject (const char *class_name,
  84                                  lldb::ProcessSP process_sp);
  85
  86     virtual lldb::ScriptInterpreterObjectSP
  87     OSPlugin_RegisterInfo (lldb::ScriptInterpreterObjectSP os_plugin_object_sp);
  88
  89     virtual lldb::ScriptInterpreterObjectSP
  90     OSPlugin_ThreadsInfo (lldb::ScriptInterpreterObjectSP os_plugin_object_sp);
  91
  92     virtual lldb::ScriptInterpreterObjectSP
  93     OSPlugin_RegisterContextData (lldb::ScriptInterpreterObjectSP os_plugin_object_sp,
  94                                   lldb::tid_t thread_id);
  95
  96     virtual lldb::ScriptInterpreterObjectSP
  97     OSPlugin_CreateThread (lldb::ScriptInterpreterObjectSP os_plugin_object_sp,
  98                            lldb::tid_t tid,
  99                            lldb::addr_t context);
 100
 101     virtual lldb::ScriptInterpreterObjectSP
 102     LoadPluginModule (const FileSpec& file_spec,
 103                       lldb_private::Error& error);
 104
 105     virtual lldb::ScriptInterpreterObjectSP
 106     GetDynamicSettings (lldb::ScriptInterpreterObjectSP plugin_module_sp,
 107                         Target* target,
 108                         const char* setting_name,
 109                         lldb_private::Error& error);
 110
 111     virtual size_t
 112     CalculateNumChildren (const lldb::ScriptInterpreterObjectSP& implementor);
 113
 114     virtual lldb::ValueObjectSP
 115     GetChildAtIndex (const lldb::ScriptInterpreterObjectSP& implementor, uint32_t idx);
 116
 117     virtual int
 118     GetIndexOfChildWithName (const lldb::ScriptInterpreterObjectSP& implementor, const char* child_name);
 119
 120     virtual bool
 121     UpdateSynthProviderInstance (const lldb::ScriptInterpreterObjectSP& implementor);
 122
 123     virtual bool
 124     MightHaveChildrenSynthProviderInstance (const lldb::ScriptInterpreterObjectSP& implementor);
 125
 126     virtual bool
 127     RunScriptBasedCommand(const char* impl_function,
 128                           const char* args,
 129                           ScriptedCommandSynchronicity synchronicity,
 130                           lldb_private::CommandReturnObject& cmd_retobj,
 131                           Error& error);
 132
 133     bool
 134     GenerateFunction(const char *signature, const StringList &input);
 135
 136     bool
 137     GenerateBreakpointCommandCallbackData (StringList &input, std::string& output);
 138
 139     bool
 140     GenerateWatchpointCommandCallbackData (StringList &input, std::string& output);
 141
 142 //    static size_t
 143 //    GenerateBreakpointOptionsCommandCallback (void *baton,
 144 //                                              InputReader &reader,
 145 //                                              lldb::InputReaderAction notification,
 146 //                                              const char *bytes,
 147 //                                              size_t bytes_len);
 148 //
 149 //    static size_t
 150 //    GenerateWatchpointOptionsCommandCallback (void *baton,
 151 //                                              InputReader &reader,
 152 //                                              lldb::InputReaderAction notification,
 153 //                                              const char *bytes,
 154 //                                              size_t bytes_len);
 155
 156     static bool
 157     BreakpointCallbackFunction (void *baton,
 158                                 StoppointCallbackContext *context,
 159                                 lldb::user_id_t break_id,
 160                                 lldb::user_id_t break_loc_id);
 161
 162     static bool
 163     WatchpointCallbackFunction (void *baton,
 164                                 StoppointCallbackContext *context,
 165                                 lldb::user_id_t watch_id);
 166
 167     virtual bool
 168     GetScriptedSummary (const char *function_name,
 169                         lldb::ValueObjectSP valobj,
 170                         lldb::ScriptInterpreterObjectSP& callee_wrapper_sp,
 171                         std::string& retval);
 172
 173     virtual bool
 174     GetDocumentationForItem (const char* item, std::string& dest);
 175
 176     virtual bool
 177     CheckObjectExists (const char* name)
 178     {
 179         if (!name || !name[0])
 180             return false;
 181         std::string temp;
 182         return GetDocumentationForItem (name,temp);
 183     }
 184
 185     virtual bool
 186     RunScriptFormatKeyword (const char* impl_function,
 187                             Process* process,
 188                             std::string& output,
 189                             Error& error);
 190
 191     virtual bool
 192     RunScriptFormatKeyword (const char* impl_function,
 193                             Thread* thread,
 194                             std::string& output,
 195                             Error& error);
 196
 197     virtual bool
 198     RunScriptFormatKeyword (const char* impl_function,
 199                             Target* target,
 200                             std::string& output,
 201                             Error& error);
 202
 203     virtual bool
 204     RunScriptFormatKeyword (const char* impl_function,
 205                             StackFrame* frame,
 206                             std::string& output,
 207                             Error& error);
 208
 209     virtual bool
 210     LoadScriptingModule (const char* filename,
 211                          bool can_reload,
 212                          bool init_session,
 213                          lldb_private::Error& error,
 214                          lldb::ScriptInterpreterObjectSP* module_sp = nullptr);
 215
 216     virtual lldb::ScriptInterpreterObjectSP
 217     MakeScriptObject (void* object);
 218
 219     virtual std::unique_ptr<ScriptInterpreterLocker>
 220     AcquireInterpreterLock ();
 221
 222     void
 223     CollectDataForBreakpointCommandCallback (BreakpointOptions *bp_options,
 224                                              CommandReturnObject &result);
 225
 226     void
 227     CollectDataForWatchpointCommandCallback (WatchpointOptions *wp_options,
 228                                              CommandReturnObject &result);
 229
 230     /// Set a Python one-liner as the callback for the breakpoint.
 231     void
 232     SetBreakpointCommandCallback (BreakpointOptions *bp_options,
 233                                   const char *oneliner);
 234
 235     /// Set a one-liner as the callback for the watchpoint.
 236     void
 237     SetWatchpointCommandCallback (WatchpointOptions *wp_options,
 238                                   const char *oneliner);
 239
 240     StringList
 241     ReadCommandInputFromUser (FILE *in_file);
 242
 243     virtual void
 244     ResetOutputFileHandle (FILE *new_fh);
 245
 246     static void
 247     InitializePrivate ();
 248
 249     static void
 250     InitializeInterpreter (SWIGInitCallback python_swig_init_callback,
 251                            SWIGBreakpointCallbackFunction swig_breakpoint_callback,
 252                            SWIGWatchpointCallbackFunction swig_watchpoint_callback,
 253                            SWIGPythonTypeScriptCallbackFunction swig_typescript_callback,
 254                            SWIGPythonCreateSyntheticProvider swig_synthetic_script,
 255                            SWIGPythonCalculateNumChildren swig_calc_children,
 256                            SWIGPythonGetChildAtIndex swig_get_child_index,
 257                            SWIGPythonGetIndexOfChildWithName swig_get_index_child,
 258                            SWIGPythonCastPyObjectToSBValue swig_cast_to_sbvalue ,
 259                            SWIGPythonGetValueObjectSPFromSBValue swig_get_valobj_sp_from_sbvalue,
 260                            SWIGPythonUpdateSynthProviderInstance swig_update_provider,
 261                            SWIGPythonMightHaveChildrenSynthProviderInstance swig_mighthavechildren_provider,
 262                            SWIGPythonCallCommand swig_call_command,
 263                            SWIGPythonCallModuleInit swig_call_module_init,
 264                            SWIGPythonCreateOSPlugin swig_create_os_plugin,
 265                            SWIGPythonScriptKeyword_Process swig_run_script_keyword_process,
 266                            SWIGPythonScriptKeyword_Thread swig_run_script_keyword_thread,
 267                            SWIGPythonScriptKeyword_Target swig_run_script_keyword_target,
 268                            SWIGPythonScriptKeyword_Frame swig_run_script_keyword_frame,
 269                            SWIGPython_GetDynamicSetting swig_plugin_get);
 270
 271     const char *
 272     GetDictionaryName ()
 273     {
 274         return m_dictionary_name.c_str();
 275     }
 276
 277
 278     //----------------------------------------------------------------------
 279     // IOHandlerDelegate
 280     //----------------------------------------------------------------------
 281     virtual void
 282     IOHandlerActivated (IOHandler &io_handler);
 283
 284     virtual void
 285     IOHandlerInputComplete (IOHandler &io_handler, std::string &data);
 286
 287 protected:
 288
 289     bool
 290     EnterSession (uint16_t on_entry_flags,
 291                   FILE *in,
 292                   FILE *out,
 293                   FILE *err);
 294
 295     void
 296     LeaveSession ();
 297
 298     void
 299     SaveTerminalState (int fd);
 300
 301     void
 302     RestoreTerminalState ();
 303
 304     class SynchronicityHandler
 305     {
 306     private:
 307         lldb::DebuggerSP             m_debugger_sp;
 308         ScriptedCommandSynchronicity m_synch_wanted;
 309         bool                         m_old_asynch;
 310     public:
 311         SynchronicityHandler(lldb::DebuggerSP,
 312                              ScriptedCommandSynchronicity);
 313         ~SynchronicityHandler();
 314     };
 315
 316     class ScriptInterpreterPythonObject : public ScriptInterpreterObject
 317     {
 318     public:
 319         ScriptInterpreterPythonObject() :
 320         ScriptInterpreterObject()
 321         {}
 322
 323         ScriptInterpreterPythonObject(void* obj) :
 324         ScriptInterpreterObject(obj)
 325         {
 326             Py_XINCREF(m_object);
 327         }
 328
 329         explicit operator bool ()
 330         {
 331             return m_object && m_object != Py_None;
 332         }
 333
 334
 335         virtual
 336         ~ScriptInterpreterPythonObject()
 337         {
 338             Py_XDECREF(m_object);
 339             m_object = NULL;
 340         }
 341         private:
 342             DISALLOW_COPY_AND_ASSIGN (ScriptInterpreterPythonObject);
 343     };
 344 public:
 345         class Locker : public ScriptInterpreterLocker
 346         {
 347         public:
 348
 349         enum OnEntry
 350         {
 351             AcquireLock         = 0x0001,
 352             InitSession         = 0x0002,
 353             InitGlobals         = 0x0004,
 354             NoSTDIN             = 0x0008
 355         };
 356
 357         enum OnLeave
 358         {
 359             FreeLock            = 0x0001,
 360             FreeAcquiredLock    = 0x0002,    // do not free the lock if we already held it when calling constructor
 361             TearDownSession     = 0x0004
 362         };
 363
 364         Locker (ScriptInterpreterPython *py_interpreter = NULL,
 365                 uint16_t on_entry = AcquireLock | InitSession,
 366                 uint16_t on_leave = FreeLock | TearDownSession,
 367                 FILE *in = NULL,
 368                 FILE *out = NULL,
 369                 FILE *err = NULL);
 370
 371         ~Locker ();
 372
 373         private:
 374
 375         bool
 376         DoAcquireLock ();
 377
 378         bool
 379         DoInitSession (uint16_t on_entry_flags, FILE *in, FILE *out, FILE *err);
 380
 381         bool
 382         DoFreeLock ();
 383
 384         bool
 385         DoTearDownSession ();
 386
 387         static void
 388         ReleasePythonLock ();
 389
 390         bool                     m_teardown_session;
 391         ScriptInterpreterPython *m_python_interpreter;
 392 //      FILE*                    m_tmp_fh;
 393         PyGILState_STATE         m_GILState;
 394         };
 395 private:
 396
 397     enum ActiveIOHandler {
 398         eIOHandlerNone,
 399         eIOHandlerBreakpoint,
 400         eIOHandlerWatchpoint
 401     };
 402     PythonObject &
 403     GetMainModule ();
 404
 405     PythonDictionary &
 406     GetSessionDictionary ();
 407
 408     PythonDictionary &
 409     GetSysModuleDictionary ();
 410
 411     bool
 412     GetEmbeddedInterpreterModuleObjects ();
 413
 414     PythonObject m_saved_stdin;
 415     PythonObject m_saved_stdout;
 416     PythonObject m_saved_stderr;
 417     PythonObject m_main_module;
 418     PythonObject m_lldb_module;
 419     PythonDictionary m_session_dict;
 420     PythonDictionary m_sys_module_dict;
 421     PythonObject m_run_one_line_function;
 422     PythonObject m_run_one_line_str_global;
 423     std::string m_dictionary_name;
 424     TerminalState m_terminal_state;
 425     ActiveIOHandler m_active_io_handler;
 426     bool m_session_is_active;
 427     bool m_pty_slave_is_open;
 428     bool m_valid_session;
 429     PyThreadState *m_command_thread_state;
 430 };
 431 } // namespace lldb_private
 432
 433 #endif // #ifdef LLDB_DISABLE_PYTHON
 434
 435 #endif // #ifndef liblldb_ScriptInterpreterPython_h_