gdb/mi/mi-cmd-stack.c

   1 /* MI Command Set - stack commands.
   2    Copyright (C) 2000-2019 Free Software Foundation, Inc.
   3    Contributed by Cygnus Solutions (a Red Hat company).
   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 "target.h"
  22 #include "frame.h"
  23 #include "value.h"
  24 #include "mi-cmds.h"
  25 #include "ui-out.h"
  26 #include "symtab.h"
  27 #include "block.h"
  28 #include "stack.h"
  29 #include "dictionary.h"
  30 #include "language.h"
  31 #include "valprint.h"
  32 #include "utils.h"
  33 #include "mi-getopt.h"
  34 #include "extension.h"
  35 #include <ctype.h>
  36 #include "mi-parse.h"
  37 #include "common/gdb_optional.h"
  38 #include "safe-ctype.h"
  39
  40 enum what_to_list { locals, arguments, all };
  41
  42 static void list_args_or_locals (enum what_to_list what,
  43                                  enum print_values values,
  44                                  struct frame_info *fi,
  45                                  int skip_unavailable);
  46
  47 /* True if we want to allow Python-based frame filters.  */
  48 static int frame_filters = 0;
  49
  50 void
  51 mi_cmd_enable_frame_filters (const char *command, char **argv, int argc)
  52 {
  53   if (argc != 0)
  54     error (_("-enable-frame-filters: no arguments allowed"));
  55   frame_filters = 1;
  56 }
  57
  58 /* Like apply_ext_lang_frame_filter, but take a print_values */
  59
  60 static enum ext_lang_bt_status
  61 mi_apply_ext_lang_frame_filter (struct frame_info *frame,
  62                                 frame_filter_flags flags,
  63                                 enum print_values print_values,
  64                                 struct ui_out *out,
  65                                 int frame_low, int frame_high)
  66 {
  67   /* ext_lang_frame_args's MI options are compatible with MI print
  68      values.  */
  69   return apply_ext_lang_frame_filter (frame, flags,
  70                                       (enum ext_lang_frame_args) print_values,
  71                                       out,
  72                                       frame_low, frame_high);
  73 }
  74
  75 /* Print a list of the stack frames.  Args can be none, in which case
  76    we want to print the whole backtrace, or a pair of numbers
  77    specifying the frame numbers at which to start and stop the
  78    display.  If the two numbers are equal, a single frame will be
  79    displayed.  */
  80
  81 void
  82 mi_cmd_stack_list_frames (const char *command, char **argv, int argc)
  83 {
  84   int frame_low;
  85   int frame_high;
  86   int i;
  87   struct frame_info *fi;
  88   enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
  89   int raw_arg = 0;
  90   int oind = 0;
  91   enum opt
  92     {
  93       NO_FRAME_FILTERS
  94     };
  95   static const struct mi_opt opts[] =
  96     {
  97       {"-no-frame-filters", NO_FRAME_FILTERS, 0},
  98       { 0, 0, 0 }
  99     };
 100
 101   /* Parse arguments.  In this instance we are just looking for
 102      --no-frame-filters.  */
 103   while (1)
 104     {
 105       char *oarg;
 106       int opt = mi_getopt ("-stack-list-frames", argc, argv,
 107                            opts, &oind, &oarg);
 108       if (opt < 0)
 109         break;
 110       switch ((enum opt) opt)
 111         {
 112         case NO_FRAME_FILTERS:
 113           raw_arg = oind;
 114           break;
 115         }
 116     }
 117
 118   /* After the last option is parsed, there should either be low -
 119      high range, or no further arguments.  */
 120   if ((argc - oind != 0) && (argc - oind != 2))
 121     error (_("-stack-list-frames: Usage: [--no-frame-filters] [FRAME_LOW FRAME_HIGH]"));
 122
 123   /* If there is a range, set it.  */
 124   if (argc - oind == 2)
 125     {
 126       frame_low = atoi (argv[0 + oind]);
 127       frame_high = atoi (argv[1 + oind]);
 128     }
 129   else
 130     {
 131       /* Called with no arguments, it means we want the whole
 132          backtrace.  */
 133       frame_low = -1;
 134       frame_high = -1;
 135     }
 136
 137   /* Let's position fi on the frame at which to start the
 138      display. Could be the innermost frame if the whole stack needs
 139      displaying, or if frame_low is 0.  */
 140   for (i = 0, fi = get_current_frame ();
 141        fi && i < frame_low;
 142        i++, fi = get_prev_frame (fi));
 143
 144   if (fi == NULL)
 145     error (_("-stack-list-frames: Not enough frames in stack."));
 146
 147   ui_out_emit_list list_emitter (current_uiout, "stack");
 148
 149   if (! raw_arg && frame_filters)
 150     {
 151       frame_filter_flags flags = PRINT_LEVEL | PRINT_FRAME_INFO;
 152       int py_frame_low = frame_low;
 153
 154       /* We cannot pass -1 to frame_low, as that would signify a
 155       relative backtrace from the tail of the stack.  So, in the case
 156       of frame_low == -1, assign and increment it.  */
 157       if (py_frame_low == -1)
 158         py_frame_low++;
 159
 160       result = apply_ext_lang_frame_filter (get_current_frame (), flags,
 161                                             NO_VALUES,  current_uiout,
 162                                             py_frame_low, frame_high);
 163     }
 164
 165   /* Run the inbuilt backtrace if there are no filters registered, or
 166      if "--no-frame-filters" has been specified from the command.  */
 167   if (! frame_filters || raw_arg  || result == EXT_LANG_BT_NO_FILTERS)
 168     {
 169       /* Now let's print the frames up to frame_high, or until there are
 170          frames in the stack.  */
 171       for (;
 172            fi && (i <= frame_high || frame_high == -1);
 173            i++, fi = get_prev_frame (fi))
 174         {
 175           QUIT;
 176           /* Print the location and the address always, even for level 0.
 177              If args is 0, don't print the arguments.  */
 178           print_frame_info (fi, 1, LOC_AND_ADDRESS, 0 /* args */, 0);
 179         }
 180     }
 181 }
 182
 183 void
 184 mi_cmd_stack_info_depth (const char *command, char **argv, int argc)
 185 {
 186   int frame_high;
 187   int i;
 188   struct frame_info *fi;
 189
 190   if (argc > 1)
 191     error (_("-stack-info-depth: Usage: [MAX_DEPTH]"));
 192
 193   if (argc == 1)
 194     frame_high = atoi (argv[0]);
 195   else
 196     /* Called with no arguments, it means we want the real depth of
 197        the stack.  */
 198     frame_high = -1;
 199
 200   for (i = 0, fi = get_current_frame ();
 201        fi && (i < frame_high || frame_high == -1);
 202        i++, fi = get_prev_frame (fi))
 203     QUIT;
 204
 205   current_uiout->field_int ("depth", i);
 206 }
 207
 208 /* Print a list of the locals for the current frame.  With argument of
 209    0, print only the names, with argument of 1 print also the
 210    values.  */
 211
 212 void
 213 mi_cmd_stack_list_locals (const char *command, char **argv, int argc)
 214 {
 215   struct frame_info *frame;
 216   int raw_arg = 0;
 217   enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
 218   enum print_values print_value;
 219   int oind = 0;
 220   int skip_unavailable = 0;
 221
 222   if (argc > 1)
 223     {
 224       enum opt
 225       {
 226         NO_FRAME_FILTERS,
 227         SKIP_UNAVAILABLE,
 228       };
 229       static const struct mi_opt opts[] =
 230         {
 231           {"-no-frame-filters", NO_FRAME_FILTERS, 0},
 232           {"-skip-unavailable", SKIP_UNAVAILABLE, 0},
 233           { 0, 0, 0 }
 234         };
 235
 236       while (1)
 237         {
 238           char *oarg;
 239           /* Don't parse 'print-values' as an option.  */
 240           int opt = mi_getopt ("-stack-list-locals", argc - 1, argv,
 241                                opts, &oind, &oarg);
 242
 243           if (opt < 0)
 244             break;
 245           switch ((enum opt) opt)
 246             {
 247             case NO_FRAME_FILTERS:
 248               raw_arg = oind;
 249               break;
 250             case SKIP_UNAVAILABLE:
 251               skip_unavailable = 1;
 252               break;
 253             }
 254         }
 255     }
 256
 257   /* After the last option is parsed, there should be only
 258      'print-values'.  */
 259   if (argc - oind != 1)
 260     error (_("-stack-list-locals: Usage: [--no-frame-filters] "
 261              "[--skip-unavailable] PRINT_VALUES"));
 262
 263   frame = get_selected_frame (NULL);
 264   print_value = mi_parse_print_values (argv[oind]);
 265
 266    if (! raw_arg && frame_filters)
 267      {
 268        frame_filter_flags flags = PRINT_LEVEL | PRINT_LOCALS;
 269
 270        result = mi_apply_ext_lang_frame_filter (frame, flags, print_value,
 271                                                 current_uiout, 0, 0);
 272      }
 273
 274    /* Run the inbuilt backtrace if there are no filters registered, or
 275       if "--no-frame-filters" has been specified from the command.  */
 276    if (! frame_filters || raw_arg  || result == EXT_LANG_BT_NO_FILTERS)
 277      {
 278        list_args_or_locals (locals, print_value, frame,
 279                             skip_unavailable);
 280      }
 281 }
 282
 283 /* Print a list of the arguments for the current frame.  With argument
 284    of 0, print only the names, with argument of 1 print also the
 285    values.  */
 286
 287 void
 288 mi_cmd_stack_list_args (const char *command, char **argv, int argc)
 289 {
 290   int frame_low;
 291   int frame_high;
 292   int i;
 293   struct frame_info *fi;
 294   enum print_values print_values;
 295   struct ui_out *uiout = current_uiout;
 296   int raw_arg = 0;
 297   int oind = 0;
 298   int skip_unavailable = 0;
 299   enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
 300   enum opt
 301   {
 302     NO_FRAME_FILTERS,
 303     SKIP_UNAVAILABLE,
 304   };
 305   static const struct mi_opt opts[] =
 306     {
 307       {"-no-frame-filters", NO_FRAME_FILTERS, 0},
 308       {"-skip-unavailable", SKIP_UNAVAILABLE, 0},
 309       { 0, 0, 0 }
 310     };
 311
 312   while (1)
 313     {
 314       char *oarg;
 315       int opt = mi_getopt_allow_unknown ("-stack-list-args", argc, argv,
 316                                          opts, &oind, &oarg);
 317
 318       if (opt < 0)
 319         break;
 320       switch ((enum opt) opt)
 321         {
 322         case NO_FRAME_FILTERS:
 323           raw_arg = oind;
 324           break;
 325         case SKIP_UNAVAILABLE:
 326           skip_unavailable = 1;
 327           break;
 328         }
 329     }
 330
 331   if (argc - oind != 1 && argc - oind != 3)
 332     error (_("-stack-list-arguments: Usage: "   \
 333              "[--no-frame-filters] [--skip-unavailable] "
 334              "PRINT_VALUES [FRAME_LOW FRAME_HIGH]"));
 335
 336   if (argc - oind == 3)
 337     {
 338       frame_low = atoi (argv[1 + oind]);
 339       frame_high = atoi (argv[2 + oind]);
 340     }
 341   else
 342     {
 343       /* Called with no arguments, it means we want args for the whole
 344          backtrace.  */
 345       frame_low = -1;
 346       frame_high = -1;
 347     }
 348
 349   print_values = mi_parse_print_values (argv[oind]);
 350
 351   /* Let's position fi on the frame at which to start the
 352      display. Could be the innermost frame if the whole stack needs
 353      displaying, or if frame_low is 0.  */
 354   for (i = 0, fi = get_current_frame ();
 355        fi && i < frame_low;
 356        i++, fi = get_prev_frame (fi));
 357
 358   if (fi == NULL)
 359     error (_("-stack-list-arguments: Not enough frames in stack."));
 360
 361   ui_out_emit_list list_emitter (uiout, "stack-args");
 362
 363   if (! raw_arg && frame_filters)
 364     {
 365       frame_filter_flags flags = PRINT_LEVEL | PRINT_ARGS;
 366       int py_frame_low = frame_low;
 367
 368       /* We cannot pass -1 to frame_low, as that would signify a
 369       relative backtrace from the tail of the stack.  So, in the case
 370       of frame_low == -1, assign and increment it.  */
 371       if (py_frame_low == -1)
 372         py_frame_low++;
 373
 374       result = mi_apply_ext_lang_frame_filter (get_current_frame (), flags,
 375                                                print_values, current_uiout,
 376                                                py_frame_low, frame_high);
 377     }
 378
 379      /* Run the inbuilt backtrace if there are no filters registered, or
 380       if "--no-frame-filters" has been specified from the command.  */
 381    if (! frame_filters || raw_arg  || result == EXT_LANG_BT_NO_FILTERS)
 382      {
 383       /* Now let's print the frames up to frame_high, or until there are
 384          frames in the stack.  */
 385       for (;
 386            fi && (i <= frame_high || frame_high == -1);
 387            i++, fi = get_prev_frame (fi))
 388         {
 389           QUIT;
 390           ui_out_emit_tuple tuple_emitter (uiout, "frame");
 391           uiout->field_int ("level", i);
 392           list_args_or_locals (arguments, print_values, fi, skip_unavailable);
 393         }
 394     }
 395 }
 396
 397 /* Print a list of the local variables (including arguments) for the
 398    current frame.  ARGC must be 1 and ARGV[0] specify if only the names,
 399    or both names and values of the variables must be printed.  See
 400    parse_print_value for possible values.  */
 401
 402 void
 403 mi_cmd_stack_list_variables (const char *command, char **argv, int argc)
 404 {
 405   struct frame_info *frame;
 406   int raw_arg = 0;
 407   enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
 408   enum print_values print_value;
 409   int oind = 0;
 410   int skip_unavailable = 0;
 411
 412   if (argc > 1)
 413     {
 414       enum opt
 415       {
 416         NO_FRAME_FILTERS,
 417         SKIP_UNAVAILABLE,
 418       };
 419       static const struct mi_opt opts[] =
 420         {
 421           {"-no-frame-filters", NO_FRAME_FILTERS, 0},
 422           {"-skip-unavailable", SKIP_UNAVAILABLE, 0},
 423           { 0, 0, 0 }
 424         };
 425
 426       while (1)
 427         {
 428           char *oarg;
 429           /* Don't parse 'print-values' as an option.  */
 430           int opt = mi_getopt ("-stack-list-variables", argc - 1,
 431                                argv, opts, &oind, &oarg);
 432           if (opt < 0)
 433             break;
 434           switch ((enum opt) opt)
 435             {
 436             case NO_FRAME_FILTERS:
 437               raw_arg = oind;
 438               break;
 439             case SKIP_UNAVAILABLE:
 440               skip_unavailable = 1;
 441               break;
 442             }
 443         }
 444     }
 445
 446   /* After the last option is parsed, there should be only
 447      'print-values'.  */
 448   if (argc - oind != 1)
 449     error (_("-stack-list-variables: Usage: [--no-frame-filters] " \
 450              "[--skip-unavailable] PRINT_VALUES"));
 451
 452    frame = get_selected_frame (NULL);
 453    print_value = mi_parse_print_values (argv[oind]);
 454
 455    if (! raw_arg && frame_filters)
 456      {
 457        frame_filter_flags flags = PRINT_LEVEL | PRINT_ARGS | PRINT_LOCALS;
 458
 459        result = mi_apply_ext_lang_frame_filter (frame, flags,
 460                                                 print_value,
 461                                                 current_uiout, 0, 0);
 462      }
 463
 464    /* Run the inbuilt backtrace if there are no filters registered, or
 465       if "--no-frame-filters" has been specified from the command.  */
 466    if (! frame_filters || raw_arg  || result == EXT_LANG_BT_NO_FILTERS)
 467      {
 468        list_args_or_locals (all, print_value, frame,
 469                             skip_unavailable);
 470      }
 471 }
 472
 473 /* Print single local or argument.  ARG must be already read in.  For
 474    WHAT and VALUES see list_args_or_locals.
 475
 476    Errors are printed as if they would be the parameter value.  Use
 477    zeroed ARG iff it should not be printed according to VALUES.  If
 478    SKIP_UNAVAILABLE is true, only print ARG if it is available.  */
 479
 480 static void
 481 list_arg_or_local (const struct frame_arg *arg, enum what_to_list what,
 482                    enum print_values values, int skip_unavailable)
 483 {
 484   struct ui_out *uiout = current_uiout;
 485
 486   gdb_assert (!arg->val || !arg->error);
 487   gdb_assert ((values == PRINT_NO_VALUES && arg->val == NULL
 488                && arg->error == NULL)
 489               || values == PRINT_SIMPLE_VALUES
 490               || (values == PRINT_ALL_VALUES
 491                   && (arg->val != NULL || arg->error != NULL)));
 492   gdb_assert (arg->entry_kind == print_entry_values_no
 493               || (arg->entry_kind == print_entry_values_only
 494                   && (arg->val || arg->error)));
 495
 496   if (skip_unavailable && arg->val != NULL
 497       && (value_entirely_unavailable (arg->val)
 498           /* A scalar object that does not have all bits available is
 499              also considered unavailable, because all bits contribute
 500              to its representation.  */
 501           || (val_print_scalar_type_p (value_type (arg->val))
 502               && !value_bytes_available (arg->val,
 503                                          value_embedded_offset (arg->val),
 504                                          TYPE_LENGTH (value_type (arg->val))))))
 505     return;
 506
 507   gdb::optional<ui_out_emit_tuple> tuple_emitter;
 508   if (values != PRINT_NO_VALUES || what == all)
 509     tuple_emitter.emplace (uiout, nullptr);
 510
 511   string_file stb;
 512
 513   stb.puts (SYMBOL_PRINT_NAME (arg->sym));
 514   if (arg->entry_kind == print_entry_values_only)
 515     stb.puts ("@entry");
 516   uiout->field_stream ("name", stb);
 517
 518   if (what == all && SYMBOL_IS_ARGUMENT (arg->sym))
 519     uiout->field_int ("arg", 1);
 520
 521   if (values == PRINT_SIMPLE_VALUES)
 522     {
 523       check_typedef (arg->sym->type);
 524       type_print (arg->sym->type, "", &stb, -1);
 525       uiout->field_stream ("type", stb);
 526     }
 527
 528   if (arg->val || arg->error)
 529     {
 530       const char *error_message = NULL;
 531
 532       if (arg->error)
 533         error_message = arg->error;
 534       else
 535         {
 536           TRY
 537             {
 538               struct value_print_options opts;
 539
 540               get_no_prettyformat_print_options (&opts);
 541               opts.deref_ref = 1;
 542               common_val_print (arg->val, &stb, 0, &opts,
 543                                 language_def (SYMBOL_LANGUAGE (arg->sym)));
 544             }
 545           CATCH (except, RETURN_MASK_ERROR)
 546             {
 547               error_message = except.message;
 548             }
 549           END_CATCH
 550         }
 551       if (error_message != NULL)
 552         stb.printf (_("<error reading variable: %s>"), error_message);
 553       uiout->field_stream ("value", stb);
 554     }
 555 }
 556
 557 /* Print a list of the objects for the frame FI in a certain form,
 558    which is determined by VALUES.  The objects can be locals,
 559    arguments or both, which is determined by WHAT.  If SKIP_UNAVAILABLE
 560    is true, only print the arguments or local variables whose values
 561    are available.  */
 562
 563 static void
 564 list_args_or_locals (enum what_to_list what, enum print_values values,
 565                      struct frame_info *fi, int skip_unavailable)
 566 {
 567   const struct block *block;
 568   struct symbol *sym;
 569   struct block_iterator iter;
 570   struct type *type;
 571   const char *name_of_result;
 572   struct ui_out *uiout = current_uiout;
 573
 574   block = get_frame_block (fi, 0);
 575
 576   switch (what)
 577     {
 578     case locals:
 579       name_of_result = "locals";
 580       break;
 581     case arguments:
 582       name_of_result = "args";
 583       break;
 584     case all:
 585       name_of_result = "variables";
 586       break;
 587     default:
 588       internal_error (__FILE__, __LINE__,
 589                       "unexpected what_to_list: %d", (int) what);
 590     }
 591
 592   ui_out_emit_list list_emitter (uiout, name_of_result);
 593
 594   while (block != 0)
 595     {
 596       ALL_BLOCK_SYMBOLS (block, iter, sym)
 597         {
 598           int print_me = 0;
 599
 600           switch (SYMBOL_CLASS (sym))
 601             {
 602             default:
 603             case LOC_UNDEF:     /* catches errors        */
 604             case LOC_CONST:     /* constant              */
 605             case LOC_TYPEDEF:   /* local typedef         */
 606             case LOC_LABEL:     /* local label           */
 607             case LOC_BLOCK:     /* local function        */
 608             case LOC_CONST_BYTES:       /* loc. byte seq.        */
 609             case LOC_UNRESOLVED:        /* unresolved static     */
 610             case LOC_OPTIMIZED_OUT:     /* optimized out         */
 611               print_me = 0;
 612               break;
 613
 614             case LOC_ARG:       /* argument              */
 615             case LOC_REF_ARG:   /* reference arg         */
 616             case LOC_REGPARM_ADDR:      /* indirect register arg */
 617             case LOC_LOCAL:     /* stack local           */
 618             case LOC_STATIC:    /* static                */
 619             case LOC_REGISTER:  /* register              */
 620             case LOC_COMPUTED:  /* computed location     */
 621               if (what == all)
 622                 print_me = 1;
 623               else if (what == locals)
 624                 print_me = !SYMBOL_IS_ARGUMENT (sym);
 625               else
 626                 print_me = SYMBOL_IS_ARGUMENT (sym);
 627               break;
 628             }
 629           if (print_me)
 630             {
 631               struct symbol *sym2;
 632               struct frame_arg arg, entryarg;
 633
 634               if (SYMBOL_IS_ARGUMENT (sym))
 635                 sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
 636                                       block, VAR_DOMAIN,
 637                                       NULL).symbol;
 638               else
 639                 sym2 = sym;
 640               gdb_assert (sym2 != NULL);
 641
 642               memset (&arg, 0, sizeof (arg));
 643               arg.sym = sym2;
 644               arg.entry_kind = print_entry_values_no;
 645               memset (&entryarg, 0, sizeof (entryarg));
 646               entryarg.sym = sym2;
 647               entryarg.entry_kind = print_entry_values_no;
 648
 649               switch (values)
 650                 {
 651                 case PRINT_SIMPLE_VALUES:
 652                   type = check_typedef (sym2->type);
 653                   if (TYPE_CODE (type) != TYPE_CODE_ARRAY
 654                       && TYPE_CODE (type) != TYPE_CODE_STRUCT
 655                       && TYPE_CODE (type) != TYPE_CODE_UNION)
 656                     {
 657                 case PRINT_ALL_VALUES:
 658                   if (SYMBOL_IS_ARGUMENT (sym))
 659                     read_frame_arg (sym2, fi, &arg, &entryarg);
 660                   else
 661                     read_frame_local (sym2, fi, &arg);
 662                     }
 663                   break;
 664                 }
 665
 666               if (arg.entry_kind != print_entry_values_only)
 667                 list_arg_or_local (&arg, what, values, skip_unavailable);
 668               if (entryarg.entry_kind != print_entry_values_no)
 669                 list_arg_or_local (&entryarg, what, values, skip_unavailable);
 670               xfree (arg.error);
 671               xfree (entryarg.error);
 672             }
 673         }
 674
 675       if (BLOCK_FUNCTION (block))
 676         break;
 677       else
 678         block = BLOCK_SUPERBLOCK (block);
 679     }
 680 }
 681
 682 /* Read a frame specification from FRAME_EXP and return the selected frame.
 683    Call error() if the specification is in any way invalid (so this
 684    function never returns NULL).
 685
 686    The frame specification is usually an integer level number, however if
 687    the number does not match a valid frame level then it will be treated as
 688    a frame address.  The frame address will then be used to find a matching
 689    frame in the stack.  If no matching frame is found then a new frame will
 690    be created.
 691
 692    The use of FRAME_EXP as an address is undocumented in the GDB user
 693    manual, this feature is supported here purely for backward
 694    compatibility.  */
 695
 696 static struct frame_info *
 697 parse_frame_specification (const char *frame_exp)
 698 {
 699   gdb_assert (frame_exp != NULL);
 700
 701   /* NOTE: Parse and evaluate expression, but do not use
 702      functions such as parse_and_eval_long or
 703      parse_and_eval_address to also extract the value.
 704      Instead value_as_long and value_as_address are used.
 705      This avoids problems with expressions that contain
 706      side-effects.  */
 707   struct value *arg = parse_and_eval (frame_exp);
 708
 709   /* Assume ARG is an integer, and try using that to select a frame.  */
 710   struct frame_info *fid;
 711   int level = value_as_long (arg);
 712
 713   fid = find_relative_frame (get_current_frame (), &level);
 714   if (level == 0)
 715     /* find_relative_frame was successful.  */
 716     return fid;
 717
 718   /* Convert the value into a corresponding address.  */
 719   CORE_ADDR addr = value_as_address (arg);
 720
 721   /* Assume that ADDR is an address, use that to identify a frame with a
 722      matching ID.  */
 723   struct frame_id id = frame_id_build_wild (addr);
 724
 725   /* If (s)he specifies the frame with an address, he deserves
 726      what (s)he gets.  Still, give the highest one that matches.
 727      (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
 728      know).  */
 729   for (fid = get_current_frame ();
 730        fid != NULL;
 731        fid = get_prev_frame (fid))
 732     {
 733       if (frame_id_eq (id, get_frame_id (fid)))
 734         {
 735           struct frame_info *prev_frame;
 736
 737           while (1)
 738             {
 739               prev_frame = get_prev_frame (fid);
 740               if (!prev_frame
 741                   || !frame_id_eq (id, get_frame_id (prev_frame)))
 742                 break;
 743               fid = prev_frame;
 744             }
 745           return fid;
 746         }
 747     }
 748
 749   /* We couldn't identify the frame as an existing frame, but
 750      perhaps we can create one with a single argument.  */
 751   return create_new_frame (addr, 0);
 752 }
 753
 754 /* Implement the -stack-select-frame MI command.  */
 755
 756 void
 757 mi_cmd_stack_select_frame (const char *command, char **argv, int argc)
 758 {
 759   if (argc == 0 || argc > 1)
 760     error (_("-stack-select-frame: Usage: FRAME_SPEC"));
 761
 762   select_frame_for_mi (parse_frame_specification (argv[0]));
 763 }
 764
 765 void
 766 mi_cmd_stack_info_frame (const char *command, char **argv, int argc)
 767 {
 768   if (argc > 0)
 769     error (_("-stack-info-frame: No arguments allowed"));
 770
 771   print_frame_info (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 0, 1);
 772 }