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