gdb/parser-defs.h

   1 /* Parser definitions for GDB.
   2
   3    Copyright (C) 1986-2021 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.
   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 #if !defined (PARSER_DEFS_H)
  24 #define PARSER_DEFS_H 1
  25
  26 #include "expression.h"
  27 #include "symtab.h"
  28 #include "expop.h"
  29
  30 struct block;
  31 struct language_defn;
  32 struct internalvar;
  33 class innermost_block_tracker;
  34
  35 extern bool parser_debug;
  36
  37 /* A class that can be used to build a "struct expression".  */
  38
  39 struct expr_builder
  40 {
  41   /* Constructor.  LANG is the language used to parse the expression.
  42      And GDBARCH is the gdbarch to use during parsing.  */
  43
  44   expr_builder (const struct language_defn *lang,
  45                 struct gdbarch *gdbarch);
  46
  47   DISABLE_COPY_AND_ASSIGN (expr_builder);
  48
  49   /* Resize the allocated expression to the correct size, and return
  50      it as an expression_up -- passing ownership to the caller.  */
  51   ATTRIBUTE_UNUSED_RESULT expression_up release ();
  52
  53   /* Return the gdbarch that was passed to the constructor.  */
  54
  55   struct gdbarch *gdbarch ()
  56   {
  57     return expout->gdbarch;
  58   }
  59
  60   /* Return the language that was passed to the constructor.  */
  61
  62   const struct language_defn *language ()
  63   {
  64     return expout->language_defn;
  65   }
  66
  67   /* Set the root operation of the expression that is currently being
  68      built.  */
  69   void set_operation (expr::operation_up &&op)
  70   {
  71     expout->op = std::move (op);
  72   }
  73
  74   /* The size of the expression above.  */
  75
  76   size_t expout_size;
  77
  78   /* The expression related to this parser state.  */
  79
  80   expression_up expout;
  81
  82   /* The number of elements already in the expression.  This is used
  83      to know where to put new elements.  */
  84
  85   size_t expout_ptr;
  86 };
  87
  88 /* This is used for expression completion.  */
  89
  90 struct expr_completion_state
  91 {
  92   /* The index of the last struct expression directly before a '.' or
  93      '->'.  This is set when parsing and is only used when completing a
  94      field name.  It is -1 if no dereference operation was found.  */
  95   int expout_last_struct = -1;
  96
  97   /* The last struct expression directly before a '.' or '->'.  This
  98      is set when parsing and is only used when completing a field
  99      name.  It is nullptr if no dereference operation was found.  */
 100   expr::structop_base_operation *expout_last_op = nullptr;
 101
 102   /* If we are completing a tagged type name, this will be nonzero.  */
 103   enum type_code expout_tag_completion_type = TYPE_CODE_UNDEF;
 104
 105   /* The token for tagged type name completion.  */
 106   gdb::unique_xmalloc_ptr<char> expout_completion_name;
 107 };
 108
 109 /* An instance of this type is instantiated during expression parsing,
 110    and passed to the appropriate parser.  It holds both inputs to the
 111    parser, and result.  */
 112
 113 struct parser_state : public expr_builder
 114 {
 115   /* Constructor.  LANG is the language used to parse the expression.
 116      And GDBARCH is the gdbarch to use during parsing.  */
 117
 118   parser_state (const struct language_defn *lang,
 119                 struct gdbarch *gdbarch,
 120                 const struct block *context_block,
 121                 CORE_ADDR context_pc,
 122                 int comma,
 123                 const char *input,
 124                 int completion,
 125                 innermost_block_tracker *tracker,
 126                 bool void_p)
 127     : expr_builder (lang, gdbarch),
 128       expression_context_block (context_block),
 129       expression_context_pc (context_pc),
 130       comma_terminates (comma),
 131       lexptr (input),
 132       parse_completion (completion),
 133       block_tracker (tracker),
 134       void_context_p (void_p)
 135   {
 136   }
 137
 138   DISABLE_COPY_AND_ASSIGN (parser_state);
 139
 140   /* Begin counting arguments for a function call,
 141      saving the data about any containing call.  */
 142
 143   void start_arglist ()
 144   {
 145     m_funcall_chain.push_back (arglist_len);
 146     arglist_len = 0;
 147   }
 148
 149   /* Return the number of arguments in a function call just terminated,
 150      and restore the data for the containing function call.  */
 151
 152   int end_arglist ()
 153   {
 154     int val = arglist_len;
 155     arglist_len = m_funcall_chain.back ();
 156     m_funcall_chain.pop_back ();
 157     return val;
 158   }
 159
 160   /* Mark the current index as the starting location of a structure
 161      expression.  This is used when completing on field names.  */
 162
 163   void mark_struct_expression ();
 164
 165   /* Mark the given operation as the starting location of a structure
 166      expression.  This is used when completing on field names.  */
 167
 168   void mark_struct_expression (expr::structop_base_operation *op);
 169
 170   /* Indicate that the current parser invocation is completing a tag.
 171      TAG is the type code of the tag, and PTR and LENGTH represent the
 172      start of the tag name.  */
 173
 174   void mark_completion_tag (enum type_code tag, const char *ptr, int length);
 175
 176   /* Push an operation on the stack.  */
 177   void push (expr::operation_up &&op)
 178   {
 179     m_operations.push_back (std::move (op));
 180   }
 181
 182   /* Create a new operation and push it on the stack.  */
 183   template<typename T, typename... Arg>
 184   void push_new (Arg... args)
 185   {
 186     m_operations.emplace_back (new T (std::forward<Arg> (args)...));
 187   }
 188
 189   /* Push a new C string operation.  */
 190   void push_c_string (int, struct stoken_vector *vec);
 191
 192   /* Push a symbol reference.  If SYM is nullptr, look for a minimal
 193      symbol.  */
 194   void push_symbol (const char *name, block_symbol sym);
 195
 196   /* Push a reference to $mumble.  This may result in a convenience
 197      variable, a history reference, or a register.  */
 198   void push_dollar (struct stoken str);
 199
 200   /* Pop an operation from the stack.  */
 201   expr::operation_up pop ()
 202   {
 203     expr::operation_up result = std::move (m_operations.back ());
 204     m_operations.pop_back ();
 205     return result;
 206   }
 207
 208   /* Pop N elements from the stack and return a vector.  */
 209   std::vector<expr::operation_up> pop_vector (int n)
 210   {
 211     std::vector<expr::operation_up> result (n);
 212     for (int i = 1; i <= n; ++i)
 213       result[n - i] = pop ();
 214     return result;
 215   }
 216
 217   /* A helper that pops an operation, wraps it in some other
 218      operation, and pushes it again.  */
 219   template<typename T>
 220   void wrap ()
 221   {
 222     using namespace expr;
 223     operation_up v = ::expr::make_operation<T> (pop ());
 224     push (std::move (v));
 225   }
 226
 227   /* A helper that pops two operations, wraps them in some other
 228      operation, and pushes the result.  */
 229   template<typename T>
 230   void wrap2 ()
 231   {
 232     expr::operation_up rhs = pop ();
 233     expr::operation_up lhs = pop ();
 234     push (expr::make_operation<T> (std::move (lhs), std::move (rhs)));
 235   }
 236
 237   /* If this is nonzero, this block is used as the lexical context for
 238      symbol names.  */
 239
 240   const struct block * const expression_context_block;
 241
 242   /* If expression_context_block is non-zero, then this is the PC
 243      within the block that we want to evaluate expressions at.  When
 244      debugging C or C++ code, we use this to find the exact line we're
 245      at, and then look up the macro definitions active at that
 246      point.  */
 247   const CORE_ADDR expression_context_pc;
 248
 249   /* Nonzero means stop parsing on first comma (if not within parentheses).  */
 250
 251   int comma_terminates;
 252
 253   /* During parsing of a C expression, the pointer to the next character
 254      is in this variable.  */
 255
 256   const char *lexptr;
 257
 258   /* After a token has been recognized, this variable points to it.
 259      Currently used only for error reporting.  */
 260   const char *prev_lexptr = nullptr;
 261
 262   /* Number of arguments seen so far in innermost function call.  */
 263
 264   int arglist_len = 0;
 265
 266   /* True if parsing an expression to attempt completion.  */
 267   int parse_completion;
 268
 269   /* Completion state is updated here.  */
 270   expr_completion_state m_completion_state;
 271
 272   /* The innermost block tracker.  */
 273   innermost_block_tracker *block_tracker;
 274
 275   /* True if no value is expected from the expression.  */
 276   bool void_context_p;
 277
 278 private:
 279
 280   /* Data structure for saving values of arglist_len for function calls whose
 281      arguments contain other function calls.  */
 282
 283   std::vector<int> m_funcall_chain;
 284
 285   /* Stack of operations.  */
 286   std::vector<expr::operation_up> m_operations;
 287 };
 288
 289 /* When parsing expressions we track the innermost block that was
 290    referenced.  */
 291
 292 class innermost_block_tracker
 293 {
 294 public:
 295   innermost_block_tracker (innermost_block_tracker_types types
 296                            = INNERMOST_BLOCK_FOR_SYMBOLS)
 297     : m_types (types),
 298       m_innermost_block (NULL)
 299   { /* Nothing.  */ }
 300
 301   /* Update the stored innermost block if the new block B is more inner
 302      than the currently stored block, or if no block is stored yet.  The
 303      type T tells us whether the block B was for a symbol or for a
 304      register.  The stored innermost block is only updated if the type T is
 305      a type we are interested in, the types we are interested in are held
 306      in M_TYPES and set during RESET.  */
 307   void update (const struct block *b, innermost_block_tracker_types t);
 308
 309   /* Overload of main UPDATE method which extracts the block from BS.  */
 310   void update (const struct block_symbol &bs)
 311   {
 312     update (bs.block, INNERMOST_BLOCK_FOR_SYMBOLS);
 313   }
 314
 315   /* Return the stored innermost block.  Can be nullptr if no symbols or
 316      registers were found during an expression parse, and so no innermost
 317      block was defined.  */
 318   const struct block *block () const
 319   {
 320     return m_innermost_block;
 321   }
 322
 323 private:
 324   /* The type of innermost block being looked for.  */
 325   innermost_block_tracker_types m_types;
 326
 327   /* The currently stored innermost block found while parsing an
 328      expression.  */
 329   const struct block *m_innermost_block;
 330 };
 331
 332 /* A string token, either a char-string or bit-string.  Char-strings are
 333    used, for example, for the names of symbols.  */
 334
 335 struct stoken
 336   {
 337     /* Pointer to first byte of char-string or first bit of bit-string.  */
 338     const char *ptr;
 339     /* Length of string in bytes for char-string or bits for bit-string.  */
 340     int length;
 341   };
 342
 343 struct typed_stoken
 344   {
 345     /* A language-specific type field.  */
 346     int type;
 347     /* Pointer to first byte of char-string or first bit of bit-string.  */
 348     char *ptr;
 349     /* Length of string in bytes for char-string or bits for bit-string.  */
 350     int length;
 351   };
 352
 353 struct stoken_vector
 354   {
 355     int len;
 356     struct typed_stoken *tokens;
 357   };
 358
 359 struct ttype
 360   {
 361     struct stoken stoken;
 362     struct type *type;
 363   };
 364
 365 struct symtoken
 366   {
 367     struct stoken stoken;
 368     struct block_symbol sym;
 369     int is_a_field_of_this;
 370   };
 371
 372 struct objc_class_str
 373   {
 374     struct stoken stoken;
 375     struct type *type;
 376     int theclass;
 377   };
 378
 379 /* Reverse an expression from suffix form (in which it is constructed)
 380    to prefix form (in which we can conveniently print or execute it).
 381    Ordinarily this always returns -1.  However, if LAST_STRUCT
 382    is not -1 (i.e., we are trying to complete a field name), it will
 383    return the index of the subexpression which is the left-hand-side
 384    of the struct operation at LAST_STRUCT.  */
 385
 386 extern int prefixify_expression (struct expression *expr,
 387                                  int last_struct = -1);
 388
 389 extern void write_exp_elt_opcode (struct expr_builder *, enum exp_opcode);
 390
 391 extern void write_exp_elt_sym (struct expr_builder *, struct symbol *);
 392
 393 extern void write_exp_elt_longcst (struct expr_builder *, LONGEST);
 394
 395 extern void write_exp_elt_floatcst (struct expr_builder *, const gdb_byte *);
 396
 397 extern void write_exp_elt_type (struct expr_builder *, struct type *);
 398
 399 extern void write_exp_elt_intern (struct expr_builder *, struct internalvar *);
 400
 401 extern void write_exp_string (struct expr_builder *, struct stoken);
 402
 403 void write_exp_string_vector (struct expr_builder *, int type,
 404                               struct stoken_vector *vec);
 405
 406 extern void write_exp_bitstring (struct expr_builder *, struct stoken);
 407
 408 extern void write_exp_elt_block (struct expr_builder *, const struct block *);
 409
 410 extern void write_exp_elt_objfile (struct expr_builder *,
 411                                    struct objfile *objfile);
 412
 413 extern void write_exp_msymbol (struct expr_builder *,
 414                                struct bound_minimal_symbol);
 415
 416 extern void write_dollar_variable (struct parser_state *, struct stoken str);
 417
 418 /* Write a reference to a symbol to the expression being built in PS.
 419    NAME is the name of the symbol to write; SYM is the symbol.  If SYM
 420    is nullptr (meaning the 'symbol' member), a minimal symbol will be
 421    searched for and used if available.  Throws an exception if SYM is
 422    nullptr and no minimal symbol can be found.  */
 423
 424 extern void write_exp_symbol_reference (struct parser_state *ps,
 425                                         const char *name,
 426                                         struct block_symbol sym);
 427
 428 extern const char *find_template_name_end (const char *);
 429
 430 extern std::string copy_name (struct stoken);
 431
 432 extern int dump_subexp (struct expression *, struct ui_file *, int);
 433
 434 extern int dump_subexp_body_standard (struct expression *,
 435                                       struct ui_file *, int);
 436
 437 /* Dump (to STREAM) a function call like expression at position ELT in the
 438    expression array EXP.  Return a new value for ELT just after the
 439    function call expression.  */
 440
 441 extern int dump_subexp_body_funcall (struct expression *exp,
 442                                      struct ui_file *stream, int elt);
 443
 444 extern void operator_length (const struct expression *, int, int *, int *);
 445
 446 extern void operator_length_standard (const struct expression *, int, int *,
 447                                       int *);
 448
 449 extern int operator_check_standard (struct expression *exp, int pos,
 450                                     int (*objfile_func)
 451                                       (struct objfile *objfile, void *data),
 452                                     void *data);
 453
 454 extern bool parse_float (const char *p, int len,
 455                          const struct type *type, gdb_byte *data);
 456 \f
 457 /* These codes indicate operator precedences for expression printing,
 458    least tightly binding first.  */
 459 /* Adding 1 to a precedence value is done for binary operators,
 460    on the operand which is more tightly bound, so that operators
 461    of equal precedence within that operand will get parentheses.  */
 462 /* PREC_HYPER and PREC_ABOVE_COMMA are not the precedence of any operator;
 463    they are used as the "surrounding precedence" to force
 464    various kinds of things to be parenthesized.  */
 465 enum precedence
 466   {
 467     PREC_NULL, PREC_COMMA, PREC_ABOVE_COMMA, PREC_ASSIGN, PREC_LOGICAL_OR,
 468     PREC_LOGICAL_AND, PREC_BITWISE_IOR, PREC_BITWISE_AND, PREC_BITWISE_XOR,
 469     PREC_EQUAL, PREC_ORDER, PREC_SHIFT, PREC_ADD, PREC_MUL, PREC_REPEAT,
 470     PREC_HYPER, PREC_PREFIX, PREC_SUFFIX, PREC_BUILTIN_FUNCTION
 471   };
 472
 473 /* Table mapping opcodes into strings for printing operators
 474    and precedences of the operators.  */
 475
 476 struct op_print
 477   {
 478     const char *string;
 479     enum exp_opcode opcode;
 480     /* Precedence of operator.  These values are used only by comparisons.  */
 481     enum precedence precedence;
 482
 483     /* For a binary operator:  1 iff right associate.
 484        For a unary operator:  1 iff postfix.  */
 485     int right_assoc;
 486   };
 487
 488 /* Information needed to print, prefixify, and evaluate expressions for
 489    a given language.  */
 490
 491 struct exp_descriptor
 492   {
 493     /* Print subexpression.  */
 494     void (*print_subexp) (struct expression *, int *, struct ui_file *,
 495                           enum precedence);
 496
 497     /* Returns number of exp_elements needed to represent an operator and
 498        the number of subexpressions it takes.  */
 499     void (*operator_length) (const struct expression*, int, int*, int *);
 500
 501     /* Call OBJFILE_FUNC for any objfile found being referenced by the
 502        single operator of EXP at position POS.  Operator parameters are
 503        located at positive (POS + number) offsets in EXP.  OBJFILE_FUNC
 504        should never be called with NULL OBJFILE.  OBJFILE_FUNC should
 505        get passed an arbitrary caller supplied DATA pointer.  If it
 506        returns non-zero value then (any other) non-zero value should be
 507        immediately returned to the caller.  Otherwise zero should be
 508        returned.  */
 509     int (*operator_check) (struct expression *exp, int pos,
 510                            int (*objfile_func) (struct objfile *objfile,
 511                                                 void *data),
 512                            void *data);
 513
 514     /* Dump the rest of this (prefix) expression after the operator
 515        itself has been printed.  See dump_subexp_body_standard in
 516        (expprint.c).  */
 517     int (*dump_subexp_body) (struct expression *, struct ui_file *, int);
 518
 519     /* Evaluate an expression.  */
 520     struct value *(*evaluate_exp) (struct type *, struct expression *,
 521                                    int *, enum noside);
 522   };
 523
 524
 525 /* Default descriptor containing standard definitions of all
 526    elements.  */
 527 extern const struct exp_descriptor exp_descriptor_standard;
 528
 529 /* Functions used by language-specific extended operators to (recursively)
 530    print/dump subexpressions.  */
 531
 532 extern void print_subexp (struct expression *, int *, struct ui_file *,
 533                           enum precedence);
 534
 535 extern void print_subexp_standard (struct expression *, int *,
 536                                    struct ui_file *, enum precedence);
 537
 538 /* Print a function call like expression to STREAM.  This is called as a
 539    helper function by which point the expression node identifying this as a
 540    function call has already been stripped off and POS should point to the
 541    number of function call arguments.  EXP is the object containing the
 542    list of expression elements.  */
 543
 544 extern void print_subexp_funcall (struct expression *exp, int *pos,
 545                                   struct ui_file *stream);
 546
 547 /* Function used to avoid direct calls to fprintf
 548    in the code generated by the bison parser.  */
 549
 550 extern void parser_fprintf (FILE *, const char *, ...) ATTRIBUTE_PRINTF (2, 3);
 551
 552 extern int exp_uses_objfile (struct expression *exp, struct objfile *objfile);
 553
 554 #endif /* PARSER_DEFS_H */
 555