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