gdb/python/py-framefilter.c

   1 /* Python frame filters
   2
   3    Copyright (C) 2013 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 "objfiles.h"
  22 #include "symtab.h"
  23 #include "language.h"
  24 #include "exceptions.h"
  25 #include "arch-utils.h"
  26 #include "python.h"
  27 #include "ui-out.h"
  28 #include "valprint.h"
  29 #include "annotate.h"
  30 #include "hashtab.h"
  31 #include "demangle.h"
  32 #include "mi/mi-cmds.h"
  33 #include "python-internal.h"
  34
  35 enum mi_print_types
  36 {
  37   MI_PRINT_ARGS,
  38   MI_PRINT_LOCALS
  39 };
  40
  41 /* Helper  function  to  extract  a  symbol, a  name  and  a  language
  42    definition from a Python object that conforms to the "Symbol Value"
  43    interface.  OBJ  is the Python  object to extract the  values from.
  44    NAME is a  pass-through argument where the name of  the symbol will
  45    be written.  NAME is allocated in  this function, but the caller is
  46    responsible for clean up.  SYM is a pass-through argument where the
  47    symbol will be written.  In the case of the API returning a string,
  48    this will be set to NULL.  LANGUAGE is also a pass-through argument
  49    denoting the language attributed to the Symbol.  In the case of SYM
  50    being  NULL, this  will be  set to  the current  language.  Returns
  51    PY_BT_ERROR on error with the appropriate Python exception set, and
  52    PY_BT_OK on success.  */
  53
  54 static enum py_bt_status
  55 extract_sym (PyObject *obj, char **name, struct symbol **sym,
  56              const struct language_defn **language)
  57 {
  58   PyObject *result = PyObject_CallMethod (obj, "symbol", NULL);
  59
  60   if (result == NULL)
  61     return PY_BT_ERROR;
  62
  63   /* For 'symbol' callback, the function can return a symbol or a
  64      string.  */
  65   if (gdbpy_is_string (result))
  66     {
  67       *name = python_string_to_host_string (result);
  68       Py_DECREF (result);
  69
  70       if (*name == NULL)
  71         return PY_BT_ERROR;
  72       /* If the API returns a string (and not a symbol), then there is
  73         no symbol derived language available and the frame filter has
  74         either overridden the symbol with a string, or supplied a
  75         entirely synthetic symbol/value pairing.  In that case, use
  76         python_language.  */
  77       *language = python_language;
  78       *sym = NULL;
  79     }
  80   else
  81     {
  82       /* This type checks 'result' during the conversion so we
  83          just call it unconditionally and check the return.  */
  84       *sym = symbol_object_to_symbol (result);
  85
  86       Py_DECREF (result);
  87
  88       if (*sym == NULL)
  89         {
  90           PyErr_SetString (PyExc_RuntimeError,
  91                            _("Unexpected value.  Expecting a "
  92                              "gdb.Symbol or a Python string."));
  93           return PY_BT_ERROR;
  94         }
  95
  96       /* Duplicate the symbol name, so the caller has consistency
  97          in garbage collection.  */
  98       *name = xstrdup (SYMBOL_PRINT_NAME (*sym));
  99
 100       /* If a symbol is specified attempt to determine the language
 101          from the symbol.  If mode is not "auto", then the language
 102          has been explicitly set, use that.  */
 103       if (language_mode == language_mode_auto)
 104         *language = language_def (SYMBOL_LANGUAGE (*sym));
 105       else
 106         *language = current_language;
 107     }
 108
 109   return PY_BT_OK;
 110 }
 111
 112 /* Helper function to extract a value from an object that conforms to
 113    the "Symbol Value" interface.  OBJ is the Python object to extract
 114    the value from.  VALUE is a pass-through argument where the value
 115    will be written.  If the object does not have the value attribute,
 116    or provides the Python None for a value, VALUE will be set to NULL
 117    and this function will return as successful.  Returns PY_BT_ERROR
 118    on error with the appropriate Python exception set, and PY_BT_OK on
 119    success.  */
 120
 121 static enum py_bt_status
 122 extract_value (PyObject *obj, struct value **value)
 123 {
 124   if (PyObject_HasAttrString (obj, "value"))
 125     {
 126       PyObject *vresult = PyObject_CallMethod (obj, "value", NULL);
 127
 128       if (vresult == NULL)
 129         return PY_BT_ERROR;
 130
 131       /* The Python code has returned 'None' for a value, so we set
 132          value to NULL.  This flags that GDB should read the
 133          value.  */
 134       if (vresult == Py_None)
 135         {
 136           Py_DECREF (vresult);
 137           *value = NULL;
 138           return PY_BT_OK;
 139         }
 140       else
 141         {
 142           *value = convert_value_from_python (vresult);
 143           Py_DECREF (vresult);
 144
 145           if (*value == NULL)
 146             return PY_BT_ERROR;
 147
 148           return PY_BT_OK;
 149         }
 150     }
 151   else
 152     *value = NULL;
 153
 154   return PY_BT_OK;
 155 }
 156
 157 /* MI prints only certain values according to the type of symbol and
 158    also what the user has specified.  SYM is the symbol to check, and
 159    MI_PRINT_TYPES is an enum specifying what the user wants emitted
 160    for the MI command in question.  */
 161 static int
 162 mi_should_print (struct symbol *sym, enum mi_print_types type)
 163 {
 164   int print_me = 0;
 165
 166   switch (SYMBOL_CLASS (sym))
 167     {
 168     default:
 169     case LOC_UNDEF:     /* catches errors        */
 170     case LOC_CONST:     /* constant              */
 171     case LOC_TYPEDEF:   /* local typedef         */
 172     case LOC_LABEL:     /* local label           */
 173     case LOC_BLOCK:     /* local function        */
 174     case LOC_CONST_BYTES:       /* loc. byte seq.        */
 175     case LOC_UNRESOLVED:        /* unresolved static     */
 176     case LOC_OPTIMIZED_OUT:     /* optimized out         */
 177       print_me = 0;
 178       break;
 179
 180     case LOC_ARG:       /* argument              */
 181     case LOC_REF_ARG:   /* reference arg         */
 182     case LOC_REGPARM_ADDR:      /* indirect register arg */
 183     case LOC_LOCAL:     /* stack local           */
 184     case LOC_STATIC:    /* static                */
 185     case LOC_REGISTER:  /* register              */
 186     case LOC_COMPUTED:  /* computed location     */
 187       if (type == MI_PRINT_LOCALS)
 188         print_me = ! SYMBOL_IS_ARGUMENT (sym);
 189       else
 190         print_me = SYMBOL_IS_ARGUMENT (sym);
 191     }
 192   return print_me;
 193 }
 194
 195 /* Helper function which outputs a type name extracted from VAL to a
 196    "type" field in the output stream OUT.  OUT is the ui-out structure
 197    the type name will be output too, and VAL is the value that the
 198    type will be extracted from.  Returns PY_BT_ERROR on error, with
 199    any GDB exceptions converted to a Python exception, or PY_BT_OK on
 200    success.  */
 201
 202 static enum py_bt_status
 203 py_print_type (struct ui_out *out, struct value *val)
 204 {
 205   volatile struct gdb_exception except;
 206
 207   TRY_CATCH (except, RETURN_MASK_ALL)
 208     {
 209       struct type *type;
 210       struct ui_file *stb;
 211       struct cleanup *cleanup;
 212
 213       stb = mem_fileopen ();
 214       cleanup = make_cleanup_ui_file_delete (stb);
 215       type = check_typedef (value_type (val));
 216       type_print (value_type (val), "", stb, -1);
 217       ui_out_field_stream (out, "type", stb);
 218       do_cleanups (cleanup);
 219     }
 220   if (except.reason < 0)
 221     {
 222       gdbpy_convert_exception (except);
 223       return PY_BT_ERROR;
 224     }
 225
 226   return PY_BT_OK;
 227 }
 228
 229 /* Helper function which outputs a value to an output field in a
 230    stream.  OUT is the ui-out structure the value will be output to,
 231    VAL is the value that will be printed, OPTS contains the value
 232    printing options, ARGS_TYPE is an enumerator describing the
 233    argument format, and LANGUAGE is the language_defn that the value
 234    will be printed with.  Returns PY_BT_ERROR on error, with any GDB
 235    exceptions converted to a Python exception, or PY_BT_OK on
 236    success. */
 237
 238 static enum py_bt_status
 239 py_print_value (struct ui_out *out, struct value *val,
 240                 const struct value_print_options *opts,
 241                 int indent,
 242                 enum py_frame_args args_type,
 243                 const struct language_defn *language)
 244 {
 245   int should_print = 0;
 246   volatile struct gdb_exception except;
 247   int local_indent = (4 * indent);
 248
 249   /* Never set an indent level for common_val_print if MI.  */
 250   if (ui_out_is_mi_like_p (out))
 251     local_indent = 0;
 252
 253   /* MI does not print certain values, differentiated by type,
 254      depending on what ARGS_TYPE indicates.  Test type against option.
 255      For CLI print all values.  */
 256   if (args_type == MI_PRINT_SIMPLE_VALUES
 257       || args_type == MI_PRINT_ALL_VALUES)
 258     {
 259       struct type *type = NULL;
 260
 261       TRY_CATCH (except, RETURN_MASK_ALL)
 262         {
 263           type = check_typedef (value_type (val));
 264         }
 265       if (except.reason < 0)
 266         {
 267           gdbpy_convert_exception (except);
 268           return PY_BT_ERROR;
 269         }
 270
 271       if (args_type == MI_PRINT_ALL_VALUES)
 272         should_print = 1;
 273       else if (args_type == MI_PRINT_SIMPLE_VALUES
 274                && TYPE_CODE (type) != TYPE_CODE_ARRAY
 275                && TYPE_CODE (type) != TYPE_CODE_STRUCT
 276                && TYPE_CODE (type) != TYPE_CODE_UNION)
 277         should_print = 1;
 278     }
 279   else if (args_type != NO_VALUES)
 280     should_print = 1;
 281
 282   if (should_print)
 283     {
 284       TRY_CATCH (except, RETURN_MASK_ALL)
 285         {
 286           struct ui_file *stb;
 287           struct cleanup *cleanup;
 288
 289           stb = mem_fileopen ();
 290           cleanup = make_cleanup_ui_file_delete (stb);
 291           common_val_print (val, stb, indent, opts, language);
 292           ui_out_field_stream (out, "value", stb);
 293           do_cleanups (cleanup);
 294         }
 295       if (except.reason < 0)
 296         {
 297           gdbpy_convert_exception (except);
 298           return PY_BT_ERROR;
 299         }
 300     }
 301
 302   return PY_BT_OK;
 303 }
 304
 305 /* Helper function to call a Python method and extract an iterator
 306    from the result.  If the function returns anything but an iterator
 307    the exception is preserved and NULL is returned.  FILTER is the
 308    Python object to call, and FUNC is the name of the method.  Returns
 309    a PyObject, or NULL on error with the appropriate exception set.
 310    This function can return an iterator, or NULL.  */
 311
 312 static PyObject *
 313 get_py_iter_from_func (PyObject *filter, char *func)
 314 {
 315   if (PyObject_HasAttrString (filter, func))
 316     {
 317       PyObject *result = PyObject_CallMethod (filter, func, NULL);
 318
 319       if (result != NULL)
 320         {
 321           if (result == Py_None)
 322             {
 323               return result;
 324             }
 325           else
 326             {
 327               PyObject *iterator = PyObject_GetIter (result);
 328
 329               Py_DECREF (result);
 330               return iterator;
 331             }
 332         }
 333     }
 334   else
 335     Py_RETURN_NONE;
 336
 337   return NULL;
 338 }
 339
 340 /*  Helper function to output a single frame argument and value to an
 341     output stream.  This function will account for entry values if the
 342     FV parameter is populated, the frame argument has entry values
 343     associated with them, and the appropriate "set entry-value"
 344     options are set.  Will output in CLI or MI like format depending
 345     on the type of output stream detected.  OUT is the output stream,
 346     SYM_NAME is the name of the symbol.  If SYM_NAME is populated then
 347     it must have an accompanying value in the parameter FV.  FA is a
 348     frame argument structure.  If FA is populated, both SYM_NAME and
 349     FV are ignored.  OPTS contains the value printing options,
 350     ARGS_TYPE is an enumerator describing the argument format,
 351     PRINT_ARGS_FIELD is a flag which indicates if we output "ARGS=1"
 352     in MI output in commands where both arguments and locals are
 353     printed.  Returns PY_BT_ERROR on error, with any GDB exceptions
 354     converted to a Python exception, or PY_BT_OK on success.  */
 355
 356 static enum py_bt_status
 357 py_print_single_arg (struct ui_out *out,
 358                      const char *sym_name,
 359                      struct frame_arg *fa,
 360                      struct value *fv,
 361                      const struct value_print_options *opts,
 362                      enum py_frame_args args_type,
 363                      int print_args_field,
 364                      const struct language_defn *language)
 365 {
 366   struct value *val;
 367   volatile struct gdb_exception except;
 368
 369   if (fa != NULL)
 370     {
 371       language = language_def (SYMBOL_LANGUAGE (fa->sym));
 372       val = fa->val;
 373     }
 374   else
 375     val = fv;
 376
 377   TRY_CATCH (except, RETURN_MASK_ALL)
 378     {
 379       struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
 380
 381       /*  MI has varying rules for tuples, but generally if there is only
 382       one element in each item in the list, do not start a tuple.  The
 383       exception is -stack-list-variables which emits an ARGS="1" field
 384       if the value is a frame argument.  This is denoted in this
 385       function with PRINT_ARGS_FIELD which is flag from the caller to
 386       emit the ARGS field.  */
 387       if (ui_out_is_mi_like_p (out))
 388         {
 389           if (print_args_field || args_type != NO_VALUES)
 390             make_cleanup_ui_out_tuple_begin_end (out, NULL);
 391         }
 392
 393       annotate_arg_begin ();
 394
 395       /* If frame argument is populated, check for entry-values and the
 396          entry value options.  */
 397       if (fa != NULL)
 398         {
 399           struct ui_file *stb;
 400
 401           stb = mem_fileopen ();
 402           make_cleanup_ui_file_delete (stb);
 403           fprintf_symbol_filtered (stb, SYMBOL_PRINT_NAME (fa->sym),
 404                                    SYMBOL_LANGUAGE (fa->sym),
 405                                    DMGL_PARAMS | DMGL_ANSI);
 406           if (fa->entry_kind == print_entry_values_compact)
 407             {
 408               fputs_filtered ("=", stb);
 409
 410               fprintf_symbol_filtered (stb, SYMBOL_PRINT_NAME (fa->sym),
 411                                        SYMBOL_LANGUAGE (fa->sym),
 412                                        DMGL_PARAMS | DMGL_ANSI);
 413             }
 414           if (fa->entry_kind == print_entry_values_only
 415               || fa->entry_kind == print_entry_values_compact)
 416             {
 417               fputs_filtered ("@entry", stb);
 418             }
 419           ui_out_field_stream (out, "name", stb);
 420         }
 421       else
 422         /* Otherwise, just output the name.  */
 423         ui_out_field_string (out, "name", sym_name);
 424
 425       annotate_arg_name_end ();
 426
 427       if (! ui_out_is_mi_like_p (out))
 428         ui_out_text (out, "=");
 429
 430       if (print_args_field)
 431         ui_out_field_int (out, "arg", 1);
 432
 433       /* For MI print the type, but only for simple values.  This seems
 434          weird, but this is how MI choose to format the various output
 435          types.  */
 436       if (args_type == MI_PRINT_SIMPLE_VALUES)
 437         {
 438           if (py_print_type (out, val) == PY_BT_ERROR)
 439             {
 440               do_cleanups (cleanups);
 441               goto error;
 442             }
 443         }
 444
 445       annotate_arg_value (value_type (val));
 446
 447       /* If the output is to the CLI, and the user option "set print
 448          frame-arguments" is set to none, just output "...".  */
 449       if (! ui_out_is_mi_like_p (out) && args_type == NO_VALUES)
 450         ui_out_field_string (out, "value", "...");
 451       else
 452         {
 453           /* Otherwise, print the value for both MI and the CLI, except
 454              for the case of MI_PRINT_NO_VALUES.  */
 455           if (args_type != NO_VALUES)
 456             {
 457               if (py_print_value (out, val, opts, 0, args_type, language)
 458                   == PY_BT_ERROR)
 459                 {
 460                   do_cleanups (cleanups);
 461                   goto error;
 462                 }
 463             }
 464         }
 465
 466       do_cleanups (cleanups);
 467     }
 468   if (except.reason < 0)
 469     {
 470       gdbpy_convert_exception (except);
 471       goto error;
 472     }
 473
 474   return PY_BT_OK;
 475
 476  error:
 477   return PY_BT_ERROR;
 478 }
 479
 480 /* Helper function to loop over frame arguments provided by the
 481    "frame_arguments" Python API.  Elements in the iterator must
 482    conform to the "Symbol Value" interface.  ITER is the Python
 483    iterable object, OUT is the output stream, ARGS_TYPE is an
 484    enumerator describing the argument format, PRINT_ARGS_FIELD is a
 485    flag which indicates if we output "ARGS=1" in MI output in commands
 486    where both arguments and locals are printed, and FRAME is the
 487    backing frame.  Returns PY_BT_ERROR on error, with any GDB
 488    exceptions converted to a Python exception, or PY_BT_OK on
 489    success.  */
 490
 491 static enum py_bt_status
 492 enumerate_args (PyObject *iter,
 493                 struct ui_out *out,
 494                 enum py_frame_args args_type,
 495                 int print_args_field,
 496                 struct frame_info *frame)
 497 {
 498   PyObject *item;
 499   struct value_print_options opts;
 500   volatile struct gdb_exception except;
 501
 502   get_user_print_options (&opts);
 503
 504   if (args_type == CLI_SCALAR_VALUES)
 505     {
 506       /* True in "summary" mode, false otherwise.  */
 507       opts.summary = 1;
 508     }
 509
 510   opts.deref_ref = 1;
 511
 512   TRY_CATCH (except, RETURN_MASK_ALL)
 513     {
 514       annotate_frame_args ();
 515     }
 516   if (except.reason < 0)
 517     {
 518       gdbpy_convert_exception (except);
 519       goto error;
 520     }
 521
 522   /*  Collect the first argument outside of the loop, so output of
 523       commas in the argument output is correct.  At the end of the
 524       loop block collect another item from the iterator, and, if it is
 525       not null emit a comma.  */
 526   item = PyIter_Next (iter);
 527   if (item == NULL && PyErr_Occurred ())
 528     goto error;
 529
 530   while (item)
 531     {
 532       const struct language_defn *language;
 533       char *sym_name;
 534       struct symbol *sym;
 535       struct value *val;
 536       enum py_bt_status success = PY_BT_ERROR;
 537
 538       success = extract_sym (item, &sym_name, &sym, &language);
 539       if (success == PY_BT_ERROR)
 540         {
 541           Py_DECREF (item);
 542           goto error;
 543         }
 544
 545       success = extract_value (item, &val);
 546       if (success == PY_BT_ERROR)
 547         {
 548           xfree (sym_name);
 549           Py_DECREF (item);
 550           goto error;
 551         }
 552
 553       Py_DECREF (item);
 554       item = NULL;
 555
 556       if (sym && ui_out_is_mi_like_p (out)
 557           && ! mi_should_print (sym, MI_PRINT_ARGS))
 558         {
 559           xfree (sym_name);
 560           continue;
 561         }
 562
 563       /* If the object did not provide a value, read it using
 564          read_frame_args and account for entry values, if any.  */
 565       if (val == NULL)
 566         {
 567           struct frame_arg arg, entryarg;
 568
 569           /* If there is no value, and also no symbol, set error and
 570              exit.  */
 571           if (sym == NULL)
 572             {
 573               PyErr_SetString (PyExc_RuntimeError,
 574                                _("No symbol or value provided."));
 575               xfree (sym_name);
 576               goto error;
 577             }
 578
 579           TRY_CATCH (except, RETURN_MASK_ALL)
 580             {
 581               read_frame_arg (sym, frame, &arg, &entryarg);
 582             }
 583           if (except.reason < 0)
 584             {
 585               xfree (sym_name);
 586               gdbpy_convert_exception (except);
 587               goto error;
 588             }
 589
 590           /* The object has not provided a value, so this is a frame
 591              argument to be read by GDB.  In this case we have to
 592              account for entry-values.  */
 593
 594           if (arg.entry_kind != print_entry_values_only)
 595             {
 596               if (py_print_single_arg (out, NULL, &arg,
 597                                        NULL, &opts,
 598                                        args_type,
 599                                        print_args_field,
 600                                        NULL) == PY_BT_ERROR)
 601                 {
 602                   xfree (arg.error);
 603                   xfree (entryarg.error);
 604                   xfree (sym_name);
 605                   goto error;
 606                 }
 607             }
 608
 609           if (entryarg.entry_kind != print_entry_values_no)
 610             {
 611               if (arg.entry_kind != print_entry_values_only)
 612                 {
 613                   TRY_CATCH (except, RETURN_MASK_ALL)
 614                     {
 615                       ui_out_text (out, ", ");
 616                       ui_out_wrap_hint (out, "    ");
 617                     }
 618                   if (except.reason < 0)
 619                     {
 620                       xfree (arg.error);
 621                       xfree (entryarg.error);
 622                       xfree (sym_name);
 623                       gdbpy_convert_exception (except);
 624                       goto error;
 625                     }
 626                 }
 627
 628               if (py_print_single_arg (out, NULL, &entryarg, NULL,
 629                                       &opts, args_type,
 630                                       print_args_field, NULL) == PY_BT_ERROR)
 631                 {
 632                       xfree (arg.error);
 633                       xfree (entryarg.error);
 634                       xfree (sym_name);
 635                       goto error;
 636                 }
 637             }
 638
 639           xfree (arg.error);
 640           xfree (entryarg.error);
 641         }
 642       else
 643         {
 644           /* If the object has provided a value, we just print that.  */
 645           if (val != NULL)
 646             {
 647               if (py_print_single_arg (out, sym_name, NULL, val, &opts,
 648                                        args_type, print_args_field,
 649                                        language) == PY_BT_ERROR)
 650                 {
 651                   xfree (sym_name);
 652                   goto error;
 653                 }
 654             }
 655         }
 656
 657       xfree (sym_name);
 658
 659       /* Collect the next item from the iterator.  If
 660          this is the last item, do not print the
 661          comma.  */
 662       item = PyIter_Next (iter);
 663       if (item != NULL)
 664         {
 665           TRY_CATCH (except, RETURN_MASK_ALL)
 666             {
 667               ui_out_text (out, ", ");
 668             }
 669           if (except.reason < 0)
 670             {
 671               Py_DECREF (item);
 672               gdbpy_convert_exception (except);
 673               goto error;
 674             }
 675         }
 676       else if (PyErr_Occurred ())
 677         goto error;
 678
 679       TRY_CATCH (except, RETURN_MASK_ALL)
 680         {
 681           annotate_arg_end ();
 682         }
 683       if (except.reason < 0)
 684         {
 685           Py_DECREF (item);
 686           gdbpy_convert_exception (except);
 687           goto error;
 688         }
 689     }
 690
 691   return PY_BT_OK;
 692
 693  error:
 694   return PY_BT_ERROR;
 695 }
 696
 697
 698 /* Helper function to loop over variables provided by the
 699    "frame_locals" Python API.  Elements in the iterable must conform
 700    to the "Symbol Value" interface.  ITER is the Python iterable
 701    object, OUT is the output stream, INDENT is whether we should
 702    indent the output (for CLI), ARGS_TYPE is an enumerator describing
 703    the argument format, PRINT_ARGS_FIELD is flag which indicates
 704    whether to output the ARGS field in the case of
 705    -stack-list-variables and FRAME is the backing frame.  Returns
 706    PY_BT_ERROR on error, with any GDB exceptions converted to a Python
 707    exception, or PY_BT_OK on success.  */
 708
 709 static enum py_bt_status
 710 enumerate_locals (PyObject *iter,
 711                   struct ui_out *out,
 712                   int indent,
 713                   enum py_frame_args args_type,
 714                   int print_args_field,
 715                   struct frame_info *frame)
 716 {
 717   PyObject *item;
 718   struct value_print_options opts;
 719
 720   get_user_print_options (&opts);
 721   opts.deref_ref = 1;
 722
 723   while ((item = PyIter_Next (iter)))
 724     {
 725       const struct language_defn *language;
 726       char *sym_name;
 727       struct value *val;
 728       enum py_bt_status  success = PY_BT_ERROR;
 729       struct symbol *sym;
 730       volatile struct gdb_exception except;
 731       int local_indent = 8 + (8 * indent);
 732       struct cleanup *locals_cleanups;
 733
 734       locals_cleanups = make_cleanup_py_decref (item);
 735
 736       success = extract_sym (item, &sym_name, &sym, &language);
 737       if (success == PY_BT_ERROR)
 738         {
 739           do_cleanups (locals_cleanups);
 740           goto error;
 741         }
 742
 743       make_cleanup (xfree, sym_name);
 744
 745       success = extract_value (item, &val);
 746       if (success == PY_BT_ERROR)
 747         {
 748           do_cleanups (locals_cleanups);
 749           goto error;
 750         }
 751
 752       if (sym != NULL && ui_out_is_mi_like_p (out)
 753           && ! mi_should_print (sym, MI_PRINT_LOCALS))
 754         {
 755           do_cleanups (locals_cleanups);
 756           continue;
 757         }
 758
 759       /* If the object did not provide a value, read it.  */
 760       if (val == NULL)
 761         {
 762           TRY_CATCH (except, RETURN_MASK_ALL)
 763             {
 764               val = read_var_value (sym, frame);
 765             }
 766           if (except.reason < 0)
 767             {
 768               gdbpy_convert_exception (except);
 769               do_cleanups (locals_cleanups);
 770               goto error;
 771             }
 772         }
 773
 774       /* With PRINT_NO_VALUES, MI does not emit a tuple normally as
 775          each output contains only one field.  The exception is
 776          -stack-list-variables, which always provides a tuple.  */
 777       if (ui_out_is_mi_like_p (out))
 778         {
 779           if (print_args_field || args_type != NO_VALUES)
 780             make_cleanup_ui_out_tuple_begin_end (out, NULL);
 781         }
 782       TRY_CATCH (except, RETURN_MASK_ALL)
 783         {
 784           if (! ui_out_is_mi_like_p (out))
 785             {
 786               /* If the output is not MI we indent locals.  */
 787               ui_out_spaces (out, local_indent);
 788             }
 789
 790           ui_out_field_string (out, "name", sym_name);
 791
 792           if (! ui_out_is_mi_like_p (out))
 793             ui_out_text (out, " = ");
 794         }
 795       if (except.reason < 0)
 796         {
 797           gdbpy_convert_exception (except);
 798           do_cleanups (locals_cleanups);
 799           goto error;
 800         }
 801
 802       if (args_type == MI_PRINT_SIMPLE_VALUES)
 803         {
 804           if (py_print_type (out, val) == PY_BT_ERROR)
 805             {
 806               do_cleanups (locals_cleanups);
 807               goto error;
 808             }
 809         }
 810
 811       /* CLI always prints values for locals.  MI uses the
 812          simple/no/all system.  */
 813       if (! ui_out_is_mi_like_p (out))
 814         {
 815           int val_indent = (indent + 1) * 4;
 816
 817           if (py_print_value (out, val, &opts, val_indent, args_type,
 818                               language) ==  PY_BT_ERROR)
 819             {
 820               do_cleanups (locals_cleanups);
 821               goto error;
 822             }
 823         }
 824       else
 825         {
 826           if (args_type != NO_VALUES)
 827             {
 828               if (py_print_value (out, val, &opts, 0, args_type,
 829                                   language) ==  PY_BT_ERROR)
 830                 {
 831                   do_cleanups (locals_cleanups);
 832                   goto error;
 833                 }
 834             }
 835         }
 836
 837       do_cleanups (locals_cleanups);
 838
 839       TRY_CATCH (except, RETURN_MASK_ALL)
 840         {
 841           ui_out_text (out, "\n");
 842         }
 843       if (except.reason < 0)
 844         {
 845           gdbpy_convert_exception (except);
 846           goto error;
 847         }
 848     }
 849
 850   if (item == NULL && PyErr_Occurred ())
 851     goto error;
 852
 853   return PY_BT_OK;
 854
 855  error:
 856   return PY_BT_ERROR;
 857 }
 858
 859 /*  Helper function for -stack-list-variables.  Returns PY_BT_ERROR on
 860     error, or PY_BT_OK on success.  */
 861
 862 static enum py_bt_status
 863 py_mi_print_variables (PyObject *filter, struct ui_out *out,
 864                        struct value_print_options *opts,
 865                        enum py_frame_args args_type,
 866                        struct frame_info *frame)
 867 {
 868   struct cleanup *old_chain;
 869   PyObject *args_iter;
 870   PyObject *locals_iter;
 871
 872   args_iter = get_py_iter_from_func (filter, "frame_args");
 873   old_chain = make_cleanup_py_xdecref (args_iter);
 874   if (args_iter == NULL)
 875     goto error;
 876
 877   locals_iter = get_py_iter_from_func (filter, "frame_locals");
 878   if (locals_iter == NULL)
 879     goto error;
 880
 881   make_cleanup_py_decref (locals_iter);
 882   make_cleanup_ui_out_list_begin_end (out, "variables");
 883
 884   if (args_iter != Py_None)
 885     if (enumerate_args (args_iter, out, args_type, 1, frame) == PY_BT_ERROR)
 886       goto error;
 887
 888   if (locals_iter != Py_None)
 889     if (enumerate_locals (locals_iter, out, 1, args_type, 1, frame)
 890         == PY_BT_ERROR)
 891       goto error;
 892
 893   do_cleanups (old_chain);
 894   return PY_BT_OK;
 895
 896  error:
 897   do_cleanups (old_chain);
 898   return PY_BT_ERROR;
 899 }
 900
 901 /* Helper function for printing locals.  This function largely just
 902    creates the wrapping tuple, and calls enumerate_locals.  Returns
 903    PY_BT_ERROR on error, or PY_BT_OK on success.*/
 904
 905 static enum py_bt_status
 906 py_print_locals (PyObject *filter,
 907                  struct ui_out *out,
 908                  enum py_frame_args args_type,
 909                  int indent,
 910                  struct frame_info *frame)
 911 {
 912   PyObject *locals_iter = get_py_iter_from_func (filter,
 913                                                  "frame_locals");
 914   struct cleanup *old_chain = make_cleanup_py_xdecref (locals_iter);
 915
 916   if (locals_iter == NULL)
 917     goto locals_error;
 918
 919   make_cleanup_ui_out_list_begin_end (out, "locals");
 920
 921   if (locals_iter != Py_None)
 922     if (enumerate_locals (locals_iter, out, indent, args_type,
 923                           0, frame) == PY_BT_ERROR)
 924       goto locals_error;
 925
 926   do_cleanups (old_chain);
 927   return PY_BT_OK;;
 928
 929  locals_error:
 930   do_cleanups (old_chain);
 931   return PY_BT_ERROR;
 932 }
 933
 934 /* Helper function for printing frame arguments.  This function
 935    largely just creates the wrapping tuple, and calls enumerate_args.
 936    Returns PY_BT_ERROR on error, with any GDB exceptions converted to
 937    a Python exception, or PY_BT_OK on success.  */
 938
 939 static enum py_bt_status
 940 py_print_args (PyObject *filter,
 941                struct ui_out *out,
 942                enum py_frame_args args_type,
 943                struct frame_info *frame)
 944 {
 945   PyObject *args_iter  = get_py_iter_from_func (filter, "frame_args");
 946   struct cleanup *old_chain = make_cleanup_py_xdecref (args_iter);
 947   volatile struct gdb_exception except;
 948
 949   if (args_iter == NULL)
 950     goto args_error;
 951
 952   make_cleanup_ui_out_list_begin_end (out, "args");
 953
 954   TRY_CATCH (except, RETURN_MASK_ALL)
 955     {
 956       annotate_frame_args ();
 957       if (! ui_out_is_mi_like_p (out))
 958         ui_out_text (out, " (");
 959     }
 960   if (except.reason < 0)
 961     {
 962       gdbpy_convert_exception (except);
 963       goto args_error;
 964     }
 965
 966   if (args_iter != Py_None)
 967     if (enumerate_args (args_iter, out, args_type, 0, frame) == PY_BT_ERROR)
 968       goto args_error;
 969
 970   TRY_CATCH (except, RETURN_MASK_ALL)
 971     {
 972       if (! ui_out_is_mi_like_p (out))
 973         ui_out_text (out, ")");
 974     }
 975   if (except.reason < 0)
 976     {
 977       gdbpy_convert_exception (except);
 978       goto args_error;
 979     }
 980
 981   do_cleanups (old_chain);
 982   return PY_BT_OK;
 983
 984  args_error:
 985   do_cleanups (old_chain);
 986   return PY_BT_ERROR;
 987 }
 988
 989 /*  Print a single frame to the designated output stream, detecting
 990     whether the output is MI or console, and formatting the output
 991     according to the conventions of that protocol.  FILTER is the
 992     frame-filter associated with this frame.  FLAGS is an integer
 993     describing the various print options.  The FLAGS variables is
 994     described in "apply_frame_filter" function.  ARGS_TYPE is an
 995     enumerator describing the argument format.  OUT is the output
 996     stream to print, INDENT is the level of indention for this frame
 997     (in the case of elided frames), and LEVELS_PRINTED is a hash-table
 998     containing all the frames level that have already been printed.
 999     If a frame level has been printed, do not print it again (in the
1000     case of elided frames).  Returns PY_BT_ERROR on error, with any
1001     GDB exceptions converted to a Python exception, or PY_BT_COMPLETED
1002     on success.  */
1003
1004 static enum py_bt_status
1005 py_print_frame (PyObject *filter, int flags, enum py_frame_args args_type,
1006                 struct ui_out *out, int indent, htab_t levels_printed)
1007 {
1008   int has_addr = 0;
1009   CORE_ADDR address = 0;
1010   struct gdbarch *gdbarch = NULL;
1011   struct frame_info *frame = NULL;
1012   struct cleanup *cleanup_stack = make_cleanup (null_cleanup, NULL);
1013   struct value_print_options opts;
1014   PyObject *py_inf_frame, *elided;
1015   int print_level, print_frame_info, print_args, print_locals;
1016   volatile struct gdb_exception except;
1017
1018   /* Extract print settings from FLAGS.  */
1019   print_level = (flags & PRINT_LEVEL) ? 1 : 0;
1020   print_frame_info = (flags & PRINT_FRAME_INFO) ? 1 : 0;
1021   print_args = (flags & PRINT_ARGS) ? 1 : 0;
1022   print_locals = (flags & PRINT_LOCALS) ? 1 : 0;
1023
1024   get_user_print_options (&opts);
1025
1026   /* Get the underlying frame.  This is needed to determine GDB
1027   architecture, and also, in the cases of frame variables/arguments to
1028   read them if they returned filter object requires us to do so.  */
1029   py_inf_frame = PyObject_CallMethod (filter, "inferior_frame", NULL);
1030   if (py_inf_frame == NULL)
1031     goto error;
1032
1033   frame = frame_object_to_frame_info (py_inf_frame);;
1034
1035   Py_DECREF (py_inf_frame);
1036
1037   if (frame == NULL)
1038     goto error;
1039
1040   TRY_CATCH (except, RETURN_MASK_ALL)
1041     {
1042       gdbarch = get_frame_arch (frame);
1043     }
1044   if (except.reason < 0)
1045     {
1046       gdbpy_convert_exception (except);
1047       goto error;
1048     }
1049
1050
1051   /* stack-list-variables.  */
1052   if (print_locals && print_args && ! print_frame_info)
1053     {
1054       if (py_mi_print_variables (filter, out, &opts,
1055                                  args_type, frame) == PY_BT_ERROR)
1056         goto error;
1057       else
1058         {
1059           do_cleanups (cleanup_stack);
1060           return PY_BT_COMPLETED;
1061         }
1062     }
1063
1064   /* -stack-list-locals does not require a
1065      wrapping frame attribute.  */
1066   if (print_frame_info || (print_args && ! print_locals))
1067     make_cleanup_ui_out_tuple_begin_end (out, "frame");
1068
1069   if (print_frame_info)
1070     {
1071       /* Elided frames are also printed with this function (recursively)
1072          and are printed with indention.  */
1073       if (indent > 0)
1074         {
1075         TRY_CATCH (except, RETURN_MASK_ALL)
1076           {
1077             ui_out_spaces (out, indent*4);
1078           }
1079         if (except.reason < 0)
1080           {
1081             gdbpy_convert_exception (except);
1082             goto error;
1083           }
1084         }
1085
1086       /* The address is required for frame annotations, and also for
1087          address printing.  */
1088       if (PyObject_HasAttrString (filter, "address"))
1089         {
1090           PyObject *paddr = PyObject_CallMethod (filter, "address", NULL);
1091           if (paddr != NULL)
1092             {
1093               if (paddr != Py_None)
1094                 {
1095                   address = PyLong_AsLong (paddr);
1096                   has_addr = 1;
1097                 }
1098               Py_DECREF (paddr);
1099             }
1100           else
1101             goto error;
1102         }
1103     }
1104
1105   /* Print frame level.  MI does not require the level if
1106      locals/variables only are being printed.  */
1107   if ((print_frame_info || print_args) && print_level)
1108     {
1109       struct frame_info **slot;
1110       int level;
1111       volatile struct gdb_exception except;
1112
1113       slot = (struct frame_info **) htab_find_slot (levels_printed,
1114                                                     frame, INSERT);
1115       TRY_CATCH (except, RETURN_MASK_ALL)
1116         {
1117           level = frame_relative_level (frame);
1118
1119           /* Check if this frame has already been printed (there are cases
1120              where elided synthetic dummy-frames have to 'borrow' the frame
1121              architecture from the eliding frame.  If that is the case, do
1122              not print 'level', but print spaces.  */
1123           if (*slot == frame)
1124             ui_out_field_skip (out, "level");
1125           else
1126             {
1127               *slot = frame;
1128               annotate_frame_begin (print_level ? level : 0,
1129                                     gdbarch, address);
1130               ui_out_text (out, "#");
1131               ui_out_field_fmt_int (out, 2, ui_left, "level",
1132                                     level);
1133             }
1134         }
1135       if (except.reason < 0)
1136         {
1137           gdbpy_convert_exception (except);
1138           goto error;
1139         }
1140     }
1141
1142   if (print_frame_info)
1143     {
1144       /* Print address to the address field.  If an address is not provided,
1145          print nothing.  */
1146       if (opts.addressprint && has_addr)
1147         {
1148           TRY_CATCH (except, RETURN_MASK_ALL)
1149             {
1150               annotate_frame_address ();
1151               ui_out_field_core_addr (out, "addr", gdbarch, address);
1152               annotate_frame_address_end ();
1153               ui_out_text (out, " in ");
1154             }
1155           if (except.reason < 0)
1156             {
1157               gdbpy_convert_exception (except);
1158               goto error;
1159             }
1160         }
1161
1162       /* Print frame function name.  */
1163       if (PyObject_HasAttrString (filter, "function"))
1164         {
1165           PyObject *py_func = PyObject_CallMethod (filter, "function", NULL);
1166
1167           if (py_func != NULL)
1168             {
1169               const char *function = NULL;
1170
1171               if (gdbpy_is_string (py_func))
1172                 {
1173                   char *function_to_free = NULL;
1174
1175                   function = function_to_free =
1176                     python_string_to_host_string (py_func);
1177
1178                   if (function == NULL)
1179                     {
1180                       Py_DECREF (py_func);
1181                       goto error;
1182                     }
1183                   make_cleanup (xfree, function_to_free);
1184                 }
1185               else if (PyLong_Check (py_func))
1186                 {
1187                   CORE_ADDR addr = PyLong_AsUnsignedLongLong (py_func);
1188                   struct bound_minimal_symbol msymbol;
1189
1190                   if (PyErr_Occurred ())
1191                     goto error;
1192
1193                   msymbol = lookup_minimal_symbol_by_pc (addr);
1194                   if (msymbol.minsym != NULL)
1195                     function = SYMBOL_PRINT_NAME (msymbol.minsym);
1196                 }
1197               else if (py_func != Py_None)
1198                 {
1199                   PyErr_SetString (PyExc_RuntimeError,
1200                                    _("FrameDecorator.function: expecting a " \
1201                                      "String, integer or None."));
1202                   Py_DECREF (py_func);
1203                   goto error;
1204                 }
1205
1206
1207               TRY_CATCH (except, RETURN_MASK_ALL)
1208                 {
1209                   annotate_frame_function_name ();
1210                   if (function == NULL)
1211                     ui_out_field_skip (out, "func");
1212                   else
1213                     ui_out_field_string (out, "func", function);
1214                 }
1215               if (except.reason < 0)
1216                 {
1217                   Py_DECREF (py_func);
1218                   gdbpy_convert_exception (except);
1219                   goto error;
1220                 }
1221             }
1222           Py_DECREF (py_func);
1223         }
1224       else
1225         goto error;
1226     }
1227
1228
1229   /* Frame arguments.  Check the result, and error if something went
1230      wrong.  */
1231   if (print_args)
1232     {
1233       if (py_print_args (filter, out, args_type, frame) == PY_BT_ERROR)
1234         goto error;
1235     }
1236
1237   /* File name/source/line number information.  */
1238   if (print_frame_info)
1239     {
1240       TRY_CATCH (except, RETURN_MASK_ALL)
1241         {
1242           annotate_frame_source_begin ();
1243         }
1244       if (except.reason < 0)
1245         {
1246           gdbpy_convert_exception (except);
1247           goto error;
1248         }
1249
1250       if (PyObject_HasAttrString (filter, "filename"))
1251         {
1252           PyObject *py_fn = PyObject_CallMethod (filter, "filename",
1253                                                  NULL);
1254           if (py_fn != NULL)
1255             {
1256               if (py_fn != Py_None)
1257                 {
1258                   char *filename = python_string_to_host_string (py_fn);
1259
1260                   if (filename == NULL)
1261                     {
1262                       Py_DECREF (py_fn);
1263                       goto error;
1264                     }
1265
1266                   make_cleanup (xfree, filename);
1267                   TRY_CATCH (except, RETURN_MASK_ALL)
1268                     {
1269                       ui_out_wrap_hint (out, "   ");
1270                       ui_out_text (out, " at ");
1271                       annotate_frame_source_file ();
1272                       ui_out_field_string (out, "file", filename);
1273                       annotate_frame_source_file_end ();
1274                     }
1275                   if (except.reason < 0)
1276                     {
1277                       Py_DECREF (py_fn);
1278                       gdbpy_convert_exception (except);
1279                       goto error;
1280                     }
1281                 }
1282               Py_DECREF (py_fn);
1283             }
1284           else
1285             goto error;
1286         }
1287
1288       if (PyObject_HasAttrString (filter, "line"))
1289         {
1290           PyObject *py_line = PyObject_CallMethod (filter, "line", NULL);
1291           int line;
1292
1293           if (py_line != NULL)
1294             {
1295               if (py_line != Py_None)
1296                 {
1297                   line = PyLong_AsLong (py_line);
1298                   TRY_CATCH (except, RETURN_MASK_ALL)
1299                     {
1300                       ui_out_text (out, ":");
1301                       annotate_frame_source_line ();
1302                       ui_out_field_int (out, "line", line);
1303                     }
1304                   if (except.reason < 0)
1305                     {
1306                       Py_DECREF (py_line);
1307                       gdbpy_convert_exception (except);
1308                       goto error;
1309                     }
1310                 }
1311               Py_DECREF (py_line);
1312             }
1313           else
1314             goto error;
1315         }
1316     }
1317
1318   /* For MI we need to deal with the "children" list population of
1319      elided frames, so if MI output detected do not send newline.  */
1320   if (! ui_out_is_mi_like_p (out))
1321     {
1322       TRY_CATCH (except, RETURN_MASK_ALL)
1323         {
1324           annotate_frame_end ();
1325           ui_out_text (out, "\n");
1326         }
1327       if (except.reason < 0)
1328         {
1329           gdbpy_convert_exception (except);
1330           goto error;
1331         }
1332     }
1333
1334   if (print_locals)
1335     {
1336       if (py_print_locals (filter, out, args_type, indent,
1337                            frame) == PY_BT_ERROR)
1338         goto error;
1339     }
1340
1341   /* Finally recursively print elided frames, if any.  */
1342   elided  = get_py_iter_from_func (filter, "elided");
1343   if (elided == NULL)
1344     goto error;
1345
1346   make_cleanup_py_decref (elided);
1347   if (elided != Py_None)
1348     {
1349       PyObject *item;
1350
1351       make_cleanup_ui_out_list_begin_end (out, "children");
1352
1353       if (! ui_out_is_mi_like_p (out))
1354         indent++;
1355
1356       while ((item = PyIter_Next (elided)))
1357         {
1358           enum py_bt_status success = py_print_frame (item, flags,
1359                                                       args_type, out,
1360                                                       indent,
1361                                                       levels_printed);
1362
1363           if (success == PY_BT_ERROR)
1364             {
1365               Py_DECREF (item);
1366               goto error;
1367             }
1368
1369           Py_DECREF (item);
1370         }
1371       if (item == NULL && PyErr_Occurred ())
1372         goto error;
1373     }
1374
1375
1376   do_cleanups (cleanup_stack);
1377   return PY_BT_COMPLETED;
1378
1379  error:
1380   do_cleanups (cleanup_stack);
1381   return PY_BT_ERROR;
1382 }
1383
1384 /* Helper function to initiate frame filter invocation at starting
1385    frame FRAME.  */
1386
1387 static PyObject *
1388 bootstrap_python_frame_filters (struct frame_info *frame,
1389                                 int frame_low, int frame_high)
1390 {
1391   struct cleanup *cleanups =
1392     make_cleanup (null_cleanup, NULL);
1393   PyObject *module, *sort_func, *iterable, *frame_obj, *iterator;
1394   PyObject *py_frame_low, *py_frame_high;
1395
1396   frame_obj = frame_info_to_frame_object (frame);
1397   if (frame_obj == NULL)
1398     goto error;
1399   make_cleanup_py_decref (frame_obj);
1400
1401   module = PyImport_ImportModule ("gdb.frames");
1402   if (module == NULL)
1403     goto error;
1404   make_cleanup_py_decref (module);
1405
1406   sort_func = PyObject_GetAttrString (module, "execute_frame_filters");
1407   if (sort_func == NULL)
1408     goto error;
1409   make_cleanup_py_decref (sort_func);
1410
1411   py_frame_low = PyInt_FromLong (frame_low);
1412   if (py_frame_low == NULL)
1413     goto error;
1414   make_cleanup_py_decref (py_frame_low);
1415
1416   py_frame_high = PyInt_FromLong (frame_high);
1417   if (py_frame_high == NULL)
1418     goto error;
1419   make_cleanup_py_decref (py_frame_high);
1420
1421   iterable = PyObject_CallFunctionObjArgs (sort_func, frame_obj,
1422                                            py_frame_low,
1423                                            py_frame_high,
1424                                            NULL);
1425   if (iterable == NULL)
1426     goto error;
1427
1428   do_cleanups (cleanups);
1429
1430   if (iterable != Py_None)
1431     {
1432       iterator = PyObject_GetIter (iterable);
1433       Py_DECREF (iterable);
1434     }
1435   else
1436     {
1437       return iterable;
1438     }
1439
1440   return iterator;
1441
1442  error:
1443   do_cleanups (cleanups);
1444   return NULL;
1445 }
1446
1447 /*  This is the only publicly exported function in this file.  FRAME
1448     is the source frame to start frame-filter invocation.  FLAGS is an
1449     integer holding the flags for printing.  The following elements of
1450     the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS:
1451     PRINT_LEVEL is a flag indicating whether to print the frame's
1452     relative level in the output.  PRINT_FRAME_INFO is a flag that
1453     indicates whether this function should print the frame
1454     information, PRINT_ARGS is a flag that indicates whether to print
1455     frame arguments, and PRINT_LOCALS, likewise, with frame local
1456     variables.  ARGS_TYPE is an enumerator describing the argument
1457     format, OUT is the output stream to print.  FRAME_LOW is the
1458     beginning of the slice of frames to print, and FRAME_HIGH is the
1459     upper limit of the frames to count.  Returns PY_BT_ERROR on error,
1460     or PY_BT_COMPLETED on success.*/
1461
1462 enum py_bt_status
1463 apply_frame_filter (struct frame_info *frame, int flags,
1464                     enum py_frame_args args_type,
1465                     struct ui_out *out, int frame_low,
1466                     int frame_high)
1467
1468 {
1469   struct gdbarch *gdbarch = NULL;
1470   struct cleanup *cleanups;
1471   enum py_bt_status success = PY_BT_ERROR;
1472   PyObject *iterable;
1473   volatile struct gdb_exception except;
1474   PyObject *item;
1475   htab_t levels_printed;
1476
1477   if (!gdb_python_initialized)
1478     return PY_BT_NO_FILTERS;
1479
1480   cleanups = ensure_python_env (gdbarch, current_language);
1481
1482   TRY_CATCH (except, RETURN_MASK_ALL)
1483     {
1484       gdbarch = get_frame_arch (frame);
1485     }
1486   if (except.reason < 0)
1487     {
1488       gdbpy_convert_exception (except);
1489       goto error;
1490     }
1491
1492   iterable = bootstrap_python_frame_filters (frame, frame_low, frame_high);
1493
1494   if (iterable == NULL)
1495     {
1496       /* Normally if there is an error GDB prints the exception,
1497          abandons the backtrace and exits.  The user can then call "bt
1498          no-filters", and get a default backtrace (it would be
1499          confusing to automatically start a standard backtrace halfway
1500          through a Python filtered backtrace).  However in the case
1501          where GDB cannot initialize the frame filters (most likely
1502          due to incorrect auto-load paths), GDB has printed nothing.
1503          In this case it is OK to print the default backtrace after
1504          printing the error message.  GDB returns PY_BT_NO_FILTERS
1505          here to signify there are no filters after printing the
1506          initialization error.  This return code will trigger a
1507          default backtrace.  */
1508
1509       gdbpy_print_stack ();
1510       do_cleanups (cleanups);
1511       return PY_BT_NO_FILTERS;
1512     }
1513
1514   /* If iterable is None, then there are no frame filters registered.
1515      If this is the case, defer to default GDB printing routines in MI
1516      and CLI.  */
1517   make_cleanup_py_decref (iterable);
1518   if (iterable == Py_None)
1519     {
1520       success = PY_BT_NO_FILTERS;
1521       goto done;
1522     }
1523
1524   levels_printed = htab_create (20,
1525                                 htab_hash_pointer,
1526                                 htab_eq_pointer,
1527                                 NULL);
1528   make_cleanup_htab_delete (levels_printed);
1529
1530   while ((item = PyIter_Next (iterable)))
1531     {
1532       success = py_print_frame (item, flags, args_type, out, 0,
1533                                 levels_printed);
1534
1535       /* Do not exit on error printing a single frame.  Print the
1536          error and continue with other frames.  */
1537       if (success == PY_BT_ERROR)
1538         gdbpy_print_stack ();
1539
1540       Py_DECREF (item);
1541     }
1542
1543   if (item == NULL && PyErr_Occurred ())
1544     goto error;
1545
1546  done:
1547   do_cleanups (cleanups);
1548   return success;
1549
1550   /* Exit and abandon backtrace on error, printing the exception that
1551      is set.  */
1552  error:
1553   gdbpy_print_stack ();
1554   do_cleanups (cleanups);
1555   return PY_BT_ERROR;
1556 }