gdb/mi/mi-cmd-stack.c

   1 /* MI Command Set - stack commands.
   2    Copyright (C) 2000-2024 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 <optional>
  38 #include "gdbsupport/gdb-safe-ctype.h"
  39 #include "inferior.h"
  40 #include "observable.h"
  41
  42 enum what_to_list { locals, arguments, all };
  43
  44 static void list_args_or_locals (const frame_print_options &fp_opts,
  45                                  enum what_to_list what,
  46                                  enum print_values values,
  47                                  frame_info_ptr fi,
  48                                  int skip_unavailable);
  49
  50 /* True if we want to allow Python-based frame filters.  */
  51 static int frame_filters = 0;
  52
  53 void
  54 mi_cmd_enable_frame_filters (const char *command, const char *const *argv,
  55                              int argc)
  56 {
  57   if (argc != 0)
  58     error (_("-enable-frame-filters: no arguments allowed"));
  59   frame_filters = 1;
  60 }
  61
  62 /* Like apply_ext_lang_frame_filter, but take a print_values */
  63
  64 static enum ext_lang_bt_status
  65 mi_apply_ext_lang_frame_filter (frame_info_ptr frame,
  66                                 frame_filter_flags flags,
  67                                 enum print_values print_values,
  68                                 struct ui_out *out,
  69                                 int frame_low, int frame_high)
  70 {
  71   /* ext_lang_frame_args's MI options are compatible with MI print
  72      values.  */
  73   return apply_ext_lang_frame_filter (frame, flags,
  74                                       (enum ext_lang_frame_args) print_values,
  75                                       out,
  76                                       frame_low, frame_high);
  77 }
  78
  79 /* Print a list of the stack frames.  Args can be none, in which case
  80    we want to print the whole backtrace, or a pair of numbers
  81    specifying the frame numbers at which to start and stop the
  82    display.  If the two numbers are equal, a single frame will be
  83    displayed.  */
  84
  85 void
  86 mi_cmd_stack_list_frames (const char *command, const char *const *argv,
  87                           int argc)
  88 {
  89   int frame_low;
  90   int frame_high;
  91   int i;
  92   frame_info_ptr fi;
  93   enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
  94   int raw_arg = 0;
  95   int oind = 0;
  96   enum opt
  97     {
  98       NO_FRAME_FILTERS
  99     };
 100   static const struct mi_opt opts[] =
 101     {
 102       {"-no-frame-filters", NO_FRAME_FILTERS, 0},
 103       { 0, 0, 0 }
 104     };
 105
 106   /* Parse arguments.  In this instance we are just looking for
 107      --no-frame-filters.  */
 108   while (1)
 109     {
 110       const char *oarg;
 111       int opt = mi_getopt ("-stack-list-frames", argc, argv,
 112                            opts, &oind, &oarg);
 113       if (opt < 0)
 114         break;
 115       switch ((enum opt) opt)
 116         {
 117         case NO_FRAME_FILTERS:
 118           raw_arg = oind;
 119           break;
 120         }
 121     }
 122
 123   /* After the last option is parsed, there should either be low -
 124      high range, or no further arguments.  */
 125   if ((argc - oind != 0) && (argc - oind != 2))
 126     error (_("-stack-list-frames: Usage: [--no-frame-filters] [FRAME_LOW FRAME_HIGH]"));
 127
 128   /* If there is a range, set it.  */
 129   if (argc - oind == 2)
 130     {
 131       frame_low = atoi (argv[0 + oind]);
 132       frame_high = atoi (argv[1 + oind]);
 133     }
 134   else
 135     {
 136       /* Called with no arguments, it means we want the whole
 137          backtrace.  */
 138       frame_low = -1;
 139       frame_high = -1;
 140     }
 141
 142   /* Let's position fi on the frame at which to start the
 143      display. Could be the innermost frame if the whole stack needs
 144      displaying, or if frame_low is 0.  */
 145   for (i = 0, fi = get_current_frame ();
 146        fi && i < frame_low;
 147        i++, fi = get_prev_frame (fi));
 148
 149   if (fi == NULL)
 150     error (_("-stack-list-frames: Not enough frames in stack."));
 151
 152   ui_out_emit_list list_emitter (current_uiout, "stack");
 153
 154   if (! raw_arg && frame_filters)
 155     {
 156       frame_filter_flags flags = PRINT_LEVEL | PRINT_FRAME_INFO;
 157       int py_frame_low = frame_low;
 158
 159       /* We cannot pass -1 to frame_low, as that would signify a
 160       relative backtrace from the tail of the stack.  So, in the case
 161       of frame_low == -1, assign and increment it.  */
 162       if (py_frame_low == -1)
 163         py_frame_low++;
 164
 165       result = apply_ext_lang_frame_filter (get_current_frame (), flags,
 166                                             NO_VALUES,  current_uiout,
 167                                             py_frame_low, frame_high);
 168     }
 169
 170   /* Run the inbuilt backtrace if there are no filters registered, or
 171      if "--no-frame-filters" has been specified from the command.  */
 172   if (! frame_filters || raw_arg  || result == EXT_LANG_BT_NO_FILTERS)
 173     {
 174       /* Now let's print the frames up to frame_high, or until there are
 175          frames in the stack.  */
 176       for (;
 177            fi && (i <= frame_high || frame_high == -1);
 178            i++, fi = get_prev_frame (fi))
 179         {
 180           QUIT;
 181           /* Print the location and the address always, even for level 0.
 182              If args is 0, don't print the arguments.  */
 183           print_frame_info (user_frame_print_options,
 184                             fi, 1, LOC_AND_ADDRESS, 0 /* args */, 0);
 185         }
 186     }
 187 }
 188
 189 void
 190 mi_cmd_stack_info_depth (const char *command, const char *const *argv,
 191                          int argc)
 192 {
 193   int frame_high;
 194   int i;
 195   frame_info_ptr fi;
 196
 197   if (argc > 1)
 198     error (_("-stack-info-depth: Usage: [MAX_DEPTH]"));
 199
 200   if (argc == 1)
 201     frame_high = atoi (argv[0]);
 202   else
 203     /* Called with no arguments, it means we want the real depth of
 204        the stack.  */
 205     frame_high = -1;
 206
 207   for (i = 0, fi = get_current_frame ();
 208        fi && (i < frame_high || frame_high == -1);
 209        i++, fi = get_prev_frame (fi))
 210     QUIT;
 211
 212   current_uiout->field_signed ("depth", i);
 213 }
 214
 215 /* Print a list of the locals for the current frame.  With argument of
 216    0, print only the names, with argument of 1 print also the
 217    values.  */
 218
 219 void
 220 mi_cmd_stack_list_locals (const char *command, const char *const *argv,
 221                           int argc)
 222 {
 223   frame_info_ptr frame;
 224   int raw_arg = 0;
 225   enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
 226   enum print_values print_value;
 227   int oind = 0;
 228   int skip_unavailable = 0;
 229
 230   if (argc > 1)
 231     {
 232       enum opt
 233       {
 234         NO_FRAME_FILTERS,
 235         SKIP_UNAVAILABLE,
 236       };
 237       static const struct mi_opt opts[] =
 238         {
 239           {"-no-frame-filters", NO_FRAME_FILTERS, 0},
 240           {"-skip-unavailable", SKIP_UNAVAILABLE, 0},
 241           { 0, 0, 0 }
 242         };
 243
 244       while (1)
 245         {
 246           const char *oarg;
 247           /* Don't parse 'print-values' as an option.  */
 248           int opt = mi_getopt ("-stack-list-locals", argc - 1, argv,
 249                                opts, &oind, &oarg);
 250
 251           if (opt < 0)
 252             break;
 253           switch ((enum opt) opt)
 254             {
 255             case NO_FRAME_FILTERS:
 256               raw_arg = oind;
 257               break;
 258             case SKIP_UNAVAILABLE:
 259               skip_unavailable = 1;
 260               break;
 261             }
 262         }
 263     }
 264
 265   /* After the last option is parsed, there should be only
 266      'print-values'.  */
 267   if (argc - oind != 1)
 268     error (_("-stack-list-locals: Usage: [--no-frame-filters] "
 269              "[--skip-unavailable] PRINT_VALUES"));
 270
 271   frame = get_selected_frame (NULL);
 272   print_value = mi_parse_print_values (argv[oind]);
 273
 274    if (! raw_arg && frame_filters)
 275      {
 276        frame_filter_flags flags = PRINT_LEVEL | PRINT_LOCALS;
 277
 278        result = mi_apply_ext_lang_frame_filter (frame, flags, print_value,
 279                                                 current_uiout, 0, 0);
 280      }
 281
 282    /* Run the inbuilt backtrace if there are no filters registered, or
 283       if "--no-frame-filters" has been specified from the command.  */
 284    if (! frame_filters || raw_arg  || result == EXT_LANG_BT_NO_FILTERS)
 285      {
 286        list_args_or_locals (user_frame_print_options,
 287                             locals, print_value, frame,
 288                             skip_unavailable);
 289      }
 290 }
 291
 292 /* Print a list of the arguments for the current frame.  With argument
 293    of 0, print only the names, with argument of 1 print also the
 294    values.  */
 295
 296 void
 297 mi_cmd_stack_list_args (const char *command, const char *const *argv, int argc)
 298 {
 299   int frame_low;
 300   int frame_high;
 301   int i;
 302   frame_info_ptr fi;
 303   enum print_values print_values;
 304   struct ui_out *uiout = current_uiout;
 305   int raw_arg = 0;
 306   int oind = 0;
 307   int skip_unavailable = 0;
 308   enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
 309   enum opt
 310   {
 311     NO_FRAME_FILTERS,
 312     SKIP_UNAVAILABLE,
 313   };
 314   static const struct mi_opt opts[] =
 315     {
 316       {"-no-frame-filters", NO_FRAME_FILTERS, 0},
 317       {"-skip-unavailable", SKIP_UNAVAILABLE, 0},
 318       { 0, 0, 0 }
 319     };
 320
 321   while (1)
 322     {
 323       const char *oarg;
 324       int opt = mi_getopt_allow_unknown ("-stack-list-args", argc, argv,
 325                                          opts, &oind, &oarg);
 326
 327       if (opt < 0)
 328         break;
 329       switch ((enum opt) opt)
 330         {
 331         case NO_FRAME_FILTERS:
 332           raw_arg = oind;
 333           break;
 334         case SKIP_UNAVAILABLE:
 335           skip_unavailable = 1;
 336           break;
 337         }
 338     }
 339
 340   if (argc - oind != 1 && argc - oind != 3)
 341     error (_("-stack-list-arguments: Usage: "   \
 342              "[--no-frame-filters] [--skip-unavailable] "
 343              "PRINT_VALUES [FRAME_LOW FRAME_HIGH]"));
 344
 345   if (argc - oind == 3)
 346     {
 347       frame_low = atoi (argv[1 + oind]);
 348       frame_high = atoi (argv[2 + oind]);
 349     }
 350   else
 351     {
 352       /* Called with no arguments, it means we want args for the whole
 353          backtrace.  */
 354       frame_low = -1;
 355       frame_high = -1;
 356     }
 357
 358   print_values = mi_parse_print_values (argv[oind]);
 359
 360   /* Let's position fi on the frame at which to start the
 361      display. Could be the innermost frame if the whole stack needs
 362      displaying, or if frame_low is 0.  */
 363   for (i = 0, fi = get_current_frame ();
 364        fi && i < frame_low;
 365        i++, fi = get_prev_frame (fi));
 366
 367   if (fi == NULL)
 368     error (_("-stack-list-arguments: Not enough frames in stack."));
 369
 370   ui_out_emit_list list_emitter (uiout, "stack-args");
 371
 372   if (! raw_arg && frame_filters)
 373     {
 374       frame_filter_flags flags = PRINT_LEVEL | PRINT_ARGS;
 375       int py_frame_low = frame_low;
 376
 377       /* We cannot pass -1 to frame_low, as that would signify a
 378       relative backtrace from the tail of the stack.  So, in the case
 379       of frame_low == -1, assign and increment it.  */
 380       if (py_frame_low == -1)
 381         py_frame_low++;
 382
 383       result = mi_apply_ext_lang_frame_filter (get_current_frame (), flags,
 384                                                print_values, current_uiout,
 385                                                py_frame_low, frame_high);
 386     }
 387
 388      /* Run the inbuilt backtrace if there are no filters registered, or
 389       if "--no-frame-filters" has been specified from the command.  */
 390    if (! frame_filters || raw_arg  || result == EXT_LANG_BT_NO_FILTERS)
 391      {
 392       /* Now let's print the frames up to frame_high, or until there are
 393          frames in the stack.  */
 394       for (;
 395            fi && (i <= frame_high || frame_high == -1);
 396            i++, fi = get_prev_frame (fi))
 397         {
 398           QUIT;
 399           ui_out_emit_tuple tuple_emitter (uiout, "frame");
 400           uiout->field_signed ("level", i);
 401           list_args_or_locals (user_frame_print_options,
 402                                arguments, print_values, fi, skip_unavailable);
 403         }
 404     }
 405 }
 406
 407 /* Print a list of the local variables (including arguments) for the
 408    current frame.  ARGC must be 1 and ARGV[0] specify if only the names,
 409    or both names and values of the variables must be printed.  See
 410    parse_print_value for possible values.  */
 411
 412 void
 413 mi_cmd_stack_list_variables (const char *command, const char *const *argv,
 414                              int argc)
 415 {
 416   frame_info_ptr frame;
 417   int raw_arg = 0;
 418   enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
 419   enum print_values print_value;
 420   int oind = 0;
 421   int skip_unavailable = 0;
 422
 423   if (argc > 1)
 424     {
 425       enum opt
 426       {
 427         NO_FRAME_FILTERS,
 428         SKIP_UNAVAILABLE,
 429       };
 430       static const struct mi_opt opts[] =
 431         {
 432           {"-no-frame-filters", NO_FRAME_FILTERS, 0},
 433           {"-skip-unavailable", SKIP_UNAVAILABLE, 0},
 434           { 0, 0, 0 }
 435         };
 436
 437       while (1)
 438         {
 439           const char *oarg;
 440           /* Don't parse 'print-values' as an option.  */
 441           int opt = mi_getopt ("-stack-list-variables", argc - 1,
 442                                argv, opts, &oind, &oarg);
 443           if (opt < 0)
 444             break;
 445           switch ((enum opt) opt)
 446             {
 447             case NO_FRAME_FILTERS:
 448               raw_arg = oind;
 449               break;
 450             case SKIP_UNAVAILABLE:
 451               skip_unavailable = 1;
 452               break;
 453             }
 454         }
 455     }
 456
 457   /* After the last option is parsed, there should be only
 458      'print-values'.  */
 459   if (argc - oind != 1)
 460     error (_("-stack-list-variables: Usage: [--no-frame-filters] " \
 461              "[--skip-unavailable] PRINT_VALUES"));
 462
 463    frame = get_selected_frame (NULL);
 464    print_value = mi_parse_print_values (argv[oind]);
 465
 466    if (! raw_arg && frame_filters)
 467      {
 468        frame_filter_flags flags = PRINT_LEVEL | PRINT_ARGS | PRINT_LOCALS;
 469
 470        result = mi_apply_ext_lang_frame_filter (frame, flags,
 471                                                 print_value,
 472                                                 current_uiout, 0, 0);
 473      }
 474
 475    /* Run the inbuilt backtrace if there are no filters registered, or
 476       if "--no-frame-filters" has been specified from the command.  */
 477    if (! frame_filters || raw_arg  || result == EXT_LANG_BT_NO_FILTERS)
 478      {
 479        list_args_or_locals (user_frame_print_options,
 480                             all, print_value, frame,
 481                             skip_unavailable);
 482      }
 483 }
 484
 485 /* Print single local or argument.  ARG must be already read in.  For
 486    WHAT and VALUES see list_args_or_locals.
 487
 488    Errors are printed as if they would be the parameter value.  Use
 489    zeroed ARG iff it should not be printed according to VALUES.  If
 490    SKIP_UNAVAILABLE is true, only print ARG if it is available.  */
 491
 492 static void
 493 list_arg_or_local (const struct frame_arg *arg, enum what_to_list what,
 494                    enum print_values values, int skip_unavailable)
 495 {
 496   struct ui_out *uiout = current_uiout;
 497
 498   gdb_assert (!arg->val || !arg->error);
 499   gdb_assert ((values == PRINT_NO_VALUES && arg->val == NULL
 500                && arg->error == NULL)
 501               || values == PRINT_SIMPLE_VALUES
 502               || (values == PRINT_ALL_VALUES
 503                   && (arg->val != NULL || arg->error != NULL)));
 504   gdb_assert (arg->entry_kind == print_entry_values_no
 505               || (arg->entry_kind == print_entry_values_only
 506                   && (arg->val || arg->error)));
 507
 508   if (skip_unavailable && arg->val != NULL
 509       && (arg->val->entirely_unavailable ()
 510           /* A scalar object that does not have all bits available is
 511              also considered unavailable, because all bits contribute
 512              to its representation.  */
 513           || (val_print_scalar_type_p (arg->val->type ())
 514               && !arg->val->bytes_available (arg->val->embedded_offset (),
 515                                              arg->val->type ()->length ()))))
 516     return;
 517
 518   std::optional<ui_out_emit_tuple> tuple_emitter;
 519   if (values != PRINT_NO_VALUES || what == all)
 520     tuple_emitter.emplace (uiout, nullptr);
 521
 522   string_file stb;
 523
 524   stb.puts (arg->sym->print_name ());
 525   if (arg->entry_kind == print_entry_values_only)
 526     stb.puts ("@entry");
 527   uiout->field_stream ("name", stb);
 528
 529   if (what == all && arg->sym->is_argument ())
 530     uiout->field_signed ("arg", 1);
 531
 532   if (values == PRINT_SIMPLE_VALUES)
 533     {
 534       check_typedef (arg->sym->type ());
 535       type_print (arg->sym->type (), "", &stb, -1);
 536       uiout->field_stream ("type", stb);
 537     }
 538
 539   if (arg->val || arg->error)
 540     {
 541       if (arg->error)
 542         stb.printf (_("<error reading variable: %s>"), arg->error.get ());
 543       else
 544         {
 545           try
 546             {
 547               struct value_print_options opts;
 548
 549               get_no_prettyformat_print_options (&opts);
 550               opts.deref_ref = true;
 551               common_val_print (arg->val, &stb, 0, &opts,
 552                                 language_def (arg->sym->language ()));
 553             }
 554           catch (const gdb_exception_error &except)
 555             {
 556               stb.printf (_("<error reading variable: %s>"),
 557                           except.what ());
 558             }
 559         }
 560       uiout->field_stream ("value", stb);
 561     }
 562 }
 563
 564 /* Print a list of the objects for the frame FI in a certain form,
 565    which is determined by VALUES.  The objects can be locals,
 566    arguments or both, which is determined by WHAT.  If SKIP_UNAVAILABLE
 567    is true, only print the arguments or local variables whose values
 568    are available.  */
 569
 570 static void
 571 list_args_or_locals (const frame_print_options &fp_opts,
 572                      enum what_to_list what, enum print_values values,
 573                      frame_info_ptr fi, int skip_unavailable)
 574 {
 575   const struct block *block;
 576   const char *name_of_result;
 577   struct ui_out *uiout = current_uiout;
 578
 579   block = get_frame_block (fi, 0);
 580
 581   switch (what)
 582     {
 583     case locals:
 584       name_of_result = "locals";
 585       break;
 586     case arguments:
 587       name_of_result = "args";
 588       break;
 589     case all:
 590       name_of_result = "variables";
 591       break;
 592     default:
 593       internal_error ("unexpected what_to_list: %d", (int) what);
 594     }
 595
 596   ui_out_emit_list list_emitter (uiout, name_of_result);
 597
 598   while (block != 0)
 599     {
 600       for (struct symbol *sym : block_iterator_range (block))
 601         {
 602           int print_me = 0;
 603
 604           switch (sym->aclass ())
 605             {
 606             default:
 607             case LOC_UNDEF:     /* catches errors        */
 608             case LOC_CONST:     /* constant              */
 609             case LOC_TYPEDEF:   /* local typedef         */
 610             case LOC_LABEL:     /* local label           */
 611             case LOC_BLOCK:     /* local function        */
 612             case LOC_CONST_BYTES:       /* loc. byte seq.        */
 613             case LOC_UNRESOLVED:        /* unresolved static     */
 614             case LOC_OPTIMIZED_OUT:     /* optimized out         */
 615               print_me = 0;
 616               break;
 617
 618             case LOC_ARG:       /* argument              */
 619             case LOC_REF_ARG:   /* reference arg         */
 620             case LOC_REGPARM_ADDR:      /* indirect register arg */
 621             case LOC_LOCAL:     /* stack local           */
 622             case LOC_STATIC:    /* static                */
 623             case LOC_REGISTER:  /* register              */
 624             case LOC_COMPUTED:  /* computed location     */
 625               if (what == all)
 626                 print_me = 1;
 627               else if (what == locals)
 628                 print_me = !sym->is_argument ();
 629               else
 630                 print_me = sym->is_argument ();
 631               break;
 632             }
 633           if (print_me)
 634             {
 635               struct symbol *sym2;
 636               struct frame_arg arg, entryarg;
 637
 638               if (sym->is_argument ())
 639                 sym2 = lookup_symbol_search_name (sym->search_name (),
 640                                                   block, VAR_DOMAIN).symbol;
 641               else
 642                 sym2 = sym;
 643               gdb_assert (sym2 != NULL);
 644
 645               arg.sym = sym2;
 646               arg.entry_kind = print_entry_values_no;
 647               entryarg.sym = sym2;
 648               entryarg.entry_kind = print_entry_values_no;
 649
 650               switch (values)
 651                 {
 652                 case PRINT_SIMPLE_VALUES:
 653                   if (!mi_simple_type_p (sym2->type ()))
 654                     break;
 655                   [[fallthrough]];
 656
 657                 case PRINT_ALL_VALUES:
 658                   if (sym->is_argument ())
 659                     read_frame_arg (fp_opts, sym2, fi, &arg, &entryarg);
 660                   else
 661                     read_frame_local (sym2, fi, &arg);
 662                   break;
 663                 }
 664
 665               if (arg.entry_kind != print_entry_values_only)
 666                 list_arg_or_local (&arg, what, values, skip_unavailable);
 667               if (entryarg.entry_kind != print_entry_values_no)
 668                 list_arg_or_local (&entryarg, what, values, skip_unavailable);
 669             }
 670         }
 671
 672       if (block->function ())
 673         break;
 674       else
 675         block = block->superblock ();
 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 frame_info_ptr
 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   frame_info_ptr 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 (id == get_frame_id (fid))
 731         {
 732           frame_info_ptr prev_frame;
 733
 734           while (1)
 735             {
 736               prev_frame = get_prev_frame (fid);
 737               if (!prev_frame
 738                   || 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, const char *const *argv,
 755                            int argc)
 756 {
 757   if (argc == 0 || argc > 1)
 758     error (_("-stack-select-frame: Usage: FRAME_SPEC"));
 759   select_frame (parse_frame_specification (argv[0]));
 760 }
 761
 762 void
 763 mi_cmd_stack_info_frame (const char *command, const char *const *argv,
 764                          int argc)
 765 {
 766   if (argc > 0)
 767     error (_("-stack-info-frame: No arguments allowed"));
 768
 769   print_frame_info (user_frame_print_options,
 770                     get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 0, 1);
 771 }