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       if (arg->error)
 531         stb.printf (_("<error reading variable: %s>"), arg->error);
 532       else
 533         {
 534           try
 535             {
 536               struct value_print_options opts;
 537
 538               get_no_prettyformat_print_options (&opts);
 539               opts.deref_ref = 1;
 540               common_val_print (arg->val, &stb, 0, &opts,
 541                                 language_def (SYMBOL_LANGUAGE (arg->sym)));
 542             }
 543           catch (const gdb_exception_error &except)
 544             {
 545               stb.printf (_("<error reading variable: %s>"),
 546                           except.what ());
 547             }
 548         }
 549       uiout->field_stream ("value", stb);
 550     }
 551 }
 552
 553 /* Print a list of the objects for the frame FI in a certain form,
 554    which is determined by VALUES.  The objects can be locals,
 555    arguments or both, which is determined by WHAT.  If SKIP_UNAVAILABLE
 556    is true, only print the arguments or local variables whose values
 557    are available.  */
 558
 559 static void
 560 list_args_or_locals (enum what_to_list what, enum print_values values,
 561                      struct frame_info *fi, int skip_unavailable)
 562 {
 563   const struct block *block;
 564   struct symbol *sym;
 565   struct block_iterator iter;
 566   struct type *type;
 567   const char *name_of_result;
 568   struct ui_out *uiout = current_uiout;
 569
 570   block = get_frame_block (fi, 0);
 571
 572   switch (what)
 573     {
 574     case locals:
 575       name_of_result = "locals";
 576       break;
 577     case arguments:
 578       name_of_result = "args";
 579       break;
 580     case all:
 581       name_of_result = "variables";
 582       break;
 583     default:
 584       internal_error (__FILE__, __LINE__,
 585                       "unexpected what_to_list: %d", (int) what);
 586     }
 587
 588   ui_out_emit_list list_emitter (uiout, name_of_result);
 589
 590   while (block != 0)
 591     {
 592       ALL_BLOCK_SYMBOLS (block, iter, sym)
 593         {
 594           int print_me = 0;
 595
 596           switch (SYMBOL_CLASS (sym))
 597             {
 598             default:
 599             case LOC_UNDEF:     /* catches errors        */
 600             case LOC_CONST:     /* constant              */
 601             case LOC_TYPEDEF:   /* local typedef         */
 602             case LOC_LABEL:     /* local label           */
 603             case LOC_BLOCK:     /* local function        */
 604             case LOC_CONST_BYTES:       /* loc. byte seq.        */
 605             case LOC_UNRESOLVED:        /* unresolved static     */
 606             case LOC_OPTIMIZED_OUT:     /* optimized out         */
 607               print_me = 0;
 608               break;
 609
 610             case LOC_ARG:       /* argument              */
 611             case LOC_REF_ARG:   /* reference arg         */
 612             case LOC_REGPARM_ADDR:      /* indirect register arg */
 613             case LOC_LOCAL:     /* stack local           */
 614             case LOC_STATIC:    /* static                */
 615             case LOC_REGISTER:  /* register              */
 616             case LOC_COMPUTED:  /* computed location     */
 617               if (what == all)
 618                 print_me = 1;
 619               else if (what == locals)
 620                 print_me = !SYMBOL_IS_ARGUMENT (sym);
 621               else
 622                 print_me = SYMBOL_IS_ARGUMENT (sym);
 623               break;
 624             }
 625           if (print_me)
 626             {
 627               struct symbol *sym2;
 628               struct frame_arg arg, entryarg;
 629
 630               if (SYMBOL_IS_ARGUMENT (sym))
 631                 sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
 632                                       block, VAR_DOMAIN,
 633                                       NULL).symbol;
 634               else
 635                 sym2 = sym;
 636               gdb_assert (sym2 != NULL);
 637
 638               memset (&arg, 0, sizeof (arg));
 639               arg.sym = sym2;
 640               arg.entry_kind = print_entry_values_no;
 641               memset (&entryarg, 0, sizeof (entryarg));
 642               entryarg.sym = sym2;
 643               entryarg.entry_kind = print_entry_values_no;
 644
 645               switch (values)
 646                 {
 647                 case PRINT_SIMPLE_VALUES:
 648                   type = check_typedef (sym2->type);
 649                   if (TYPE_CODE (type) != TYPE_CODE_ARRAY
 650                       && TYPE_CODE (type) != TYPE_CODE_STRUCT
 651                       && TYPE_CODE (type) != TYPE_CODE_UNION)
 652                     {
 653                 case PRINT_ALL_VALUES:
 654                   if (SYMBOL_IS_ARGUMENT (sym))
 655                     read_frame_arg (sym2, fi, &arg, &entryarg);
 656                   else
 657                     read_frame_local (sym2, fi, &arg);
 658                     }
 659                   break;
 660                 }
 661
 662               if (arg.entry_kind != print_entry_values_only)
 663                 list_arg_or_local (&arg, what, values, skip_unavailable);
 664               if (entryarg.entry_kind != print_entry_values_no)
 665                 list_arg_or_local (&entryarg, what, values, skip_unavailable);
 666               xfree (arg.error);
 667               xfree (entryarg.error);
 668             }
 669         }
 670
 671       if (BLOCK_FUNCTION (block))
 672         break;
 673       else
 674         block = BLOCK_SUPERBLOCK (block);
 675     }
 676 }
 677
 678 /* Read a frame specification from FRAME_EXP and return the selected frame.
 679    Call error() if the specification is in any way invalid (so this
 680    function never returns NULL).
 681
 682    The frame specification is usually an integer level number, however if
 683    the number does not match a valid frame level then it will be treated as
 684    a frame address.  The frame address will then be used to find a matching
 685    frame in the stack.  If no matching frame is found then a new frame will
 686    be created.
 687
 688    The use of FRAME_EXP as an address is undocumented in the GDB user
 689    manual, this feature is supported here purely for backward
 690    compatibility.  */
 691
 692 static struct frame_info *
 693 parse_frame_specification (const char *frame_exp)
 694 {
 695   gdb_assert (frame_exp != NULL);
 696
 697   /* NOTE: Parse and evaluate expression, but do not use
 698      functions such as parse_and_eval_long or
 699      parse_and_eval_address to also extract the value.
 700      Instead value_as_long and value_as_address are used.
 701      This avoids problems with expressions that contain
 702      side-effects.  */
 703   struct value *arg = parse_and_eval (frame_exp);
 704
 705   /* Assume ARG is an integer, and try using that to select a frame.  */
 706   struct frame_info *fid;
 707   int level = value_as_long (arg);
 708
 709   fid = find_relative_frame (get_current_frame (), &level);
 710   if (level == 0)
 711     /* find_relative_frame was successful.  */
 712     return fid;
 713
 714   /* Convert the value into a corresponding address.  */
 715   CORE_ADDR addr = value_as_address (arg);
 716
 717   /* Assume that ADDR is an address, use that to identify a frame with a
 718      matching ID.  */
 719   struct frame_id id = frame_id_build_wild (addr);
 720
 721   /* If (s)he specifies the frame with an address, he deserves
 722      what (s)he gets.  Still, give the highest one that matches.
 723      (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
 724      know).  */
 725   for (fid = get_current_frame ();
 726        fid != NULL;
 727        fid = get_prev_frame (fid))
 728     {
 729       if (frame_id_eq (id, get_frame_id (fid)))
 730         {
 731           struct frame_info *prev_frame;
 732
 733           while (1)
 734             {
 735               prev_frame = get_prev_frame (fid);
 736               if (!prev_frame
 737                   || !frame_id_eq (id, get_frame_id (prev_frame)))
 738                 break;
 739               fid = prev_frame;
 740             }
 741           return fid;
 742         }
 743     }
 744
 745   /* We couldn't identify the frame as an existing frame, but
 746      perhaps we can create one with a single argument.  */
 747   return create_new_frame (addr, 0);
 748 }
 749
 750 /* Implement the -stack-select-frame MI command.  */
 751
 752 void
 753 mi_cmd_stack_select_frame (const char *command, char **argv, int argc)
 754 {
 755   if (argc == 0 || argc > 1)
 756     error (_("-stack-select-frame: Usage: FRAME_SPEC"));
 757
 758   select_frame_for_mi (parse_frame_specification (argv[0]));
 759 }
 760
 761 void
 762 mi_cmd_stack_info_frame (const char *command, char **argv, int argc)
 763 {
 764   if (argc > 0)
 765     error (_("-stack-info-frame: No arguments allowed"));
 766
 767   print_frame_info (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 0, 1);
 768 }