1 /* Definitions for expressions stored in reversed prefix form, for GDB. 2 3 Copyright (C) 1986-2023 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) */ 314