gdb/parse.c

   1 /* Parse expressions for GDB.
   2
   3    Copyright (C) 1986-2019 Free Software Foundation, Inc.
   4
   5    Modified from expread.y by the Department of Computer Science at the
   6    State University of New York at Buffalo, 1991.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 /* Parse an expression from text in a string,
  24    and return the result as a struct expression pointer.
  25    That structure contains arithmetic operations in reverse polish,
  26    with constants represented by operations that are followed by special data.
  27    See expression.h for the details of the format.
  28    What is important here is that it can be built up sequentially
  29    during the process of parsing; the lower levels of the tree always
  30    come first in the result.  */
  31
  32 #include "defs.h"
  33 #include <ctype.h>
  34 #include "arch-utils.h"
  35 #include "symtab.h"
  36 #include "gdbtypes.h"
  37 #include "frame.h"
  38 #include "expression.h"
  39 #include "value.h"
  40 #include "command.h"
  41 #include "language.h"
  42 #include "f-lang.h"
  43 #include "parser-defs.h"
  44 #include "gdbcmd.h"
  45 #include "symfile.h"            /* for overlay functions */
  46 #include "inferior.h"
  47 #include "target-float.h"
  48 #include "block.h"
  49 #include "source.h"
  50 #include "objfiles.h"
  51 #include "user-regs.h"
  52 #include <algorithm>
  53 #include "common/gdb_optional.h"
  54
  55 /* Standard set of definitions for printing, dumping, prefixifying,
  56  * and evaluating expressions.  */
  57
  58 const struct exp_descriptor exp_descriptor_standard =
  59   {
  60     print_subexp_standard,
  61     operator_length_standard,
  62     operator_check_standard,
  63     op_name_standard,
  64     dump_subexp_body_standard,
  65     evaluate_subexp_standard
  66   };
  67 \f
  68 /* Global variables declared in parser-defs.h (and commented there).  */
  69 innermost_block_tracker innermost_block;
  70
  71 \f
  72 static unsigned int expressiondebug = 0;
  73 static void
  74 show_expressiondebug (struct ui_file *file, int from_tty,
  75                       struct cmd_list_element *c, const char *value)
  76 {
  77   fprintf_filtered (file, _("Expression debugging is %s.\n"), value);
  78 }
  79
  80
  81 /* Non-zero if an expression parser should set yydebug.  */
  82 int parser_debug;
  83
  84 static void
  85 show_parserdebug (struct ui_file *file, int from_tty,
  86                   struct cmd_list_element *c, const char *value)
  87 {
  88   fprintf_filtered (file, _("Parser debugging is %s.\n"), value);
  89 }
  90
  91
  92 static int prefixify_subexp (struct expression *, struct expression *, int,
  93                              int, int);
  94
  95 static expression_up parse_exp_in_context (const char **, CORE_ADDR,
  96                                            const struct block *, int,
  97                                            int, int *,
  98                                            innermost_block_tracker_types,
  99                                            expr_completion_state *);
 100
 101 static void increase_expout_size (struct expr_builder *ps, size_t lenelt);
 102
 103
 104 /* Documented at it's declaration.  */
 105
 106 void
 107 innermost_block_tracker::update (const struct block *b,
 108                                  innermost_block_tracker_types t)
 109 {
 110   if ((m_types & t) != 0
 111       && (m_innermost_block == NULL
 112           || contained_in (b, m_innermost_block)))
 113     m_innermost_block = b;
 114 }
 115
 116 \f
 117
 118 /* See definition in parser-defs.h.  */
 119
 120 expr_builder::expr_builder (const struct language_defn *lang,
 121                             struct gdbarch *gdbarch)
 122   : expout_size (10),
 123     expout (XNEWVAR (expression,
 124                      (sizeof (expression)
 125                       + EXP_ELEM_TO_BYTES (expout_size)))),
 126     expout_ptr (0)
 127 {
 128   expout->language_defn = lang;
 129   expout->gdbarch = gdbarch;
 130 }
 131
 132 expression_up
 133 expr_builder::release ()
 134 {
 135   /* Record the actual number of expression elements, and then
 136      reallocate the expression memory so that we free up any
 137      excess elements.  */
 138
 139   expout->nelts = expout_ptr;
 140   expout.reset (XRESIZEVAR (expression, expout.release (),
 141                             (sizeof (expression)
 142                              + EXP_ELEM_TO_BYTES (expout_ptr))));
 143
 144   return std::move (expout);
 145 }
 146
 147 /* This page contains the functions for adding data to the struct expression
 148    being constructed.  */
 149
 150 /* Add one element to the end of the expression.  */
 151
 152 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
 153    a register through here.  */
 154
 155 static void
 156 write_exp_elt (struct expr_builder *ps, const union exp_element *expelt)
 157 {
 158   if (ps->expout_ptr >= ps->expout_size)
 159     {
 160       ps->expout_size *= 2;
 161       ps->expout.reset (XRESIZEVAR (expression, ps->expout.release (),
 162                                     (sizeof (expression)
 163                                      + EXP_ELEM_TO_BYTES (ps->expout_size))));
 164     }
 165   ps->expout->elts[ps->expout_ptr++] = *expelt;
 166 }
 167
 168 void
 169 write_exp_elt_opcode (struct expr_builder *ps, enum exp_opcode expelt)
 170 {
 171   union exp_element tmp;
 172
 173   memset (&tmp, 0, sizeof (union exp_element));
 174   tmp.opcode = expelt;
 175   write_exp_elt (ps, &tmp);
 176 }
 177
 178 void
 179 write_exp_elt_sym (struct expr_builder *ps, struct symbol *expelt)
 180 {
 181   union exp_element tmp;
 182
 183   memset (&tmp, 0, sizeof (union exp_element));
 184   tmp.symbol = expelt;
 185   write_exp_elt (ps, &tmp);
 186 }
 187
 188 void
 189 write_exp_elt_msym (struct expr_builder *ps, minimal_symbol *expelt)
 190 {
 191   union exp_element tmp;
 192
 193   memset (&tmp, 0, sizeof (union exp_element));
 194   tmp.msymbol = expelt;
 195   write_exp_elt (ps, &tmp);
 196 }
 197
 198 void
 199 write_exp_elt_block (struct expr_builder *ps, const struct block *b)
 200 {
 201   union exp_element tmp;
 202
 203   memset (&tmp, 0, sizeof (union exp_element));
 204   tmp.block = b;
 205   write_exp_elt (ps, &tmp);
 206 }
 207
 208 void
 209 write_exp_elt_objfile (struct expr_builder *ps, struct objfile *objfile)
 210 {
 211   union exp_element tmp;
 212
 213   memset (&tmp, 0, sizeof (union exp_element));
 214   tmp.objfile = objfile;
 215   write_exp_elt (ps, &tmp);
 216 }
 217
 218 void
 219 write_exp_elt_longcst (struct expr_builder *ps, LONGEST expelt)
 220 {
 221   union exp_element tmp;
 222
 223   memset (&tmp, 0, sizeof (union exp_element));
 224   tmp.longconst = expelt;
 225   write_exp_elt (ps, &tmp);
 226 }
 227
 228 void
 229 write_exp_elt_floatcst (struct expr_builder *ps, const gdb_byte expelt[16])
 230 {
 231   union exp_element tmp;
 232   int index;
 233
 234   for (index = 0; index < 16; index++)
 235     tmp.floatconst[index] = expelt[index];
 236
 237   write_exp_elt (ps, &tmp);
 238 }
 239
 240 void
 241 write_exp_elt_type (struct expr_builder *ps, struct type *expelt)
 242 {
 243   union exp_element tmp;
 244
 245   memset (&tmp, 0, sizeof (union exp_element));
 246   tmp.type = expelt;
 247   write_exp_elt (ps, &tmp);
 248 }
 249
 250 void
 251 write_exp_elt_intern (struct expr_builder *ps, struct internalvar *expelt)
 252 {
 253   union exp_element tmp;
 254
 255   memset (&tmp, 0, sizeof (union exp_element));
 256   tmp.internalvar = expelt;
 257   write_exp_elt (ps, &tmp);
 258 }
 259
 260 /* Add a string constant to the end of the expression.
 261
 262    String constants are stored by first writing an expression element
 263    that contains the length of the string, then stuffing the string
 264    constant itself into however many expression elements are needed
 265    to hold it, and then writing another expression element that contains
 266    the length of the string.  I.e. an expression element at each end of
 267    the string records the string length, so you can skip over the
 268    expression elements containing the actual string bytes from either
 269    end of the string.  Note that this also allows gdb to handle
 270    strings with embedded null bytes, as is required for some languages.
 271
 272    Don't be fooled by the fact that the string is null byte terminated,
 273    this is strictly for the convenience of debugging gdb itself.
 274    Gdb does not depend up the string being null terminated, since the
 275    actual length is recorded in expression elements at each end of the
 276    string.  The null byte is taken into consideration when computing how
 277    many expression elements are required to hold the string constant, of
 278    course.  */
 279
 280
 281 void
 282 write_exp_string (struct expr_builder *ps, struct stoken str)
 283 {
 284   int len = str.length;
 285   size_t lenelt;
 286   char *strdata;
 287
 288   /* Compute the number of expression elements required to hold the string
 289      (including a null byte terminator), along with one expression element
 290      at each end to record the actual string length (not including the
 291      null byte terminator).  */
 292
 293   lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
 294
 295   increase_expout_size (ps, lenelt);
 296
 297   /* Write the leading length expression element (which advances the current
 298      expression element index), then write the string constant followed by a
 299      terminating null byte, and then write the trailing length expression
 300      element.  */
 301
 302   write_exp_elt_longcst (ps, (LONGEST) len);
 303   strdata = (char *) &ps->expout->elts[ps->expout_ptr];
 304   memcpy (strdata, str.ptr, len);
 305   *(strdata + len) = '\0';
 306   ps->expout_ptr += lenelt - 2;
 307   write_exp_elt_longcst (ps, (LONGEST) len);
 308 }
 309
 310 /* Add a vector of string constants to the end of the expression.
 311
 312    This adds an OP_STRING operation, but encodes the contents
 313    differently from write_exp_string.  The language is expected to
 314    handle evaluation of this expression itself.
 315
 316    After the usual OP_STRING header, TYPE is written into the
 317    expression as a long constant.  The interpretation of this field is
 318    up to the language evaluator.
 319
 320    Next, each string in VEC is written.  The length is written as a
 321    long constant, followed by the contents of the string.  */
 322
 323 void
 324 write_exp_string_vector (struct expr_builder *ps, int type,
 325                          struct stoken_vector *vec)
 326 {
 327   int i, len;
 328   size_t n_slots;
 329
 330   /* Compute the size.  We compute the size in number of slots to
 331      avoid issues with string padding.  */
 332   n_slots = 0;
 333   for (i = 0; i < vec->len; ++i)
 334     {
 335       /* One slot for the length of this element, plus the number of
 336          slots needed for this string.  */
 337       n_slots += 1 + BYTES_TO_EXP_ELEM (vec->tokens[i].length);
 338     }
 339
 340   /* One more slot for the type of the string.  */
 341   ++n_slots;
 342
 343   /* Now compute a phony string length.  */
 344   len = EXP_ELEM_TO_BYTES (n_slots) - 1;
 345
 346   n_slots += 4;
 347   increase_expout_size (ps, n_slots);
 348
 349   write_exp_elt_opcode (ps, OP_STRING);
 350   write_exp_elt_longcst (ps, len);
 351   write_exp_elt_longcst (ps, type);
 352
 353   for (i = 0; i < vec->len; ++i)
 354     {
 355       write_exp_elt_longcst (ps, vec->tokens[i].length);
 356       memcpy (&ps->expout->elts[ps->expout_ptr], vec->tokens[i].ptr,
 357               vec->tokens[i].length);
 358       ps->expout_ptr += BYTES_TO_EXP_ELEM (vec->tokens[i].length);
 359     }
 360
 361   write_exp_elt_longcst (ps, len);
 362   write_exp_elt_opcode (ps, OP_STRING);
 363 }
 364
 365 /* Add a bitstring constant to the end of the expression.
 366
 367    Bitstring constants are stored by first writing an expression element
 368    that contains the length of the bitstring (in bits), then stuffing the
 369    bitstring constant itself into however many expression elements are
 370    needed to hold it, and then writing another expression element that
 371    contains the length of the bitstring.  I.e. an expression element at
 372    each end of the bitstring records the bitstring length, so you can skip
 373    over the expression elements containing the actual bitstring bytes from
 374    either end of the bitstring.  */
 375
 376 void
 377 write_exp_bitstring (struct expr_builder *ps, struct stoken str)
 378 {
 379   int bits = str.length;        /* length in bits */
 380   int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 381   size_t lenelt;
 382   char *strdata;
 383
 384   /* Compute the number of expression elements required to hold the bitstring,
 385      along with one expression element at each end to record the actual
 386      bitstring length in bits.  */
 387
 388   lenelt = 2 + BYTES_TO_EXP_ELEM (len);
 389
 390   increase_expout_size (ps, lenelt);
 391
 392   /* Write the leading length expression element (which advances the current
 393      expression element index), then write the bitstring constant, and then
 394      write the trailing length expression element.  */
 395
 396   write_exp_elt_longcst (ps, (LONGEST) bits);
 397   strdata = (char *) &ps->expout->elts[ps->expout_ptr];
 398   memcpy (strdata, str.ptr, len);
 399   ps->expout_ptr += lenelt - 2;
 400   write_exp_elt_longcst (ps, (LONGEST) bits);
 401 }
 402
 403 /* Return the type of MSYMBOL, a minimal symbol of OBJFILE.  If
 404    ADDRESS_P is not NULL, set it to the MSYMBOL's resolved
 405    address.  */
 406
 407 type *
 408 find_minsym_type_and_address (minimal_symbol *msymbol,
 409                               struct objfile *objfile,
 410                               CORE_ADDR *address_p)
 411 {
 412   bound_minimal_symbol bound_msym = {msymbol, objfile};
 413   struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
 414   enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
 415
 416   bool is_tls = (section != NULL
 417                  && section->the_bfd_section->flags & SEC_THREAD_LOCAL);
 418
 419   /* The minimal symbol might point to a function descriptor;
 420      resolve it to the actual code address instead.  */
 421   CORE_ADDR addr;
 422   if (is_tls)
 423     {
 424       /* Addresses of TLS symbols are really offsets into a
 425          per-objfile/per-thread storage block.  */
 426       addr = MSYMBOL_VALUE_RAW_ADDRESS (bound_msym.minsym);
 427     }
 428   else if (msymbol_is_function (objfile, msymbol, &addr))
 429     {
 430       if (addr != BMSYMBOL_VALUE_ADDRESS (bound_msym))
 431         {
 432           /* This means we resolved a function descriptor, and we now
 433              have an address for a code/text symbol instead of a data
 434              symbol.  */
 435           if (MSYMBOL_TYPE (msymbol) == mst_data_gnu_ifunc)
 436             type = mst_text_gnu_ifunc;
 437           else
 438             type = mst_text;
 439           section = NULL;
 440         }
 441     }
 442   else
 443     addr = BMSYMBOL_VALUE_ADDRESS (bound_msym);
 444
 445   if (overlay_debugging)
 446     addr = symbol_overlayed_address (addr, section);
 447
 448   if (is_tls)
 449     {
 450       /* Skip translation if caller does not need the address.  */
 451       if (address_p != NULL)
 452         *address_p = target_translate_tls_address (objfile, addr);
 453       return objfile_type (objfile)->nodebug_tls_symbol;
 454     }
 455
 456   if (address_p != NULL)
 457     *address_p = addr;
 458
 459   switch (type)
 460     {
 461     case mst_text:
 462     case mst_file_text:
 463     case mst_solib_trampoline:
 464       return objfile_type (objfile)->nodebug_text_symbol;
 465
 466     case mst_text_gnu_ifunc:
 467       return objfile_type (objfile)->nodebug_text_gnu_ifunc_symbol;
 468
 469     case mst_data:
 470     case mst_file_data:
 471     case mst_bss:
 472     case mst_file_bss:
 473       return objfile_type (objfile)->nodebug_data_symbol;
 474
 475     case mst_slot_got_plt:
 476       return objfile_type (objfile)->nodebug_got_plt_symbol;
 477
 478     default:
 479       return objfile_type (objfile)->nodebug_unknown_symbol;
 480     }
 481 }
 482
 483 /* Add the appropriate elements for a minimal symbol to the end of
 484    the expression.  */
 485
 486 void
 487 write_exp_msymbol (struct expr_builder *ps,
 488                    struct bound_minimal_symbol bound_msym)
 489 {
 490   write_exp_elt_opcode (ps, OP_VAR_MSYM_VALUE);
 491   write_exp_elt_objfile (ps, bound_msym.objfile);
 492   write_exp_elt_msym (ps, bound_msym.minsym);
 493   write_exp_elt_opcode (ps, OP_VAR_MSYM_VALUE);
 494 }
 495
 496 /* See parser-defs.h.  */
 497
 498 void
 499 parser_state::mark_struct_expression ()
 500 {
 501   gdb_assert (parse_completion
 502               && (m_completion_state.expout_tag_completion_type
 503                   == TYPE_CODE_UNDEF));
 504   m_completion_state.expout_last_struct = expout_ptr;
 505 }
 506
 507 /* Indicate that the current parser invocation is completing a tag.
 508    TAG is the type code of the tag, and PTR and LENGTH represent the
 509    start of the tag name.  */
 510
 511 void
 512 parser_state::mark_completion_tag (enum type_code tag, const char *ptr,
 513                                    int length)
 514 {
 515   gdb_assert (parse_completion
 516               && (m_completion_state.expout_tag_completion_type
 517                   == TYPE_CODE_UNDEF)
 518               && m_completion_state.expout_completion_name == NULL
 519               && m_completion_state.expout_last_struct == -1);
 520   gdb_assert (tag == TYPE_CODE_UNION
 521               || tag == TYPE_CODE_STRUCT
 522               || tag == TYPE_CODE_ENUM);
 523   m_completion_state.expout_tag_completion_type = tag;
 524   m_completion_state.expout_completion_name.reset (xstrndup (ptr, length));
 525 }
 526
 527 \f
 528 /* Recognize tokens that start with '$'.  These include:
 529
 530    $regname     A native register name or a "standard
 531    register name".
 532
 533    $variable    A convenience variable with a name chosen
 534    by the user.
 535
 536    $digits              Value history with index <digits>, starting
 537    from the first value which has index 1.
 538
 539    $$digits     Value history with index <digits> relative
 540    to the last value.  I.e. $$0 is the last
 541    value, $$1 is the one previous to that, $$2
 542    is the one previous to $$1, etc.
 543
 544    $ | $0 | $$0 The last value in the value history.
 545
 546    $$           An abbreviation for the second to the last
 547    value in the value history, I.e. $$1  */
 548
 549 void
 550 write_dollar_variable (struct parser_state *ps, struct stoken str)
 551 {
 552   struct block_symbol sym;
 553   struct bound_minimal_symbol msym;
 554   struct internalvar *isym = NULL;
 555
 556   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
 557      and $$digits (equivalent to $<-digits> if you could type that).  */
 558
 559   int negate = 0;
 560   int i = 1;
 561   /* Double dollar means negate the number and add -1 as well.
 562      Thus $$ alone means -1.  */
 563   if (str.length >= 2 && str.ptr[1] == '$')
 564     {
 565       negate = 1;
 566       i = 2;
 567     }
 568   if (i == str.length)
 569     {
 570       /* Just dollars (one or two).  */
 571       i = -negate;
 572       goto handle_last;
 573     }
 574   /* Is the rest of the token digits?  */
 575   for (; i < str.length; i++)
 576     if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
 577       break;
 578   if (i == str.length)
 579     {
 580       i = atoi (str.ptr + 1 + negate);
 581       if (negate)
 582         i = -i;
 583       goto handle_last;
 584     }
 585
 586   /* Handle tokens that refer to machine registers:
 587      $ followed by a register name.  */
 588   i = user_reg_map_name_to_regnum (ps->gdbarch (),
 589                                    str.ptr + 1, str.length - 1);
 590   if (i >= 0)
 591     goto handle_register;
 592
 593   /* Any names starting with $ are probably debugger internal variables.  */
 594
 595   isym = lookup_only_internalvar (copy_name (str) + 1);
 596   if (isym)
 597     {
 598       write_exp_elt_opcode (ps, OP_INTERNALVAR);
 599       write_exp_elt_intern (ps, isym);
 600       write_exp_elt_opcode (ps, OP_INTERNALVAR);
 601       return;
 602     }
 603
 604   /* On some systems, such as HP-UX and hppa-linux, certain system routines
 605      have names beginning with $ or $$.  Check for those, first.  */
 606
 607   sym = lookup_symbol (copy_name (str), NULL, VAR_DOMAIN, NULL);
 608   if (sym.symbol)
 609     {
 610       write_exp_elt_opcode (ps, OP_VAR_VALUE);
 611       write_exp_elt_block (ps, sym.block);
 612       write_exp_elt_sym (ps, sym.symbol);
 613       write_exp_elt_opcode (ps, OP_VAR_VALUE);
 614       return;
 615     }
 616   msym = lookup_bound_minimal_symbol (copy_name (str));
 617   if (msym.minsym)
 618     {
 619       write_exp_msymbol (ps, msym);
 620       return;
 621     }
 622
 623   /* Any other names are assumed to be debugger internal variables.  */
 624
 625   write_exp_elt_opcode (ps, OP_INTERNALVAR);
 626   write_exp_elt_intern (ps, create_internalvar (copy_name (str) + 1));
 627   write_exp_elt_opcode (ps, OP_INTERNALVAR);
 628   return;
 629 handle_last:
 630   write_exp_elt_opcode (ps, OP_LAST);
 631   write_exp_elt_longcst (ps, (LONGEST) i);
 632   write_exp_elt_opcode (ps, OP_LAST);
 633   return;
 634 handle_register:
 635   write_exp_elt_opcode (ps, OP_REGISTER);
 636   str.length--;
 637   str.ptr++;
 638   write_exp_string (ps, str);
 639   write_exp_elt_opcode (ps, OP_REGISTER);
 640   innermost_block.update (ps->expression_context_block,
 641                           INNERMOST_BLOCK_FOR_REGISTERS);
 642   return;
 643 }
 644
 645
 646 const char *
 647 find_template_name_end (const char *p)
 648 {
 649   int depth = 1;
 650   int just_seen_right = 0;
 651   int just_seen_colon = 0;
 652   int just_seen_space = 0;
 653
 654   if (!p || (*p != '<'))
 655     return 0;
 656
 657   while (*++p)
 658     {
 659       switch (*p)
 660         {
 661         case '\'':
 662         case '\"':
 663         case '{':
 664         case '}':
 665           /* In future, may want to allow these??  */
 666           return 0;
 667         case '<':
 668           depth++;              /* start nested template */
 669           if (just_seen_colon || just_seen_right || just_seen_space)
 670             return 0;           /* but not after : or :: or > or space */
 671           break;
 672         case '>':
 673           if (just_seen_colon || just_seen_right)
 674             return 0;           /* end a (nested?) template */
 675           just_seen_right = 1;  /* but not after : or :: */
 676           if (--depth == 0)     /* also disallow >>, insist on > > */
 677             return ++p;         /* if outermost ended, return */
 678           break;
 679         case ':':
 680           if (just_seen_space || (just_seen_colon > 1))
 681             return 0;           /* nested class spec coming up */
 682           just_seen_colon++;    /* we allow :: but not :::: */
 683           break;
 684         case ' ':
 685           break;
 686         default:
 687           if (!((*p >= 'a' && *p <= 'z') ||     /* allow token chars */
 688                 (*p >= 'A' && *p <= 'Z') ||
 689                 (*p >= '0' && *p <= '9') ||
 690                 (*p == '_') || (*p == ',') ||   /* commas for template args */
 691                 (*p == '&') || (*p == '*') ||   /* pointer and ref types */
 692                 (*p == '(') || (*p == ')') ||   /* function types */
 693                 (*p == '[') || (*p == ']')))    /* array types */
 694             return 0;
 695         }
 696       if (*p != ' ')
 697         just_seen_space = 0;
 698       if (*p != ':')
 699         just_seen_colon = 0;
 700       if (*p != '>')
 701         just_seen_right = 0;
 702     }
 703   return 0;
 704 }
 705 \f
 706
 707 /* Return a null-terminated temporary copy of the name of a string token.
 708
 709    Tokens that refer to names do so with explicit pointer and length,
 710    so they can share the storage that lexptr is parsing.
 711    When it is necessary to pass a name to a function that expects
 712    a null-terminated string, the substring is copied out
 713    into a separate block of storage.
 714
 715    N.B. A single buffer is reused on each call.  */
 716
 717 char *
 718 copy_name (struct stoken token)
 719 {
 720   /* A temporary buffer for identifiers, so we can null-terminate them.
 721      We allocate this with xrealloc.  parse_exp_1 used to allocate with
 722      alloca, using the size of the whole expression as a conservative
 723      estimate of the space needed.  However, macro expansion can
 724      introduce names longer than the original expression; there's no
 725      practical way to know beforehand how large that might be.  */
 726   static char *namecopy;
 727   static size_t namecopy_size;
 728
 729   /* Make sure there's enough space for the token.  */
 730   if (namecopy_size < token.length + 1)
 731     {
 732       namecopy_size = token.length + 1;
 733       namecopy = (char *) xrealloc (namecopy, token.length + 1);
 734     }
 735
 736   memcpy (namecopy, token.ptr, token.length);
 737   namecopy[token.length] = 0;
 738
 739   return namecopy;
 740 }
 741 \f
 742
 743 /* See comments on parser-defs.h.  */
 744
 745 int
 746 prefixify_expression (struct expression *expr, int last_struct)
 747 {
 748   gdb_assert (expr->nelts > 0);
 749   int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
 750   struct expression *temp;
 751   int inpos = expr->nelts, outpos = 0;
 752
 753   temp = (struct expression *) alloca (len);
 754
 755   /* Copy the original expression into temp.  */
 756   memcpy (temp, expr, len);
 757
 758   return prefixify_subexp (temp, expr, inpos, outpos, last_struct);
 759 }
 760
 761 /* Return the number of exp_elements in the postfix subexpression
 762    of EXPR whose operator is at index ENDPOS - 1 in EXPR.  */
 763
 764 static int
 765 length_of_subexp (struct expression *expr, int endpos)
 766 {
 767   int oplen, args;
 768
 769   operator_length (expr, endpos, &oplen, &args);
 770
 771   while (args > 0)
 772     {
 773       oplen += length_of_subexp (expr, endpos - oplen);
 774       args--;
 775     }
 776
 777   return oplen;
 778 }
 779
 780 /* Sets *OPLENP to the length of the operator whose (last) index is
 781    ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
 782    operator takes.  */
 783
 784 void
 785 operator_length (const struct expression *expr, int endpos, int *oplenp,
 786                  int *argsp)
 787 {
 788   expr->language_defn->la_exp_desc->operator_length (expr, endpos,
 789                                                      oplenp, argsp);
 790 }
 791
 792 /* Default value for operator_length in exp_descriptor vectors.  */
 793
 794 void
 795 operator_length_standard (const struct expression *expr, int endpos,
 796                           int *oplenp, int *argsp)
 797 {
 798   int oplen = 1;
 799   int args = 0;
 800   enum range_type range_type;
 801   int i;
 802
 803   if (endpos < 1)
 804     error (_("?error in operator_length_standard"));
 805
 806   i = (int) expr->elts[endpos - 1].opcode;
 807
 808   switch (i)
 809     {
 810       /* C++  */
 811     case OP_SCOPE:
 812       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 813       oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
 814       break;
 815
 816     case OP_LONG:
 817     case OP_FLOAT:
 818     case OP_VAR_VALUE:
 819     case OP_VAR_MSYM_VALUE:
 820       oplen = 4;
 821       break;
 822
 823     case OP_FUNC_STATIC_VAR:
 824       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 825       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 826       args = 1;
 827       break;
 828
 829     case OP_TYPE:
 830     case OP_BOOL:
 831     case OP_LAST:
 832     case OP_INTERNALVAR:
 833     case OP_VAR_ENTRY_VALUE:
 834       oplen = 3;
 835       break;
 836
 837     case OP_COMPLEX:
 838       oplen = 3;
 839       args = 2;
 840       break;
 841
 842     case OP_FUNCALL:
 843     case OP_F77_UNDETERMINED_ARGLIST:
 844       oplen = 3;
 845       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 846       break;
 847
 848     case TYPE_INSTANCE:
 849       oplen = 5 + longest_to_int (expr->elts[endpos - 2].longconst);
 850       args = 1;
 851       break;
 852
 853     case OP_OBJC_MSGCALL:       /* Objective C message (method) call.  */
 854       oplen = 4;
 855       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 856       break;
 857
 858     case UNOP_MAX:
 859     case UNOP_MIN:
 860       oplen = 3;
 861       break;
 862
 863     case UNOP_CAST_TYPE:
 864     case UNOP_DYNAMIC_CAST:
 865     case UNOP_REINTERPRET_CAST:
 866     case UNOP_MEMVAL_TYPE:
 867       oplen = 1;
 868       args = 2;
 869       break;
 870
 871     case BINOP_VAL:
 872     case UNOP_CAST:
 873     case UNOP_MEMVAL:
 874       oplen = 3;
 875       args = 1;
 876       break;
 877
 878     case UNOP_ABS:
 879     case UNOP_CAP:
 880     case UNOP_CHR:
 881     case UNOP_FLOAT:
 882     case UNOP_HIGH:
 883     case UNOP_KIND:
 884     case UNOP_ODD:
 885     case UNOP_ORD:
 886     case UNOP_TRUNC:
 887     case OP_TYPEOF:
 888     case OP_DECLTYPE:
 889     case OP_TYPEID:
 890       oplen = 1;
 891       args = 1;
 892       break;
 893
 894     case OP_ADL_FUNC:
 895       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 896       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 897       oplen++;
 898       oplen++;
 899       break;
 900
 901     case STRUCTOP_STRUCT:
 902     case STRUCTOP_PTR:
 903       args = 1;
 904       /* fall through */
 905     case OP_REGISTER:
 906     case OP_M2_STRING:
 907     case OP_STRING:
 908     case OP_OBJC_NSSTRING:      /* Objective C Foundation Class
 909                                    NSString constant.  */
 910     case OP_OBJC_SELECTOR:      /* Objective C "@selector" pseudo-op.  */
 911     case OP_NAME:
 912       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 913       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 914       break;
 915
 916     case OP_ARRAY:
 917       oplen = 4;
 918       args = longest_to_int (expr->elts[endpos - 2].longconst);
 919       args -= longest_to_int (expr->elts[endpos - 3].longconst);
 920       args += 1;
 921       break;
 922
 923     case TERNOP_COND:
 924     case TERNOP_SLICE:
 925       args = 3;
 926       break;
 927
 928       /* Modula-2 */
 929     case MULTI_SUBSCRIPT:
 930       oplen = 3;
 931       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 932       break;
 933
 934     case BINOP_ASSIGN_MODIFY:
 935       oplen = 3;
 936       args = 2;
 937       break;
 938
 939       /* C++ */
 940     case OP_THIS:
 941       oplen = 2;
 942       break;
 943
 944     case OP_RANGE:
 945       oplen = 3;
 946       range_type = (enum range_type)
 947         longest_to_int (expr->elts[endpos - 2].longconst);
 948
 949       switch (range_type)
 950         {
 951         case LOW_BOUND_DEFAULT:
 952         case LOW_BOUND_DEFAULT_EXCLUSIVE:
 953         case HIGH_BOUND_DEFAULT:
 954           args = 1;
 955           break;
 956         case BOTH_BOUND_DEFAULT:
 957           args = 0;
 958           break;
 959         case NONE_BOUND_DEFAULT:
 960         case NONE_BOUND_DEFAULT_EXCLUSIVE:
 961           args = 2;
 962           break;
 963         }
 964
 965       break;
 966
 967     default:
 968       args = 1 + (i < (int) BINOP_END);
 969     }
 970
 971   *oplenp = oplen;
 972   *argsp = args;
 973 }
 974
 975 /* Copy the subexpression ending just before index INEND in INEXPR
 976    into OUTEXPR, starting at index OUTBEG.
 977    In the process, convert it from suffix to prefix form.
 978    If LAST_STRUCT is -1, then this function always returns -1.
 979    Otherwise, it returns the index of the subexpression which is the
 980    left-hand-side of the expression at LAST_STRUCT.  */
 981
 982 static int
 983 prefixify_subexp (struct expression *inexpr,
 984                   struct expression *outexpr, int inend, int outbeg,
 985                   int last_struct)
 986 {
 987   int oplen;
 988   int args;
 989   int i;
 990   int *arglens;
 991   int result = -1;
 992
 993   operator_length (inexpr, inend, &oplen, &args);
 994
 995   /* Copy the final operator itself, from the end of the input
 996      to the beginning of the output.  */
 997   inend -= oplen;
 998   memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
 999           EXP_ELEM_TO_BYTES (oplen));
