1 /* Definitions for expressions stored in reversed prefix form, for GDB.
3 Copyright (C) 1986-2023 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
20 #if !defined (EXPRESSION_H)
21 #define EXPRESSION_H 1
26 /* While parsing expressions we need to track the innermost lexical block
27 that we encounter. In some situations we need to track the innermost
28 block just for symbols, and in other situations we want to track the
29 innermost block for symbols and registers. These flags are used by the
30 innermost block tracker to control which blocks we consider for the
31 innermost block. These flags can be combined together as needed. */
33 enum innermost_block_tracker_type
35 /* Track the innermost block for symbols within an expression. */
36 INNERMOST_BLOCK_FOR_SYMBOLS
= (1 << 0),
38 /* Track the innermost block for registers within an expression. */
39 INNERMOST_BLOCK_FOR_REGISTERS
= (1 << 1)
41 DEF_ENUM_FLAGS_TYPE (enum innermost_block_tracker_type
,
42 innermost_block_tracker_types
);
44 enum exp_opcode
: uint8_t
46 #define OP(name) name ,
48 #include "std-operator.def"
53 /* Values of NOSIDE argument to eval_subexp. */
58 EVAL_AVOID_SIDE_EFFECTS
/* Don't modify any variables or
59 call any functions. The value
60 returned will have the correct
61 type, and will have an
62 approximately correct lvalue
63 type (inaccuracy: anything that is
64 listed as being in a register in
65 the function in which it was
66 declared will be lval_register).
67 Ideally this would not even read
68 target memory, but currently it
69 does in many situations. */
82 typedef std::unique_ptr
<operation
> operation_up
;
84 /* Base class for an operation. An operation is a single component of
91 operation () = default;
92 DISABLE_COPY_AND_ASSIGN (operation
);
96 virtual ~operation () = default;
98 /* Evaluate this operation. */
99 virtual value
*evaluate (struct type
*expect_type
,
100 struct expression
*exp
,
101 enum noside noside
) = 0;
103 /* Evaluate this operation in a context where C-like coercion is
105 virtual value
*evaluate_with_coercion (struct expression
*exp
,
108 return evaluate (nullptr, exp
, noside
);
111 /* Evaluate this expression in the context of a cast to
113 virtual value
*evaluate_for_cast (struct type
*expect_type
,
114 struct expression
*exp
,
117 /* Evaluate this expression in the context of a sizeof
119 virtual value
*evaluate_for_sizeof (struct expression
*exp
,
122 /* Evaluate this expression in the context of an address-of
123 operation. Must return the address. */
124 virtual value
*evaluate_for_address (struct expression
*exp
,
127 /* Evaluate a function call, with this object as the callee.
128 EXPECT_TYPE, EXP, and NOSIDE have the same meaning as in
129 'evaluate'. ARGS holds the operations that should be evaluated
130 to get the arguments to the call. */
131 virtual value
*evaluate_funcall (struct type
*expect_type
,
132 struct expression
*exp
,
134 const std::vector
<operation_up
> &args
)
136 /* Defer to the helper overload. */
137 return evaluate_funcall (expect_type
, exp
, noside
, nullptr, args
);
140 /* True if this is a constant expression. */
141 virtual bool constant_p () const
144 /* Return true if this operation uses OBJFILE (and will become
145 dangling when OBJFILE is unloaded), otherwise return false.
146 OBJFILE must not be a separate debug info file. */
147 virtual bool uses_objfile (struct objfile
*objfile
) const
150 /* Generate agent expression bytecodes for this operation. */
151 void generate_ax (struct expression
*exp
, struct agent_expr
*ax
,
152 struct axs_value
*value
,
153 struct type
*cast_type
= nullptr);
155 /* Return the opcode that is implemented by this operation. */
156 virtual enum exp_opcode
opcode () const = 0;
158 /* Print this operation to STREAM. */
159 virtual void dump (struct ui_file
*stream
, int depth
) const = 0;
161 /* Call to indicate that this is the outermost operation in the
162 expression. This should almost never be overridden. */
163 virtual void set_outermost () { }
167 /* A helper overload that wraps evaluate_subexp_do_call. */
168 value
*evaluate_funcall (struct type
*expect_type
,
169 struct expression
*exp
,
171 const char *function_name
,
172 const std::vector
<operation_up
> &args
);
174 /* Called by generate_ax to do the work for this particular
176 virtual void do_generate_ax (struct expression
*exp
,
177 struct agent_expr
*ax
,
178 struct axs_value
*value
,
179 struct type
*cast_type
)
181 error (_("Cannot translate to agent expression"));
185 /* A helper function for creating an operation_up, given a type. */
186 template<typename T
, typename
... Arg
>
188 make_operation (Arg
... args
)
190 return operation_up (new T (std::forward
<Arg
> (args
)...));
197 expression (const struct language_defn
*lang
, struct gdbarch
*arch
)
198 : language_defn (lang
),
203 DISABLE_COPY_AND_ASSIGN (expression
);
205 /* Return the opcode for the outermost sub-expression of this
207 enum exp_opcode
first_opcode () const
209 return op
->opcode ();
212 /* Dump the expression to STREAM. */
213 void dump (struct ui_file
*stream
)
215 op
->dump (stream
, 0);
218 /* Return true if this expression uses OBJFILE (and will become
219 dangling when OBJFILE is unloaded), otherwise return false.
220 OBJFILE must not be a separate debug info file. */
221 bool uses_objfile (struct objfile
*objfile
) const;
223 /* Evaluate the expression. EXPECT_TYPE is the context type of the
224 expression; normally this should be nullptr. NOSIDE controls how
225 evaluation is performed. */
226 struct value
*evaluate (struct type
*expect_type
= nullptr,
227 enum noside noside
= EVAL_NORMAL
);
229 /* Evaluate an expression, avoiding all memory references
230 and getting a value whose type alone is correct. */
231 struct value
*evaluate_type ()
232 { return evaluate (nullptr, EVAL_AVOID_SIDE_EFFECTS
); }
234 /* Language it was entered in. */
235 const struct language_defn
*language_defn
;
236 /* Architecture it was parsed in. */
237 struct gdbarch
*gdbarch
;
238 expr::operation_up op
;
241 typedef std::unique_ptr
<expression
> expression_up
;
243 /* When parsing expressions we track the innermost block that was
246 class innermost_block_tracker
249 innermost_block_tracker (innermost_block_tracker_types types
250 = INNERMOST_BLOCK_FOR_SYMBOLS
)
252 m_innermost_block (NULL
)
255 /* Update the stored innermost block if the new block B is more inner
256 than the currently stored block, or if no block is stored yet. The
257 type T tells us whether the block B was for a symbol or for a
258 register. The stored innermost block is only updated if the type T is
259 a type we are interested in, the types we are interested in are held
260 in M_TYPES and set during RESET. */
261 void update (const struct block
*b
, innermost_block_tracker_types t
);
263 /* Overload of main UPDATE method which extracts the block from BS. */
264 void update (const struct block_symbol
&bs
)
266 update (bs
.block
, INNERMOST_BLOCK_FOR_SYMBOLS
);
269 /* Return the stored innermost block. Can be nullptr if no symbols or
270 registers were found during an expression parse, and so no innermost
271 block was defined. */
272 const struct block
*block () const
274 return m_innermost_block
;
278 /* The type of innermost block being looked for. */
279 innermost_block_tracker_types m_types
;
281 /* The currently stored innermost block found while parsing an
283 const struct block
*m_innermost_block
;
288 extern expression_up
parse_expression (const char *,
289 innermost_block_tracker
* = nullptr,
290 bool void_context_p
= false);
292 extern expression_up
parse_expression_with_language (const char *string
,
296 class completion_tracker
;
298 /* Base class for expression completion. An instance of this
299 represents a completion request from the parser. */
300 struct expr_completion_base
302 /* Perform this object's completion. EXP is the expression in which
303 the completion occurs. TRACKER is the tracker to update with the
304 results. Return true if completion was possible (even if no
305 completions were found), false to fall back to ordinary
306 expression completion (i.e., symbol names). */
307 virtual bool complete (struct expression
*exp
,
308 completion_tracker
&tracker
) = 0;
310 virtual ~expr_completion_base () = default;
313 extern expression_up parse_expression_for_completion
314 (const char *, std::unique_ptr
<expr_completion_base
> *completer
);
316 extern expression_up
parse_exp_1 (const char **, CORE_ADDR pc
,
317 const struct block
*, int,
318 innermost_block_tracker
* = nullptr);
322 /* Evaluate a function call. The function to be called is in CALLEE and
323 the arguments passed to the function are in ARGVEC.
324 FUNCTION_NAME is the name of the function, if known.
325 DEFAULT_RETURN_TYPE is used as the function's return type if the return
328 extern struct value
*evaluate_subexp_do_call (expression
*exp
,
331 gdb::array_view
<value
*> argvec
,
332 const char *function_name
,
333 type
*default_return_type
);
335 /* In an OP_RANGE expression, either bound could be empty, indicating
336 that its value is by default that of the corresponding bound of the
337 array or string. Also, the upper end of the range can be exclusive
338 or inclusive. So we have six sorts of subrange. This enumeration
339 type is to identify this. */
341 enum range_flag
: unsigned
343 /* This is a standard range. Both the lower and upper bounds are
344 defined, and the bounds are inclusive. */
347 /* The low bound was not given. */
348 RANGE_LOW_BOUND_DEFAULT
= 1 << 0,
350 /* The high bound was not given. */
351 RANGE_HIGH_BOUND_DEFAULT
= 1 << 1,
353 /* The high bound of this range is exclusive. */
354 RANGE_HIGH_BOUND_EXCLUSIVE
= 1 << 2,
356 /* The range has a stride. */
357 RANGE_HAS_STRIDE
= 1 << 3,
360 DEF_ENUM_FLAGS_TYPE (enum range_flag
, range_flags
);
362 #endif /* !defined (EXPRESSION_H) */