gdb/expression.h

   1 /* Definitions for expressions stored in reversed prefix form, for GDB.
   2
   3    Copyright (C) 1986-2022 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #if !defined (EXPRESSION_H)
  21 #define EXPRESSION_H 1
  22
  23 #include "gdbtypes.h"
  24
  25 /* While parsing expressions we need to track the innermost lexical block
  26    that we encounter.  In some situations we need to track the innermost
  27    block just for symbols, and in other situations we want to track the
  28    innermost block for symbols and registers.  These flags are used by the
  29    innermost block tracker to control which blocks we consider for the
  30    innermost block.  These flags can be combined together as needed.  */
  31
  32 enum innermost_block_tracker_type
  33 {
  34   /* Track the innermost block for symbols within an expression.  */
  35   INNERMOST_BLOCK_FOR_SYMBOLS = (1 << 0),
  36
  37   /* Track the innermost block for registers within an expression.  */
  38   INNERMOST_BLOCK_FOR_REGISTERS = (1 << 1)
  39 };
  40 DEF_ENUM_FLAGS_TYPE (enum innermost_block_tracker_type,
  41                      innermost_block_tracker_types);
  42
  43 enum exp_opcode : uint8_t
  44   {
  45 #define OP(name) name ,
  46
  47 #include "std-operator.def"
  48
  49 #undef OP
  50   };
  51
  52 /* Values of NOSIDE argument to eval_subexp.  */
  53
  54 enum noside
  55   {
  56     EVAL_NORMAL,
  57     EVAL_AVOID_SIDE_EFFECTS     /* Don't modify any variables or
  58                                    call any functions.  The value
  59                                    returned will have the correct
  60                                    type, and will have an
  61                                    approximately correct lvalue
  62                                    type (inaccuracy: anything that is
  63                                    listed as being in a register in
  64                                    the function in which it was
  65                                    declared will be lval_register).
  66                                    Ideally this would not even read
  67                                    target memory, but currently it
  68                                    does in many situations.  */
  69   };
  70
  71 struct expression;
  72 struct agent_expr;
  73 struct axs_value;
  74 struct type;
  75 struct ui_file;
  76
  77 namespace expr
  78 {
  79
  80 class operation;
  81 typedef std::unique_ptr<operation> operation_up;
  82
  83 /* Base class for an operation.  An operation is a single component of
  84    an expression.  */
  85
  86 class operation
  87 {
  88 protected:
  89
  90   operation () = default;
  91   DISABLE_COPY_AND_ASSIGN (operation);
  92
  93 public:
  94
  95   virtual ~operation () = default;
  96
  97   /* Evaluate this operation.  */
  98   virtual value *evaluate (struct type *expect_type,
  99                            struct expression *exp,
 100                            enum noside noside) = 0;
 101
 102   /* Evaluate this operation in a context where C-like coercion is
 103      needed.  */
 104   virtual value *evaluate_with_coercion (struct expression *exp,
 105                                          enum noside noside)
 106   {
 107     return evaluate (nullptr, exp, noside);
 108   }
 109
 110   /* Evaluate this expression in the context of a cast to
 111      EXPECT_TYPE.  */
 112   virtual value *evaluate_for_cast (struct type *expect_type,
 113                                     struct expression *exp,
 114                                     enum noside noside);
 115
 116   /* Evaluate this expression in the context of a sizeof
 117      operation.  */
 118   virtual value *evaluate_for_sizeof (struct expression *exp,
 119                                       enum noside noside);
 120
 121   /* Evaluate this expression in the context of an address-of
 122      operation.  Must return the address.  */
 123   virtual value *evaluate_for_address (struct expression *exp,
 124                                        enum noside noside);
 125
 126   /* Evaluate a function call, with this object as the callee.
 127      EXPECT_TYPE, EXP, and NOSIDE have the same meaning as in
 128      'evaluate'.  ARGS holds the operations that should be evaluated
 129      to get the arguments to the call.  */
 130   virtual value *evaluate_funcall (struct type *expect_type,
 131                                    struct expression *exp,
 132                                    enum noside noside,
 133                                    const std::vector<operation_up> &args)
 134   {
 135     /* Defer to the helper overload.  */
 136     return evaluate_funcall (expect_type, exp, noside, nullptr, args);
 137   }
 138
 139   /* True if this is a constant expression.  */
 140   virtual bool constant_p () const
 141   { return false; }
 142
 143   /* Return true if this operation uses OBJFILE (and will become
 144      dangling when OBJFILE is unloaded), otherwise return false.
 145      OBJFILE must not be a separate debug info file.  */
 146   virtual bool uses_objfile (struct objfile *objfile) const
 147   { return false; }
 148
 149   /* Generate agent expression bytecodes for this operation.  */
 150   void generate_ax (struct expression *exp, struct agent_expr *ax,
 151                     struct axs_value *value,
 152                     struct type *cast_type = nullptr);
 153
 154   /* Return the opcode that is implemented by this operation.  */
 155   virtual enum exp_opcode opcode () const = 0;
 156
 157   /* Print this operation to STREAM.  */
 158   virtual void dump (struct ui_file *stream, int depth) const = 0;
 159
 160   /* Call to indicate that this is the outermost operation in the
 161      expression.  This should almost never be overridden.  */
 162   virtual void set_outermost () { }
 163
 164 protected:
 165
 166   /* A helper overload that wraps evaluate_subexp_do_call.  */
 167   value *evaluate_funcall (struct type *expect_type,
 168                            struct expression *exp,
 169                            enum noside noside,
 170                            const char *function_name,
 171                            const std::vector<operation_up> &args);
 172
 173   /* Called by generate_ax to do the work for this particular
 174      operation.  */
 175   virtual void do_generate_ax (struct expression *exp,
 176                                struct agent_expr *ax,
 177                                struct axs_value *value,
 178                                struct type *cast_type)
 179   {
 180     error (_("Cannot translate to agent expression"));
 181   }
 182 };
 183
 184 /* A helper function for creating an operation_up, given a type.  */
 185 template<typename T, typename... Arg>
 186 operation_up
 187 make_operation (Arg... args)
 188 {
 189   return operation_up (new T (std::forward<Arg> (args)...));
 190 }
 191
 192 }
 193
 194 struct expression
 195 {
 196   expression (const struct language_defn *lang, struct gdbarch *arch)
 197     : language_defn (lang),
 198       gdbarch (arch)
 199   {
 200   }
 201
 202   DISABLE_COPY_AND_ASSIGN (expression);
 203
 204   /* Return the opcode for the outermost sub-expression of this
 205      expression.  */
 206   enum exp_opcode first_opcode () const
 207   {
 208     return op->opcode ();
 209   }
 210
 211   /* Dump the expression to STREAM.  */
 212   void dump (struct ui_file *stream)
 213   {
 214     op->dump (stream, 0);
 215   }
 216
 217   /* Evaluate the expression.  EXPECT_TYPE is the context type of the
 218      expression; normally this should be nullptr.  NOSIDE controls how
 219      evaluation is performed.  */
 220   struct value *evaluate (struct type *expect_type, enum noside noside);
 221
 222   /* Language it was entered in.  */
 223   const struct language_defn *language_defn;
 224   /* Architecture it was parsed in.  */
 225   struct gdbarch *gdbarch;
 226   expr::operation_up op;
 227 };
 228
 229 typedef std::unique_ptr<expression> expression_up;
 230
 231 /* From parse.c */
 232
 233 class innermost_block_tracker;
 234 extern expression_up parse_expression (const char *,
 235                                        innermost_block_tracker * = nullptr,
 236                                        bool void_context_p = false);
 237
 238 extern expression_up parse_expression_with_language (const char *string,
 239                                                      enum language lang);
 240
 241
 242 class completion_tracker;
 243
 244 /* Base class for expression completion.  An instance of this
 245    represents a completion request from the parser.  */
 246 struct expr_completion_base
 247 {
 248   /* Perform this object's completion.  EXP is the expression in which
 249      the completion occurs.  TRACKER is the tracker to update with the
 250      results.  Return true if completion was possible (even if no
 251      completions were found), false to fall back to ordinary
 252      expression completion (i.e., symbol names).  */
 253   virtual bool complete (struct expression *exp,
 254                          completion_tracker &tracker) = 0;
 255
 256   virtual ~expr_completion_base () = default;
 257 };
 258
 259 extern expression_up parse_expression_for_completion
 260      (const char *, std::unique_ptr<expr_completion_base> *completer);
 261
 262 class innermost_block_tracker;
 263 extern expression_up parse_exp_1 (const char **, CORE_ADDR pc,
 264                                   const struct block *, int,
 265                                   innermost_block_tracker * = nullptr);
 266
 267 /* From eval.c */
 268
 269 /* Evaluate a function call.  The function to be called is in CALLEE and
 270    the arguments passed to the function are in ARGVEC.
 271    FUNCTION_NAME is the name of the function, if known.
 272    DEFAULT_RETURN_TYPE is used as the function's return type if the return
 273    type is unknown.  */
 274
 275 extern struct value *evaluate_subexp_do_call (expression *exp,
 276                                               enum noside noside,
 277                                               value *callee,
 278                                               gdb::array_view<value *> argvec,
 279                                               const char *function_name,
 280                                               type *default_return_type);
 281
 282 /* From expprint.c */
 283
 284 extern const char *op_name (enum exp_opcode opcode);
 285
 286 /* In an OP_RANGE expression, either bound could be empty, indicating
 287    that its value is by default that of the corresponding bound of the
 288    array or string.  Also, the upper end of the range can be exclusive
 289    or inclusive.  So we have six sorts of subrange.  This enumeration
 290    type is to identify this.  */
 291
 292 enum range_flag : unsigned
 293 {
 294   /* This is a standard range.  Both the lower and upper bounds are
 295      defined, and the bounds are inclusive.  */
 296   RANGE_STANDARD = 0,
 297
 298   /* The low bound was not given.  */
 299   RANGE_LOW_BOUND_DEFAULT = 1 << 0,
 300
 301   /* The high bound was not given.  */
 302   RANGE_HIGH_BOUND_DEFAULT = 1 << 1,
 303
 304   /* The high bound of this range is exclusive.  */
 305   RANGE_HIGH_BOUND_EXCLUSIVE = 1 << 2,
 306
 307   /* The range has a stride.  */
 308   RANGE_HAS_STRIDE = 1 << 3,
 309 };
 310
 311 DEF_ENUM_FLAGS_TYPE (enum range_flag, range_flags);
 312
 313 #endif /* !defined (EXPRESSION_H) */