1000   outbeg += oplen;
1001
1002   if (last_struct == inend)
1003     result = outbeg - oplen;
1004
1005   /* Find the lengths of the arg subexpressions.  */
1006   arglens = (int *) alloca (args * sizeof (int));
1007   for (i = args - 1; i >= 0; i--)
1008     {
1009       oplen = length_of_subexp (inexpr, inend);
1010       arglens[i] = oplen;
1011       inend -= oplen;
1012     }
1013
1014   /* Now copy each subexpression, preserving the order of
1015      the subexpressions, but prefixifying each one.
1016      In this loop, inend starts at the beginning of
1017      the expression this level is working on
1018      and marches forward over the arguments.
1019      outbeg does similarly in the output.  */
1020   for (i = 0; i < args; i++)
1021     {
1022       int r;
1023
1024       oplen = arglens[i];
1025       inend += oplen;
1026       r = prefixify_subexp (inexpr, outexpr, inend, outbeg, last_struct);
1027       if (r != -1)
1028         {
1029           /* Return immediately.  We probably have only parsed a
1030              partial expression, so we don't want to try to reverse
1031              the other operands.  */
1032           return r;
1033         }
1034       outbeg += oplen;
1035     }
1036
1037   return result;
1038 }
1039 \f
1040 /* Read an expression from the string *STRINGPTR points to,
1041    parse it, and return a pointer to a struct expression that we malloc.
1042    Use block BLOCK as the lexical context for variable names;
1043    if BLOCK is zero, use the block of the selected stack frame.
1044    Meanwhile, advance *STRINGPTR to point after the expression,
1045    at the first nonwhite character that is not part of the expression
1046    (possibly a null character).
1047
1048    If COMMA is nonzero, stop if a comma is reached.  */
1049
1050 expression_up
1051 parse_exp_1 (const char **stringptr, CORE_ADDR pc, const struct block *block,
1052              int comma, innermost_block_tracker_types tracker_types)
1053 {
1054   return parse_exp_in_context (stringptr, pc, block, comma, 0, NULL,
1055                                tracker_types, nullptr);
1056 }
1057
1058 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1059    no value is expected from the expression.
1060    OUT_SUBEXP is set when attempting to complete a field name; in this
1061    case it is set to the index of the subexpression on the
1062    left-hand-side of the struct op.  If not doing such completion, it
1063    is left untouched.  */
1064
1065 static expression_up
1066 parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
1067                       const struct block *block,
1068                       int comma, int void_context_p, int *out_subexp,
1069                       innermost_block_tracker_types tracker_types,
1070                       expr_completion_state *cstate)
1071 {
1072   const struct language_defn *lang = NULL;
1073   int subexp;
1074
1075   innermost_block.reset (tracker_types);
1076
1077   if (*stringptr == 0 || **stringptr == 0)
1078     error_no_arg (_("expression to compute"));
1079
1080   const struct block *expression_context_block = block;
1081   CORE_ADDR expression_context_pc = 0;
1082
1083   /* If no context specified, try using the current frame, if any.  */
1084   if (!expression_context_block)
1085     expression_context_block = get_selected_block (&expression_context_pc);
1086   else if (pc == 0)
1087     expression_context_pc = BLOCK_ENTRY_PC (expression_context_block);
1088   else
1089     expression_context_pc = pc;
1090
1091   /* Fall back to using the current source static context, if any.  */
1092
1093   if (!expression_context_block)
1094     {
1095       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1096       if (cursal.symtab)
1097         expression_context_block
1098           = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal.symtab),
1099                                STATIC_BLOCK);
1100       if (expression_context_block)
1101         expression_context_pc = BLOCK_ENTRY_PC (expression_context_block);
1102     }
1103
1104   if (language_mode == language_mode_auto && block != NULL)
1105     {
1106       /* Find the language associated to the given context block.
1107          Default to the current language if it can not be determined.
1108
1109          Note that using the language corresponding to the current frame
1110          can sometimes give unexpected results.  For instance, this
1111          routine is often called several times during the inferior
1112          startup phase to re-parse breakpoint expressions after
1113          a new shared library has been loaded.  The language associated
1114          to the current frame at this moment is not relevant for
1115          the breakpoint.  Using it would therefore be silly, so it seems
1116          better to rely on the current language rather than relying on
1117          the current frame language to parse the expression.  That's why
1118          we do the following language detection only if the context block
1119          has been specifically provided.  */
1120       struct symbol *func = block_linkage_function (block);
1121
1122       if (func != NULL)
1123         lang = language_def (SYMBOL_LANGUAGE (func));
1124       if (lang == NULL || lang->la_language == language_unknown)
1125         lang = current_language;
1126     }
1127   else
1128     lang = current_language;
1129
1130   /* get_current_arch may reset CURRENT_LANGUAGE via select_frame.
1131      While we need CURRENT_LANGUAGE to be set to LANG (for lookup_symbol
1132      and others called from *.y) ensure CURRENT_LANGUAGE gets restored
1133      to the value matching SELECTED_FRAME as set by get_current_arch.  */
1134
1135   parser_state ps (lang, get_current_arch (), expression_context_block,
1136                    expression_context_pc, comma, *stringptr,
1137                    cstate != nullptr);
1138
1139   scoped_restore_current_language lang_saver;
1140   set_language (lang->la_language);
1141
1142   TRY
1143     {
1144       lang->la_parser (&ps);
1145     }
1146   CATCH (except, RETURN_MASK_ALL)
1147     {
1148       /* If parsing for completion, allow this to succeed; but if no
1149          expression elements have been written, then there's nothing
1150          to do, so fail.  */
1151       if (! ps.parse_completion || ps.expout_ptr == 0)
1152         throw_exception (except);
1153     }
1154   END_CATCH
1155
1156   /* We have to operate on an "expression *", due to la_post_parser,
1157      which explains this funny-looking double release.  */
1158   expression_up result = ps.release ();
1159
1160   /* Convert expression from postfix form as generated by yacc
1161      parser, to a prefix form.  */
1162
1163   if (expressiondebug)
1164     dump_raw_expression (result.get (), gdb_stdlog,
1165                          "before conversion to prefix form");
1166
1167   subexp = prefixify_expression (result.get (),
1168                                  ps.m_completion_state.expout_last_struct);
1169   if (out_subexp)
1170     *out_subexp = subexp;
1171
1172   lang->la_post_parser (&result, void_context_p, ps.parse_completion);
1173
1174   if (expressiondebug)
1175     dump_prefix_expression (result.get (), gdb_stdlog);
1176
1177   if (cstate != nullptr)
1178     *cstate = std::move (ps.m_completion_state);
1179   *stringptr = ps.lexptr;
1180   return result;
1181 }
1182
1183 /* Parse STRING as an expression, and complain if this fails
1184    to use up all of the contents of STRING.  */
1185
1186 expression_up
1187 parse_expression (const char *string)
1188 {
1189   expression_up exp = parse_exp_1 (&string, 0, 0, 0);
1190   if (*string)
1191     error (_("Junk after end of expression."));
1192   return exp;
1193 }
1194
1195 /* Same as parse_expression, but using the given language (LANG)
1196    to parse the expression.  */
1197
1198 expression_up
1199 parse_expression_with_language (const char *string, enum language lang)
1200 {
1201   gdb::optional<scoped_restore_current_language> lang_saver;
1202   if (current_language->la_language != lang)
1203     {
1204       lang_saver.emplace ();
1205       set_language (lang);
1206     }
1207
1208   return parse_expression (string);
1209 }
1210
1211 /* Parse STRING as an expression.  If parsing ends in the middle of a
1212    field reference, return the type of the left-hand-side of the
1213    reference; furthermore, if the parsing ends in the field name,
1214    return the field name in *NAME.  If the parsing ends in the middle
1215    of a field reference, but the reference is somehow invalid, throw
1216    an exception.  In all other cases, return NULL.  */
1217
1218 struct type *
1219 parse_expression_for_completion (const char *string,
1220                                  gdb::unique_xmalloc_ptr<char> *name,
1221                                  enum type_code *code)
1222 {
1223   expression_up exp;
1224   struct value *val;
1225   int subexp;
1226   expr_completion_state cstate;
1227
1228   TRY
1229     {
1230       exp = parse_exp_in_context (&string, 0, 0, 0, 0, &subexp,
1231                                   INNERMOST_BLOCK_FOR_SYMBOLS, &cstate);
1232     }
1233   CATCH (except, RETURN_MASK_ERROR)
1234     {
1235       /* Nothing, EXP remains NULL.  */
1236     }
1237   END_CATCH
1238
1239   if (exp == NULL)
1240     return NULL;
1241
1242   if (cstate.expout_tag_completion_type != TYPE_CODE_UNDEF)
1243     {
1244       *code = cstate.expout_tag_completion_type;
1245       *name = std::move (cstate.expout_completion_name);
1246       return NULL;
1247     }
1248
1249   if (cstate.expout_last_struct == -1)
1250     return NULL;
1251
1252   const char *fieldname = extract_field_op (exp.get (), &subexp);
1253   if (fieldname == NULL)
1254     {
1255       name->reset ();
1256       return NULL;
1257     }
1258
1259   name->reset (xstrdup (fieldname));
1260   /* This might throw an exception.  If so, we want to let it
1261      propagate.  */
1262   val = evaluate_subexpression_type (exp.get (), subexp);
1263
1264   return value_type (val);
1265 }
1266
1267 /* A post-parser that does nothing.  */
1268
1269 void
1270 null_post_parser (expression_up *exp, int void_context_p, int completin)
1271 {
1272 }
1273
1274 /* Parse floating point value P of length LEN.
1275    Return false if invalid, true if valid.
1276    The successfully parsed number is stored in DATA in
1277    target format for floating-point type TYPE.
1278
1279    NOTE: This accepts the floating point syntax that sscanf accepts.  */
1280
1281 bool
1282 parse_float (const char *p, int len,
1283              const struct type *type, gdb_byte *data)
1284 {
1285   return target_float_from_string (data, type, std::string (p, len));
1286 }
1287 \f
1288 /* This function avoids direct calls to fprintf
1289    in the parser generated debug code.  */
1290 void
1291 parser_fprintf (FILE *x, const char *y, ...)
1292 {
1293   va_list args;
1294
1295   va_start (args, y);
1296   if (x == stderr)
1297     vfprintf_unfiltered (gdb_stderr, y, args);
1298   else
1299     {
1300       fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1301       vfprintf_unfiltered (gdb_stderr, y, args);
1302     }
1303   va_end (args);
1304 }
1305
1306 /* Implementation of the exp_descriptor method operator_check.  */
1307
1308 int
1309 operator_check_standard (struct expression *exp, int pos,
1310                          int (*objfile_func) (struct objfile *objfile,
1311                                               void *data),
1312                          void *data)
1313 {
1314   const union exp_element *const elts = exp->elts;
1315   struct type *type = NULL;
1316   struct objfile *objfile = NULL;
1317
1318   /* Extended operators should have been already handled by exp_descriptor
1319      iterate method of its specific language.  */
1320   gdb_assert (elts[pos].opcode < OP_EXTENDED0);
1321
1322   /* Track the callers of write_exp_elt_type for this table.  */
1323
1324   switch (elts[pos].opcode)
1325     {
1326     case BINOP_VAL:
1327     case OP_COMPLEX:
1328     case OP_FLOAT:
1329     case OP_LONG:
1330     case OP_SCOPE:
1331     case OP_TYPE:
1332     case UNOP_CAST:
1333     case UNOP_MAX:
1334     case UNOP_MEMVAL:
1335     case UNOP_MIN:
1336       type = elts[pos + 1].type;
1337       break;
1338
1339     case TYPE_INSTANCE:
1340       {
1341         LONGEST arg, nargs = elts[pos + 2].longconst;
1342
1343         for (arg = 0; arg < nargs; arg++)
1344           {
1345             struct type *inst_type = elts[pos + 3 + arg].type;
1346             struct objfile *inst_objfile = TYPE_OBJFILE (inst_type);
1347
1348             if (inst_objfile && (*objfile_func) (inst_objfile, data))
1349               return 1;
1350           }
1351       }
1352       break;
1353
1354     case OP_VAR_VALUE:
1355       {
1356         const struct block *const block = elts[pos + 1].block;
1357         const struct symbol *const symbol = elts[pos + 2].symbol;
1358
1359         /* Check objfile where the variable itself is placed.
1360            SYMBOL_OBJ_SECTION (symbol) may be NULL.  */
1361         if ((*objfile_func) (symbol_objfile (symbol), data))
1362           return 1;
1363
1364         /* Check objfile where is placed the code touching the variable.  */
1365         objfile = lookup_objfile_from_block (block);
1366
1367         type = SYMBOL_TYPE (symbol);
1368       }
1369       break;
1370     case OP_VAR_MSYM_VALUE:
1371       objfile = elts[pos + 1].objfile;
1372       break;
1373     }
1374
1375   /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL.  */
1376
1377   if (type && TYPE_OBJFILE (type)
1378       && (*objfile_func) (TYPE_OBJFILE (type), data))
1379     return 1;
1380   if (objfile && (*objfile_func) (objfile, data))
1381     return 1;
1382
1383   return 0;
1384 }
1385
1386 /* Call OBJFILE_FUNC for any objfile found being referenced by EXP.
1387    OBJFILE_FUNC is never called with NULL OBJFILE.  OBJFILE_FUNC get
1388    passed an arbitrary caller supplied DATA pointer.  If OBJFILE_FUNC
1389    returns non-zero value then (any other) non-zero value is immediately
1390    returned to the caller.  Otherwise zero is returned after iterating
1391    through whole EXP.  */
1392
1393 static int
1394 exp_iterate (struct expression *exp,
1395              int (*objfile_func) (struct objfile *objfile, void *data),
1396              void *data)
1397 {
1398   int endpos;
1399
1400   for (endpos = exp->nelts; endpos > 0; )
1401     {
1402       int pos, args, oplen = 0;
1403
1404       operator_length (exp, endpos, &oplen, &args);
1405       gdb_assert (oplen > 0);
1406
1407       pos = endpos - oplen;
1408       if (exp->language_defn->la_exp_desc->operator_check (exp, pos,
1409                                                            objfile_func, data))
1410         return 1;
1411
1412       endpos = pos;
1413     }
1414
1415   return 0;
1416 }
1417
1418 /* Helper for exp_uses_objfile.  */
1419
1420 static int
1421 exp_uses_objfile_iter (struct objfile *exp_objfile, void *objfile_voidp)
1422 {
1423   struct objfile *objfile = (struct objfile *) objfile_voidp;
1424
1425   if (exp_objfile->separate_debug_objfile_backlink)
1426     exp_objfile = exp_objfile->separate_debug_objfile_backlink;
1427
1428   return exp_objfile == objfile;
1429 }
1430
1431 /* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1432    is unloaded), otherwise return 0.  OBJFILE must not be a separate debug info
1433    file.  */
1434
1435 int
1436 exp_uses_objfile (struct expression *exp, struct objfile *objfile)
1437 {
1438   gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
1439
1440   return exp_iterate (exp, exp_uses_objfile_iter, objfile);
1441 }
1442
1443 /* Reallocate the `expout' pointer inside PS so that it can accommodate
1444    at least LENELT expression elements.  This function does nothing if
1445    there is enough room for the elements.  */
1446
1447 static void
1448 increase_expout_size (struct expr_builder *ps, size_t lenelt)
1449 {
1450   if ((ps->expout_ptr + lenelt) >= ps->expout_size)
1451     {
1452       ps->expout_size = std::max (ps->expout_size * 2,
1453                                   ps->expout_ptr + lenelt + 10);
1454       ps->expout.reset (XRESIZEVAR (expression,
1455                                     ps->expout.release (),
1456                                     (sizeof (struct expression)
1457                                      + EXP_ELEM_TO_BYTES (ps->expout_size))));
1458     }
1459 }
1460
1461 void
1462 _initialize_parse (void)
1463 {
1464   add_setshow_zuinteger_cmd ("expression", class_maintenance,
1465                              &expressiondebug,
1466                              _("Set expression debugging."),
1467                              _("Show expression debugging."),
1468                              _("When non-zero, the internal representation "
1469                                "of expressions will be printed."),
1470                              NULL,
1471                              show_expressiondebug,
1472                              &setdebuglist, &showdebuglist);
1473   add_setshow_boolean_cmd ("parser", class_maintenance,
1474                             &parser_debug,
1475                            _("Set parser debugging."),
1476                            _("Show parser debugging."),
1477                            _("When non-zero, expression parser "
1478                              "tracing will be enabled."),
1479                             NULL,
1480                             show_parserdebug,
1481                             &setdebuglist, &showdebuglist);
1482 }