gdb/python/python.c

   1 /* General python/gdb code
   2
   3    Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "arch-utils.h"
  22 #include "command.h"
  23 #include "ui-out.h"
  24 #include "cli/cli-script.h"
  25 #include "gdbcmd.h"
  26 #include "objfiles.h"
  27 #include "observer.h"
  28 #include "value.h"
  29 #include "language.h"
  30
  31 #include <ctype.h>
  32
  33 /* True if we should print the stack when catching a Python error,
  34    false otherwise.  */
  35 static int gdbpy_should_print_stack = 1;
  36
  37 /* This is true if we should auto-load python code when an objfile is
  38    opened, false otherwise.  */
  39 static int gdbpy_auto_load = 1;
  40
  41 #ifdef HAVE_PYTHON
  42
  43 #include "python.h"
  44 #include "libiberty.h"
  45 #include "cli/cli-decode.h"
  46 #include "charset.h"
  47 #include "top.h"
  48 #include "exceptions.h"
  49 #include "python-internal.h"
  50 #include "version.h"
  51 #include "target.h"
  52 #include "gdbthread.h"
  53
  54 static PyMethodDef GdbMethods[];
  55
  56 PyObject *gdb_module;
  57
  58 /* Some string constants we may wish to use.  */
  59 PyObject *gdbpy_to_string_cst;
  60 PyObject *gdbpy_children_cst;
  61 PyObject *gdbpy_display_hint_cst;
  62 PyObject *gdbpy_doc_cst;
  63
  64
  65 /* Architecture and language to be used in callbacks from
  66    the Python interpreter.  */
  67 struct gdbarch *python_gdbarch;
  68 const struct language_defn *python_language;
  69
  70 /* Restore global language and architecture and Python GIL state
  71    when leaving the Python interpreter.  */
  72
  73 struct python_env
  74 {
  75   PyGILState_STATE state;
  76   struct gdbarch *gdbarch;
  77   const struct language_defn *language;
  78 };
  79
  80 static void
  81 restore_python_env (void *p)
  82 {
  83   struct python_env *env = (struct python_env *)p;
  84   PyGILState_Release (env->state);
  85   python_gdbarch = env->gdbarch;
  86   python_language = env->language;
  87   xfree (env);
  88 }
  89
  90 /* Called before entering the Python interpreter to install the
  91    current language and architecture to be used for Python values.  */
  92
  93 struct cleanup *
  94 ensure_python_env (struct gdbarch *gdbarch,
  95                    const struct language_defn *language)
  96 {
  97   struct python_env *env = xmalloc (sizeof *env);
  98
  99   env->state = PyGILState_Ensure ();
 100   env->gdbarch = python_gdbarch;
 101   env->language = python_language;
 102
 103   python_gdbarch = gdbarch;
 104   python_language = language;
 105
 106   return make_cleanup (restore_python_env, env);
 107 }
 108
 109
 110 /* Given a command_line, return a command string suitable for passing
 111    to Python.  Lines in the string are separated by newlines.  The
 112    return value is allocated using xmalloc and the caller is
 113    responsible for freeing it.  */
 114
 115 static char *
 116 compute_python_string (struct command_line *l)
 117 {
 118   struct command_line *iter;
 119   char *script = NULL;
 120   int size = 0;
 121   int here;
 122
 123   for (iter = l; iter; iter = iter->next)
 124     size += strlen (iter->line) + 1;
 125
 126   script = xmalloc (size + 1);
 127   here = 0;
 128   for (iter = l; iter; iter = iter->next)
 129     {
 130       int len = strlen (iter->line);
 131       strcpy (&script[here], iter->line);
 132       here += len;
 133       script[here++] = '\n';
 134     }
 135   script[here] = '\0';
 136   return script;
 137 }
 138
 139 /* Take a command line structure representing a 'python' command, and
 140    evaluate its body using the Python interpreter.  */
 141
 142 void
 143 eval_python_from_control_command (struct command_line *cmd)
 144 {
 145   int ret;
 146   char *script;
 147   struct cleanup *cleanup;
 148
 149   if (cmd->body_count != 1)
 150     error (_("Invalid \"python\" block structure."));
 151
 152   cleanup = ensure_python_env (get_current_arch (), current_language);
 153
 154   script = compute_python_string (cmd->body_list[0]);
 155   ret = PyRun_SimpleString (script);
 156   xfree (script);
 157   if (ret)
 158     {
 159       gdbpy_print_stack ();
 160       error (_("Error while executing Python code."));
 161     }
 162
 163   do_cleanups (cleanup);
 164 }
 165
 166 /* Implementation of the gdb "python" command.  */
 167
 168 static void
 169 python_command (char *arg, int from_tty)
 170 {
 171   struct cleanup *cleanup;
 172   cleanup = ensure_python_env (get_current_arch (), current_language);
 173
 174   while (arg && *arg && isspace (*arg))
 175     ++arg;
 176   if (arg && *arg)
 177     {
 178       if (PyRun_SimpleString (arg))
 179         {
 180           gdbpy_print_stack ();
 181           error (_("Error while executing Python code."));
 182         }
 183     }
 184   else
 185     {
 186       struct command_line *l = get_command_line (python_control, "");
 187       make_cleanup_free_command_lines (&l);
 188       execute_control_command_untraced (l);
 189     }
 190
 191   do_cleanups (cleanup);
 192 }
 193
 194 \f
 195
 196 /* Transform a gdb parameters's value into a Python value.  May return
 197    NULL (and set a Python exception) on error.  Helper function for
 198    get_parameter.  */
 199
 200 static PyObject *
 201 parameter_to_python (struct cmd_list_element *cmd)
 202 {
 203   switch (cmd->var_type)
 204     {
 205     case var_string:
 206     case var_string_noescape:
 207     case var_optional_filename:
 208     case var_filename:
 209     case var_enum:
 210       {
 211         char *str = * (char **) cmd->var;
 212         if (! str)
 213           str = "";
 214         return PyString_Decode (str, strlen (str), host_charset (), NULL);
 215       }
 216
 217     case var_boolean:
 218       {
 219         if (* (int *) cmd->var)
 220           Py_RETURN_TRUE;
 221         else
 222           Py_RETURN_FALSE;
 223       }
 224
 225     case var_auto_boolean:
 226       {
 227         enum auto_boolean ab = * (enum auto_boolean *) cmd->var;
 228         if (ab == AUTO_BOOLEAN_TRUE)
 229           Py_RETURN_TRUE;
 230         else if (ab == AUTO_BOOLEAN_FALSE)
 231           Py_RETURN_FALSE;
 232         else
 233           Py_RETURN_NONE;
 234       }
 235
 236     case var_integer:
 237       if ((* (int *) cmd->var) == INT_MAX)
 238         Py_RETURN_NONE;
 239       /* Fall through.  */
 240     case var_zinteger:
 241       return PyLong_FromLong (* (int *) cmd->var);
 242
 243     case var_uinteger:
 244       {
 245         unsigned int val = * (unsigned int *) cmd->var;
 246         if (val == UINT_MAX)
 247           Py_RETURN_NONE;
 248         return PyLong_FromUnsignedLong (val);
 249       }
 250     }
 251
 252   return PyErr_Format (PyExc_RuntimeError, "programmer error: unhandled type");
 253 }
 254
 255 /* A Python function which returns a gdb parameter's value as a Python
 256    value.  */
 257
 258 static PyObject *
 259 gdbpy_parameter (PyObject *self, PyObject *args)
 260 {
 261   struct cmd_list_element *alias, *prefix, *cmd;
 262   char *arg, *newarg;
 263   int found = -1;
 264   volatile struct gdb_exception except;
 265
 266   if (! PyArg_ParseTuple (args, "s", &arg))
 267     return NULL;
 268
 269   newarg = concat ("show ", arg, (char *) NULL);
 270
 271   TRY_CATCH (except, RETURN_MASK_ALL)
 272     {
 273       found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);
 274     }
 275   xfree (newarg);
 276   GDB_PY_HANDLE_EXCEPTION (except);
 277   if (!found)
 278     return PyErr_Format (PyExc_RuntimeError,
 279                          "could not find parameter `%s'", arg);
 280
 281   if (! cmd->var)
 282     return PyErr_Format (PyExc_RuntimeError, "`%s' is not a parameter", arg);
 283   return parameter_to_python (cmd);
 284 }
 285
 286 /* A Python function which evaluates a string using the gdb CLI.  */
 287
 288 static PyObject *
 289 execute_gdb_command (PyObject *self, PyObject *args)
 290 {
 291   struct cmd_list_element *alias, *prefix, *cmd;
 292   char *arg, *newarg;
 293   PyObject *from_tty_obj = NULL;
 294   int from_tty;
 295   int cmp;
 296   volatile struct gdb_exception except;
 297
 298   if (! PyArg_ParseTuple (args, "s|O!", &arg, &PyBool_Type, &from_tty_obj))
 299     return NULL;
 300
 301   from_tty = 0;
 302   if (from_tty_obj)
 303     {
 304       cmp = PyObject_IsTrue (from_tty_obj);
 305       if (cmp < 0)
 306           return NULL;
 307       from_tty = cmp;
 308     }
 309
 310   TRY_CATCH (except, RETURN_MASK_ALL)
 311     {
 312       /* Copy the argument text in case the command modifies it.  */
 313       char *copy = xstrdup (arg);
 314       struct cleanup *cleanup = make_cleanup (xfree, copy);
 315       execute_command (copy, from_tty);
 316       do_cleanups (cleanup);
 317     }
 318   GDB_PY_HANDLE_EXCEPTION (except);
 319
 320   /* Do any commands attached to breakpoint we stopped at.  */
 321   bpstat_do_actions ();
 322
 323   Py_RETURN_NONE;
 324 }
 325
 326 /* Parse a string and evaluate it as an expression.  */
 327 static PyObject *
 328 gdbpy_parse_and_eval (PyObject *self, PyObject *args)
 329 {
 330   char *expr_str;
 331   struct value *result = NULL;
 332   volatile struct gdb_exception except;
 333
 334   if (!PyArg_ParseTuple (args, "s", &expr_str))
 335     return NULL;
 336
 337   TRY_CATCH (except, RETURN_MASK_ALL)
 338     {
 339       result = parse_and_eval (expr_str);
 340     }
 341   GDB_PY_HANDLE_EXCEPTION (except);
 342
 343   return value_to_value_object (result);
 344 }
 345
 346 \f
 347
 348 /* Printing.  */
 349
 350 /* A python function to write a single string using gdb's filtered
 351    output stream.  */
 352 static PyObject *
 353 gdbpy_write (PyObject *self, PyObject *args)
 354 {
 355   char *arg;
 356   if (! PyArg_ParseTuple (args, "s", &arg))
 357     return NULL;
 358   printf_filtered ("%s", arg);
 359   Py_RETURN_NONE;
 360 }
 361
 362 /* A python function to flush gdb's filtered output stream.  */
 363 static PyObject *
 364 gdbpy_flush (PyObject *self, PyObject *args)
 365 {
 366   gdb_flush (gdb_stdout);
 367   Py_RETURN_NONE;
 368 }
 369
 370 /* Print a python exception trace, or print nothing and clear the
 371    python exception, depending on gdbpy_should_print_stack.  Only call
 372    this if a python exception is set.  */
 373 void
 374 gdbpy_print_stack (void)
 375 {
 376   if (gdbpy_should_print_stack)
 377     PyErr_Print ();
 378   else
 379     PyErr_Clear ();
 380 }
 381
 382 \f
 383
 384 /* The "current" objfile.  This is set when gdb detects that a new
 385    objfile has been loaded.  It is only set for the duration of a call
 386    to gdbpy_new_objfile; it is NULL at other times.  */
 387 static struct objfile *gdbpy_current_objfile;
 388
 389 /* The file name we attempt to read.  */
 390 #define GDBPY_AUTO_FILENAME "-gdb.py"
 391
 392 /* This is a new_objfile observer callback which loads python code
 393    based on the path to the objfile.  */
 394 static void
 395 gdbpy_new_objfile (struct objfile *objfile)
 396 {
 397   char *realname;
 398   char *filename, *debugfile;
 399   int len;
 400   FILE *input;
 401   struct cleanup *cleanups;
 402
 403   if (!gdbpy_auto_load || !objfile || !objfile->name)
 404     return;
 405
 406   cleanups = ensure_python_env (get_objfile_arch (objfile), current_language);
 407
 408   gdbpy_current_objfile = objfile;
 409
 410   realname = gdb_realpath (objfile->name);
 411   len = strlen (realname);
 412   filename = xmalloc (len + sizeof (GDBPY_AUTO_FILENAME));
 413   memcpy (filename, realname, len);
 414   strcpy (filename + len, GDBPY_AUTO_FILENAME);
 415
 416   input = fopen (filename, "r");
 417   debugfile = filename;
 418
 419   make_cleanup (xfree, filename);
 420   make_cleanup (xfree, realname);
 421
 422   if (!input && debug_file_directory)
 423     {
 424       /* Also try the same file in the separate debug info directory.  */
 425       debugfile = xmalloc (strlen (filename)
 426                            + strlen (debug_file_directory) + 1);
 427       strcpy (debugfile, debug_file_directory);
 428       /* FILENAME is absolute, so we don't need a "/" here.  */
 429       strcat (debugfile, filename);
 430
 431       make_cleanup (xfree, debugfile);
 432       input = fopen (debugfile, "r");
 433     }
 434
 435   if (!input && gdb_datadir)
 436     {
 437       /* Also try the same file in a subdirectory of gdb's data
 438          directory.  */
 439       debugfile = xmalloc (strlen (gdb_datadir) + strlen (filename)
 440                            + strlen ("/auto-load") + 1);
 441       strcpy (debugfile, gdb_datadir);
 442       strcat (debugfile, "/auto-load");
 443       /* FILENAME is absolute, so we don't need a "/" here.  */
 444       strcat (debugfile, filename);
 445
 446       make_cleanup (xfree, debugfile);
 447       input = fopen (debugfile, "r");
 448     }
 449
 450   if (input)
 451     {
 452       /* We don't want to throw an exception here -- but the user
 453          would like to know that something went wrong.  */
 454       if (PyRun_SimpleFile (input, debugfile))
 455         gdbpy_print_stack ();
 456       fclose (input);
 457     }
 458
 459   do_cleanups (cleanups);
 460   gdbpy_current_objfile = NULL;
 461 }
 462
 463 /* Return the current Objfile, or None if there isn't one.  */
 464 static PyObject *
 465 gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2)
 466 {
 467   PyObject *result;
 468
 469   if (! gdbpy_current_objfile)
 470     Py_RETURN_NONE;
 471
 472   result = objfile_to_objfile_object (gdbpy_current_objfile);
 473   if (result)
 474     Py_INCREF (result);
 475   return result;
 476 }
 477
 478 /* Return a sequence holding all the Objfiles.  */
 479 static PyObject *
 480 gdbpy_objfiles (PyObject *unused1, PyObject *unused2)
 481 {
 482   struct objfile *objf;
 483   PyObject *list;
 484
 485   list = PyList_New (0);
 486   if (!list)
 487     return NULL;
 488
 489   ALL_OBJFILES (objf)
 490   {
 491     PyObject *item = objfile_to_objfile_object (objf);
 492     if (!item || PyList_Append (list, item) == -1)
 493       {
 494         Py_DECREF (list);
 495         return NULL;
 496       }
 497   }
 498
 499   return list;
 500 }
 501
 502 #else /* HAVE_PYTHON */
 503
 504 /* Dummy implementation of the gdb "python" command.  */
 505
 506 static void
 507 python_command (char *arg, int from_tty)
 508 {
 509   while (arg && *arg && isspace (*arg))
 510     ++arg;
 511   if (arg && *arg)
 512     error (_("Python scripting is not supported in this copy of GDB."));
 513   else
 514     {
 515       struct command_line *l = get_command_line (python_control, "");
 516       struct cleanup *cleanups = make_cleanup_free_command_lines (&l);
 517       execute_control_command_untraced (l);
 518       do_cleanups (cleanups);
 519     }
 520 }
 521
 522 void
 523 eval_python_from_control_command (struct command_line *cmd)
 524 {
 525   error (_("Python scripting is not supported in this copy of GDB."));
 526 }
 527
 528 #endif /* HAVE_PYTHON */
 529
 530 \f
 531
 532 /* Lists for 'maint set python' commands.  */
 533
 534 static struct cmd_list_element *set_python_list;
 535 static struct cmd_list_element *show_python_list;
 536
 537 /* Function for use by 'maint set python' prefix command.  */
 538
 539 static void
 540 set_python (char *args, int from_tty)
 541 {
 542   help_list (set_python_list, "maintenance set python ", -1, gdb_stdout);
 543 }
 544
 545 /* Function for use by 'maint show python' prefix command.  */
 546
 547 static void
 548 show_python (char *args, int from_tty)
 549 {
 550   cmd_show_list (show_python_list, from_tty, "");
 551 }
 552
 553 /* Initialize the Python code.  */
 554
 555 /* Provide a prototype to silence -Wmissing-prototypes.  */
 556 extern initialize_file_ftype _initialize_python;
 557
 558 void
 559 _initialize_python (void)
 560 {
 561   add_com ("python", class_obscure, python_command,
 562 #ifdef HAVE_PYTHON
 563            _("\
 564 Evaluate a Python command.\n\
 565 \n\
 566 The command can be given as an argument, for instance:\n\
 567 \n\
 568     python print 23\n\
 569 \n\
 570 If no argument is given, the following lines are read and used\n\
 571 as the Python commands.  Type a line containing \"end\" to indicate\n\
 572 the end of the command.")
 573 #else /* HAVE_PYTHON */
 574            _("\
 575 Evaluate a Python command.\n\
 576 \n\
 577 Python scripting is not supported in this copy of GDB.\n\
 578 This command is only a placeholder.")
 579 #endif /* HAVE_PYTHON */
 580            );
 581
 582   add_prefix_cmd ("python", no_class, show_python,
 583                   _("Prefix command for python maintenance settings."),
 584                   &show_python_list, "maintenance show python ", 0,
 585                   &maintenance_show_cmdlist);
 586   add_prefix_cmd ("python", no_class, set_python,
 587                   _("Prefix command for python maintenance settings."),
 588                   &set_python_list, "maintenance set python ", 0,
 589                   &maintenance_set_cmdlist);
 590
 591   add_setshow_boolean_cmd ("print-stack", class_maintenance,
 592                            &gdbpy_should_print_stack, _("\
 593 Enable or disable printing of Python stack dump on error."), _("\
 594 Show whether Python stack will be printed on error."), _("\
 595 Enables or disables printing of Python stack traces."),
 596                            NULL, NULL,
 597                            &set_python_list,
 598                            &show_python_list);
 599
 600   add_setshow_boolean_cmd ("auto-load", class_maintenance,
 601                            &gdbpy_auto_load, _("\
 602 Enable or disable auto-loading of Python code when an object is opened."), _("\
 603 Show whether Python code will be auto-loaded when an object is opened."), _("\
 604 Enables or disables auto-loading of Python code when an object is opened."),
 605                            NULL, NULL,
 606                            &set_python_list,
 607                            &show_python_list);
 608
 609 #ifdef HAVE_PYTHON
 610   Py_Initialize ();
 611   PyEval_InitThreads ();
 612
 613   gdb_module = Py_InitModule ("gdb", GdbMethods);
 614
 615   /* The casts to (char*) are for python 2.4.  */
 616   PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version);
 617   PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", (char*) host_name);
 618   PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG", (char*) target_name);
 619
 620   gdbpy_initialize_values ();
 621   gdbpy_initialize_frames ();
 622   gdbpy_initialize_commands ();
 623   gdbpy_initialize_functions ();
 624   gdbpy_initialize_types ();
 625   gdbpy_initialize_objfile ();
 626   gdbpy_initialize_lazy_string ();
 627
 628   PyRun_SimpleString ("import gdb");
 629   PyRun_SimpleString ("gdb.pretty_printers = []");
 630
 631   observer_attach_new_objfile (gdbpy_new_objfile);
 632
 633   gdbpy_to_string_cst = PyString_FromString ("to_string");
 634   gdbpy_children_cst = PyString_FromString ("children");
 635   gdbpy_display_hint_cst = PyString_FromString ("display_hint");
 636   gdbpy_doc_cst = PyString_FromString ("__doc__");
 637
 638   /* Create a couple objects which are used for Python's stdout and
 639      stderr.  */
 640   PyRun_SimpleString ("\
 641 import sys\n\
 642 class GdbOutputFile:\n\
 643   def close(self):\n\
 644     # Do nothing.\n\
 645     return None\n\
 646 \n\
 647   def isatty(self):\n\
 648     return False\n\
 649 \n\
 650   def write(self, s):\n\
 651     gdb.write(s)\n\
 652 \n\
 653   def writelines(self, iterable):\n\
 654     for line in iterable:\n\
 655       self.write(line)\n\
 656 \n\
 657   def flush(self):\n\
 658     gdb.flush()\n\
 659 \n\
 660 sys.stderr = GdbOutputFile()\n\
 661 sys.stdout = GdbOutputFile()\n\
 662 ");
 663
 664   /* Release the GIL while gdb runs.  */
 665   PyThreadState_Swap (NULL);
 666   PyEval_ReleaseLock ();
 667
 668 #endif /* HAVE_PYTHON */
 669 }
 670
 671 \f
 672
 673 #if HAVE_PYTHON
 674
 675 static PyMethodDef GdbMethods[] =
 676 {
 677   { "history", gdbpy_history, METH_VARARGS,
 678     "Get a value from history" },
 679   { "execute", execute_gdb_command, METH_VARARGS,
 680     "Execute a gdb command" },
 681   { "parameter", gdbpy_parameter, METH_VARARGS,
 682     "Return a gdb parameter's value" },
 683
 684   { "default_visualizer", gdbpy_default_visualizer, METH_VARARGS,
 685     "Find the default visualizer for a Value." },
 686
 687   { "current_objfile", gdbpy_get_current_objfile, METH_NOARGS,
 688     "Return the current Objfile being loaded, or None." },
 689   { "objfiles", gdbpy_objfiles, METH_NOARGS,
 690     "Return a sequence of all loaded objfiles." },
 691
 692   { "selected_frame", gdbpy_selected_frame, METH_NOARGS,
 693     "selected_frame () -> gdb.Frame.\n\
 694 Return the selected frame object." },
 695   { "frame_stop_reason_string", gdbpy_frame_stop_reason_string, METH_VARARGS,
 696     "stop_reason_string (Integer) -> String.\n\
 697 Return a string explaining unwind stop reason." },
 698
 699   { "lookup_type", (PyCFunction) gdbpy_lookup_type,
 700     METH_VARARGS | METH_KEYWORDS,
 701     "lookup_type (name [, block]) -> type\n\
 702 Return a Type corresponding to the given name." },
 703
 704   { "parse_and_eval", gdbpy_parse_and_eval, METH_VARARGS,
 705     "parse_and_eval (String) -> Value.\n\
 706 Parse String as an expression, evaluate it, and return the result as a Value."
 707   },
 708
 709   { "write", gdbpy_write, METH_VARARGS,
 710     "Write a string using gdb's filtered stream." },
 711   { "flush", gdbpy_flush, METH_NOARGS,
 712     "Flush gdb's filtered stdout stream." },
 713
 714   {NULL, NULL, 0, NULL}
 715 };
 716
 717 #endif /* HAVE_PYTHON */