gdb/python/py-framefilter.c

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