126a4e74d125ec336b646e04e731c97de8355b45
1 /* GDB-specific functions for operating on agent expressions.
3 Copyright (C) 1998-2001, 2003, 2007-2012 Free Software Foundation,
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "expression.h"
34 #include "gdb_string.h"
37 #include "user-regs.h"
39 #include "dictionary.h"
40 #include "breakpoint.h"
41 #include "tracepoint.h"
42 #include "cp-support.h"
43 #include "arch-utils.h"
48 /* To make sense of this file, you should read doc/agentexpr.texi.
49 Then look at the types and enums in ax-gdb.h. For the code itself,
50 look at gen_expr, towards the bottom; that's the main function that
51 looks at the GDB expressions and calls everything else to generate
54 I'm beginning to wonder whether it wouldn't be nicer to internally
55 generate trees, with types, and then spit out the bytecode in
56 linear form afterwards; we could generate fewer `swap', `ext', and
57 `zero_ext' bytecodes that way; it would make good constant folding
58 easier, too. But at the moment, I think we should be willing to
59 pay for the simplicity of this code with less-than-optimal bytecode
62 Remember, "GBD" stands for "Great Britain, Dammit!" So be careful. */
66 /* Prototypes for local functions. */
68 /* There's a standard order to the arguments of these functions:
69 union exp_element ** --- pointer into expression
70 struct agent_expr * --- agent expression buffer to generate code into
71 struct axs_value * --- describes value left on top of stack */
73 static struct value
*const_var_ref (struct symbol
*var
);
74 static struct value
*const_expr (union exp_element
**pc
);
75 static struct value
*maybe_const_expr (union exp_element
**pc
);
77 static void gen_traced_pop (struct gdbarch
*, struct agent_expr
*,
80 static void gen_sign_extend (struct agent_expr
*, struct type
*);
81 static void gen_extend (struct agent_expr
*, struct type
*);
82 static void gen_fetch (struct agent_expr
*, struct type
*);
83 static void gen_left_shift (struct agent_expr
*, int);
86 static void gen_frame_args_address (struct gdbarch
*, struct agent_expr
*);
87 static void gen_frame_locals_address (struct gdbarch
*, struct agent_expr
*);
88 static void gen_offset (struct agent_expr
*ax
, int offset
);
89 static void gen_sym_offset (struct agent_expr
*, struct symbol
*);
90 static void gen_var_ref (struct gdbarch
*, struct agent_expr
*ax
,
91 struct axs_value
*value
, struct symbol
*var
);
94 static void gen_int_literal (struct agent_expr
*ax
,
95 struct axs_value
*value
,
96 LONGEST k
, struct type
*type
);
99 static void require_rvalue (struct agent_expr
*ax
, struct axs_value
*value
);
100 static void gen_usual_unary (struct expression
*exp
, struct agent_expr
*ax
,
101 struct axs_value
*value
);
102 static int type_wider_than (struct type
*type1
, struct type
*type2
);
103 static struct type
*max_type (struct type
*type1
, struct type
*type2
);
104 static void gen_conversion (struct agent_expr
*ax
,
105 struct type
*from
, struct type
*to
);
106 static int is_nontrivial_conversion (struct type
*from
, struct type
*to
);
107 static void gen_usual_arithmetic (struct expression
*exp
,
108 struct agent_expr
*ax
,
109 struct axs_value
*value1
,
110 struct axs_value
*value2
);
111 static void gen_integral_promotions (struct expression
*exp
,
112 struct agent_expr
*ax
,
113 struct axs_value
*value
);
114 static void gen_cast (struct agent_expr
*ax
,
115 struct axs_value
*value
, struct type
*type
);
116 static void gen_scale (struct agent_expr
*ax
,
117 enum agent_op op
, struct type
*type
);
118 static void gen_ptradd (struct agent_expr
*ax
, struct axs_value
*value
,
119 struct axs_value
*value1
, struct axs_value
*value2
);
120 static void gen_ptrsub (struct agent_expr
*ax
, struct axs_value
*value
,
121 struct axs_value
*value1
, struct axs_value
*value2
);
122 static void gen_ptrdiff (struct agent_expr
*ax
, struct axs_value
*value
,
123 struct axs_value
*value1
, struct axs_value
*value2
,
124 struct type
*result_type
);
125 static void gen_binop (struct agent_expr
*ax
,
126 struct axs_value
*value
,
127 struct axs_value
*value1
,
128 struct axs_value
*value2
,
130 enum agent_op op_unsigned
, int may_carry
, char *name
);
131 static void gen_logical_not (struct agent_expr
*ax
, struct axs_value
*value
,
132 struct type
*result_type
);
133 static void gen_complement (struct agent_expr
*ax
, struct axs_value
*value
);
134 static void gen_deref (struct agent_expr
*, struct axs_value
*);
135 static void gen_address_of (struct agent_expr
*, struct axs_value
*);
136 static void gen_bitfield_ref (struct expression
*exp
, struct agent_expr
*ax
,
137 struct axs_value
*value
,
138 struct type
*type
, int start
, int end
);
139 static void gen_primitive_field (struct expression
*exp
,
140 struct agent_expr
*ax
,
141 struct axs_value
*value
,
142 int offset
, int fieldno
, struct type
*type
);
143 static int gen_struct_ref_recursive (struct expression
*exp
,
144 struct agent_expr
*ax
,
145 struct axs_value
*value
,
146 char *field
, int offset
,
148 static void gen_struct_ref (struct expression
*exp
, struct agent_expr
*ax
,
149 struct axs_value
*value
,
151 char *operator_name
, char *operand_name
);
152 static void gen_static_field (struct gdbarch
*gdbarch
,
153 struct agent_expr
*ax
, struct axs_value
*value
,
154 struct type
*type
, int fieldno
);
155 static void gen_repeat (struct expression
*exp
, union exp_element
**pc
,
156 struct agent_expr
*ax
, struct axs_value
*value
);
157 static void gen_sizeof (struct expression
*exp
, union exp_element
**pc
,
158 struct agent_expr
*ax
, struct axs_value
*value
,
159 struct type
*size_type
);
160 static void gen_expr (struct expression
*exp
, union exp_element
**pc
,
161 struct agent_expr
*ax
, struct axs_value
*value
);
162 static void gen_expr_binop_rest (struct expression
*exp
,
163 enum exp_opcode op
, union exp_element
**pc
,
164 struct agent_expr
*ax
,
165 struct axs_value
*value
,
166 struct axs_value
*value1
,
167 struct axs_value
*value2
);
169 static void agent_command (char *exp
, int from_tty
);
172 /* Detecting constant expressions. */
174 /* If the variable reference at *PC is a constant, return its value.
175 Otherwise, return zero.
177 Hey, Wally! How can a variable reference be a constant?
179 Well, Beav, this function really handles the OP_VAR_VALUE operator,
180 not specifically variable references. GDB uses OP_VAR_VALUE to
181 refer to any kind of symbolic reference: function names, enum
182 elements, and goto labels are all handled through the OP_VAR_VALUE
183 operator, even though they're constants. It makes sense given the
186 Gee, Wally, don'cha wonder sometimes if data representations that
187 subvert commonly accepted definitions of terms in favor of heavily
188 context-specific interpretations are really just a tool of the
189 programming hegemony to preserve their power and exclude the
192 static struct value
*
193 const_var_ref (struct symbol
*var
)
195 struct type
*type
= SYMBOL_TYPE (var
);
197 switch (SYMBOL_CLASS (var
))
200 return value_from_longest (type
, (LONGEST
) SYMBOL_VALUE (var
));
203 return value_from_pointer (type
, (CORE_ADDR
) SYMBOL_VALUE_ADDRESS (var
));
211 /* If the expression starting at *PC has a constant value, return it.
212 Otherwise, return zero. If we return a value, then *PC will be
213 advanced to the end of it. If we return zero, *PC could be
215 static struct value
*
216 const_expr (union exp_element
**pc
)
218 enum exp_opcode op
= (*pc
)->opcode
;
225 struct type
*type
= (*pc
)[1].type
;
226 LONGEST k
= (*pc
)[2].longconst
;
229 return value_from_longest (type
, k
);
234 struct value
*v
= const_var_ref ((*pc
)[2].symbol
);
240 /* We could add more operators in here. */
244 v1
= const_expr (pc
);
246 return value_neg (v1
);
256 /* Like const_expr, but guarantee also that *PC is undisturbed if the
257 expression is not constant. */
258 static struct value
*
259 maybe_const_expr (union exp_element
**pc
)
261 union exp_element
*tentative_pc
= *pc
;
262 struct value
*v
= const_expr (&tentative_pc
);
264 /* If we got a value, then update the real PC. */
272 /* Generating bytecode from GDB expressions: general assumptions */
274 /* Here are a few general assumptions made throughout the code; if you
275 want to make a change that contradicts one of these, then you'd
276 better scan things pretty thoroughly.
278 - We assume that all values occupy one stack element. For example,
279 sometimes we'll swap to get at the left argument to a binary
280 operator. If we decide that void values should occupy no stack
281 elements, or that synthetic arrays (whose size is determined at
282 run time, created by the `@' operator) should occupy two stack
283 elements (address and length), then this will cause trouble.
285 - We assume the stack elements are infinitely wide, and that we
286 don't have to worry what happens if the user requests an
287 operation that is wider than the actual interpreter's stack.
288 That is, it's up to the interpreter to handle directly all the
289 integer widths the user has access to. (Woe betide the language
292 - We don't support side effects. Thus, we don't have to worry about
293 GCC's generalized lvalues, function calls, etc.
295 - We don't support floating point. Many places where we switch on
296 some type don't bother to include cases for floating point; there
297 may be even more subtle ways this assumption exists. For
298 example, the arguments to % must be integers.
300 - We assume all subexpressions have a static, unchanging type. If
301 we tried to support convenience variables, this would be a
304 - All values on the stack should always be fully zero- or
307 (I wasn't sure whether to choose this or its opposite --- that
308 only addresses are assumed extended --- but it turns out that
309 neither convention completely eliminates spurious extend
310 operations (if everything is always extended, then you have to
311 extend after add, because it could overflow; if nothing is
312 extended, then you end up producing extends whenever you change
313 sizes), and this is simpler.) */
316 /* Generating bytecode from GDB expressions: the `trace' kludge */
318 /* The compiler in this file is a general-purpose mechanism for
319 translating GDB expressions into bytecode. One ought to be able to
320 find a million and one uses for it.
322 However, at the moment it is HOPELESSLY BRAIN-DAMAGED for the sake
323 of expediency. Let he who is without sin cast the first stone.
325 For the data tracing facility, we need to insert `trace' bytecodes
326 before each data fetch; this records all the memory that the
327 expression touches in the course of evaluation, so that memory will
328 be available when the user later tries to evaluate the expression
331 This should be done (I think) in a post-processing pass, that walks
332 an arbitrary agent expression and inserts `trace' operations at the
333 appropriate points. But it's much faster to just hack them
334 directly into the code. And since we're in a crunch, that's what
337 Setting the flag trace_kludge to non-zero enables the code that
338 emits the trace bytecodes at the appropriate points. */
341 /* Inspired by trace_kludge, this indicates that pointers to chars
342 should get an added tracenz bytecode to record nonzero bytes, up to
343 a length that is the value of trace_string_kludge. */
344 int trace_string_kludge
;
346 /* Scan for all static fields in the given class, including any base
347 classes, and generate tracing bytecodes for each. */
350 gen_trace_static_fields (struct gdbarch
*gdbarch
,
351 struct agent_expr
*ax
,
354 int i
, nbases
= TYPE_N_BASECLASSES (type
);
355 struct axs_value value
;
357 CHECK_TYPEDEF (type
);
359 for (i
= TYPE_NFIELDS (type
) - 1; i
>= nbases
; i
--)
361 if (field_is_static (&TYPE_FIELD (type
, i
)))
363 gen_static_field (gdbarch
, ax
, &value
, type
, i
);
364 if (value
.optimized_out
)
368 case axs_lvalue_memory
:
370 int length
= TYPE_LENGTH (check_typedef (value
.type
));
372 ax_const_l (ax
, length
);
373 ax_simple (ax
, aop_trace
);
377 case axs_lvalue_register
:
378 /* We don't actually need the register's value to be pushed,
379 just note that we need it to be collected. */
380 ax_reg_mask (ax
, value
.u
.reg
);
388 /* Now scan through base classes recursively. */
389 for (i
= 0; i
< nbases
; i
++)
391 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
393 gen_trace_static_fields (gdbarch
, ax
, basetype
);
397 /* Trace the lvalue on the stack, if it needs it. In either case, pop
398 the value. Useful on the left side of a comma, and at the end of
399 an expression being used for tracing. */
401 gen_traced_pop (struct gdbarch
*gdbarch
,
402 struct agent_expr
*ax
, struct axs_value
*value
)
404 int string_trace
= 0;
405 if (trace_string_kludge
406 && TYPE_CODE (value
->type
) == TYPE_CODE_PTR
407 && c_textual_element_type (check_typedef (TYPE_TARGET_TYPE (value
->type
)),
417 ax_const_l (ax
, trace_string_kludge
);
418 ax_simple (ax
, aop_tracenz
);
421 /* We don't trace rvalues, just the lvalues necessary to
422 produce them. So just dispose of this value. */
423 ax_simple (ax
, aop_pop
);
426 case axs_lvalue_memory
:
428 int length
= TYPE_LENGTH (check_typedef (value
->type
));
431 ax_simple (ax
, aop_dup
);
433 /* There's no point in trying to use a trace_quick bytecode
434 here, since "trace_quick SIZE pop" is three bytes, whereas
435 "const8 SIZE trace" is also three bytes, does the same
436 thing, and the simplest code which generates that will also
437 work correctly for objects with large sizes. */
438 ax_const_l (ax
, length
);
439 ax_simple (ax
, aop_trace
);
443 ax_simple (ax
, aop_ref32
);
444 ax_const_l (ax
, trace_string_kludge
);
445 ax_simple (ax
, aop_tracenz
);
450 case axs_lvalue_register
:
451 /* We don't actually need the register's value to be on the
452 stack, and the target will get heartburn if the register is
453 larger than will fit in a stack, so just mark it for
454 collection and be done with it. */
455 ax_reg_mask (ax
, value
->u
.reg
);
457 /* But if the register points to a string, assume the value
458 will fit on the stack and push it anyway. */
461 ax_reg (ax
, value
->u
.reg
);
462 ax_const_l (ax
, trace_string_kludge
);
463 ax_simple (ax
, aop_tracenz
);
468 /* If we're not tracing, just pop the value. */
469 ax_simple (ax
, aop_pop
);
471 /* To trace C++ classes with static fields stored elsewhere. */
473 && (TYPE_CODE (value
->type
) == TYPE_CODE_STRUCT
474 || TYPE_CODE (value
->type
) == TYPE_CODE_UNION
))
475 gen_trace_static_fields (gdbarch
, ax
, value
->type
);
480 /* Generating bytecode from GDB expressions: helper functions */
482 /* Assume that the lower bits of the top of the stack is a value of
483 type TYPE, and the upper bits are zero. Sign-extend if necessary. */
485 gen_sign_extend (struct agent_expr
*ax
, struct type
*type
)
487 /* Do we need to sign-extend this? */
488 if (!TYPE_UNSIGNED (type
))
489 ax_ext (ax
, TYPE_LENGTH (type
) * TARGET_CHAR_BIT
);
493 /* Assume the lower bits of the top of the stack hold a value of type
494 TYPE, and the upper bits are garbage. Sign-extend or truncate as
497 gen_extend (struct agent_expr
*ax
, struct type
*type
)
499 int bits
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
502 ((TYPE_UNSIGNED (type
) ? ax_zero_ext
: ax_ext
) (ax
, bits
));
506 /* Assume that the top of the stack contains a value of type "pointer
507 to TYPE"; generate code to fetch its value. Note that TYPE is the
508 target type, not the pointer type. */
510 gen_fetch (struct agent_expr
*ax
, struct type
*type
)
514 /* Record the area of memory we're about to fetch. */
515 ax_trace_quick (ax
, TYPE_LENGTH (type
));
518 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
519 type
= TYPE_TARGET_TYPE (type
);
521 switch (TYPE_CODE (type
))
529 /* It's a scalar value, so we know how to dereference it. How
530 many bytes long is it? */
531 switch (TYPE_LENGTH (type
))
533 case 8 / TARGET_CHAR_BIT
:
534 ax_simple (ax
, aop_ref8
);
536 case 16 / TARGET_CHAR_BIT
:
537 ax_simple (ax
, aop_ref16
);
539 case 32 / TARGET_CHAR_BIT
:
540 ax_simple (ax
, aop_ref32
);
542 case 64 / TARGET_CHAR_BIT
:
543 ax_simple (ax
, aop_ref64
);
546 /* Either our caller shouldn't have asked us to dereference
547 that pointer (other code's fault), or we're not
548 implementing something we should be (this code's fault).
549 In any case, it's a bug the user shouldn't see. */
551 internal_error (__FILE__
, __LINE__
,
552 _("gen_fetch: strange size"));
555 gen_sign_extend (ax
, type
);
559 /* Our caller requested us to dereference a pointer from an unsupported
560 type. Error out and give callers a chance to handle the failure
562 error (_("gen_fetch: Unsupported type code `%s'."),
568 /* Generate code to left shift the top of the stack by DISTANCE bits, or
569 right shift it by -DISTANCE bits if DISTANCE < 0. This generates
570 unsigned (logical) right shifts. */
572 gen_left_shift (struct agent_expr
*ax
, int distance
)
576 ax_const_l (ax
, distance
);
577 ax_simple (ax
, aop_lsh
);
579 else if (distance
< 0)
581 ax_const_l (ax
, -distance
);
582 ax_simple (ax
, aop_rsh_unsigned
);
588 /* Generating bytecode from GDB expressions: symbol references */
590 /* Generate code to push the base address of the argument portion of
591 the top stack frame. */
593 gen_frame_args_address (struct gdbarch
*gdbarch
, struct agent_expr
*ax
)
596 LONGEST frame_offset
;
598 gdbarch_virtual_frame_pointer (gdbarch
,
599 ax
->scope
, &frame_reg
, &frame_offset
);
600 ax_reg (ax
, frame_reg
);
601 gen_offset (ax
, frame_offset
);
605 /* Generate code to push the base address of the locals portion of the
608 gen_frame_locals_address (struct gdbarch
*gdbarch
, struct agent_expr
*ax
)
611 LONGEST frame_offset
;
613 gdbarch_virtual_frame_pointer (gdbarch
,
614 ax
->scope
, &frame_reg
, &frame_offset
);
615 ax_reg (ax
, frame_reg
);
616 gen_offset (ax
, frame_offset
);
620 /* Generate code to add OFFSET to the top of the stack. Try to
621 generate short and readable code. We use this for getting to
622 variables on the stack, and structure members. If we were
623 programming in ML, it would be clearer why these are the same
626 gen_offset (struct agent_expr
*ax
, int offset
)
628 /* It would suffice to simply push the offset and add it, but this
629 makes it easier to read positive and negative offsets in the
633 ax_const_l (ax
, offset
);
634 ax_simple (ax
, aop_add
);
638 ax_const_l (ax
, -offset
);
639 ax_simple (ax
, aop_sub
);
644 /* In many cases, a symbol's value is the offset from some other
645 address (stack frame, base register, etc.) Generate code to add
646 VAR's value to the top of the stack. */
648 gen_sym_offset (struct agent_expr
*ax
, struct symbol
*var
)
650 gen_offset (ax
, SYMBOL_VALUE (var
));
654 /* Generate code for a variable reference to AX. The variable is the
655 symbol VAR. Set VALUE to describe the result. */
658 gen_var_ref (struct gdbarch
*gdbarch
, struct agent_expr
*ax
,
659 struct axs_value
*value
, struct symbol
*var
)
661 /* Dereference any typedefs. */
662 value
->type
= check_typedef (SYMBOL_TYPE (var
));
663 value
->optimized_out
= 0;
665 /* I'm imitating the code in read_var_value. */
666 switch (SYMBOL_CLASS (var
))
668 case LOC_CONST
: /* A constant, like an enum value. */
669 ax_const_l (ax
, (LONGEST
) SYMBOL_VALUE (var
));
670 value
->kind
= axs_rvalue
;
673 case LOC_LABEL
: /* A goto label, being used as a value. */
674 ax_const_l (ax
, (LONGEST
) SYMBOL_VALUE_ADDRESS (var
));
675 value
->kind
= axs_rvalue
;
678 case LOC_CONST_BYTES
:
679 internal_error (__FILE__
, __LINE__
,
680 _("gen_var_ref: LOC_CONST_BYTES "
681 "symbols are not supported"));
683 /* Variable at a fixed location in memory. Easy. */
685 /* Push the address of the variable. */
686 ax_const_l (ax
, SYMBOL_VALUE_ADDRESS (var
));
687 value
->kind
= axs_lvalue_memory
;
690 case LOC_ARG
: /* var lives in argument area of frame */
691 gen_frame_args_address (gdbarch
, ax
);
692 gen_sym_offset (ax
, var
);
693 value
->kind
= axs_lvalue_memory
;
696 case LOC_REF_ARG
: /* As above, but the frame slot really
697 holds the address of the variable. */
698 gen_frame_args_address (gdbarch
, ax
);
699 gen_sym_offset (ax
, var
);
700 /* Don't assume any particular pointer size. */
701 gen_fetch (ax
, builtin_type (gdbarch
)->builtin_data_ptr
);
702 value
->kind
= axs_lvalue_memory
;
705 case LOC_LOCAL
: /* var lives in locals area of frame */
706 gen_frame_locals_address (gdbarch
, ax
);
707 gen_sym_offset (ax
, var
);
708 value
->kind
= axs_lvalue_memory
;
712 error (_("Cannot compute value of typedef `%s'."),
713 SYMBOL_PRINT_NAME (var
));
717 ax_const_l (ax
, BLOCK_START (SYMBOL_BLOCK_VALUE (var
)));
718 value
->kind
= axs_rvalue
;
722 /* Don't generate any code at all; in the process of treating
723 this as an lvalue or rvalue, the caller will generate the
725 value
->kind
= axs_lvalue_register
;
726 value
->u
.reg
= SYMBOL_REGISTER_OPS (var
)->register_number (var
, gdbarch
);
729 /* A lot like LOC_REF_ARG, but the pointer lives directly in a
730 register, not on the stack. Simpler than LOC_REGISTER
731 because it's just like any other case where the thing
732 has a real address. */
733 case LOC_REGPARM_ADDR
:
734 ax_reg (ax
, SYMBOL_REGISTER_OPS (var
)->register_number (var
, gdbarch
));
735 value
->kind
= axs_lvalue_memory
;
740 struct minimal_symbol
*msym
741 = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var
), NULL
, NULL
);
744 error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var
));
746 /* Push the address of the variable. */
747 ax_const_l (ax
, SYMBOL_VALUE_ADDRESS (msym
));
748 value
->kind
= axs_lvalue_memory
;
753 /* FIXME: cagney/2004-01-26: It should be possible to
754 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
755 Unfortunately DWARF 2 stores the frame-base (instead of the
756 function) location in a function's symbol. Oops! For the
757 moment enable this when/where applicable. */
758 SYMBOL_COMPUTED_OPS (var
)->tracepoint_var_ref (var
, gdbarch
, ax
, value
);
761 case LOC_OPTIMIZED_OUT
:
762 /* Flag this, but don't say anything; leave it up to callers to
764 value
->optimized_out
= 1;
768 error (_("Cannot find value of botched symbol `%s'."),
769 SYMBOL_PRINT_NAME (var
));
776 /* Generating bytecode from GDB expressions: literals */
779 gen_int_literal (struct agent_expr
*ax
, struct axs_value
*value
, LONGEST k
,
783 value
->kind
= axs_rvalue
;
784 value
->type
= check_typedef (type
);
789 /* Generating bytecode from GDB expressions: unary conversions, casts */
791 /* Take what's on the top of the stack (as described by VALUE), and
792 try to make an rvalue out of it. Signal an error if we can't do
795 require_rvalue (struct agent_expr
*ax
, struct axs_value
*value
)
797 /* Only deal with scalars, structs and such may be too large
798 to fit in a stack entry. */
799 value
->type
= check_typedef (value
->type
);
800 if (TYPE_CODE (value
->type
) == TYPE_CODE_ARRAY
801 || TYPE_CODE (value
->type
) == TYPE_CODE_STRUCT
802 || TYPE_CODE (value
->type
) == TYPE_CODE_UNION
803 || TYPE_CODE (value
->type
) == TYPE_CODE_FUNC
)
804 error (_("Value not scalar: cannot be an rvalue."));
809 /* It's already an rvalue. */
812 case axs_lvalue_memory
:
813 /* The top of stack is the address of the object. Dereference. */
814 gen_fetch (ax
, value
->type
);
817 case axs_lvalue_register
:
818 /* There's nothing on the stack, but value->u.reg is the
819 register number containing the value.
821 When we add floating-point support, this is going to have to
822 change. What about SPARC register pairs, for example? */
823 ax_reg (ax
, value
->u
.reg
);
824 gen_extend (ax
, value
->type
);
828 value
->kind
= axs_rvalue
;
832 /* Assume the top of the stack is described by VALUE, and perform the
833 usual unary conversions. This is motivated by ANSI 6.2.2, but of
834 course GDB expressions are not ANSI; they're the mishmash union of
835 a bunch of languages. Rah.
837 NOTE! This function promises to produce an rvalue only when the
838 incoming value is of an appropriate type. In other words, the
839 consumer of the value this function produces may assume the value
840 is an rvalue only after checking its type.
842 The immediate issue is that if the user tries to use a structure or
843 union as an operand of, say, the `+' operator, we don't want to try
844 to convert that structure to an rvalue; require_rvalue will bomb on
845 structs and unions. Rather, we want to simply pass the struct
846 lvalue through unchanged, and let `+' raise an error. */
849 gen_usual_unary (struct expression
*exp
, struct agent_expr
*ax
,
850 struct axs_value
*value
)
852 /* We don't have to generate any code for the usual integral
853 conversions, since values are always represented as full-width on
854 the stack. Should we tweak the type? */
856 /* Some types require special handling. */
857 switch (TYPE_CODE (value
->type
))
859 /* Functions get converted to a pointer to the function. */
861 value
->type
= lookup_pointer_type (value
->type
);
862 value
->kind
= axs_rvalue
; /* Should always be true, but just in case. */
865 /* Arrays get converted to a pointer to their first element, and
866 are no longer an lvalue. */
867 case TYPE_CODE_ARRAY
:
869 struct type
*elements
= TYPE_TARGET_TYPE (value
->type
);
871 value
->type
= lookup_pointer_type (elements
);
872 value
->kind
= axs_rvalue
;
873 /* We don't need to generate any code; the address of the array
874 is also the address of its first element. */
878 /* Don't try to convert structures and unions to rvalues. Let the
879 consumer signal an error. */
880 case TYPE_CODE_STRUCT
:
881 case TYPE_CODE_UNION
:
884 /* If the value is an enum or a bool, call it an integer. */
887 value
->type
= builtin_type (exp
->gdbarch
)->builtin_int
;
891 /* If the value is an lvalue, dereference it. */
892 require_rvalue (ax
, value
);
896 /* Return non-zero iff the type TYPE1 is considered "wider" than the
897 type TYPE2, according to the rules described in gen_usual_arithmetic. */
899 type_wider_than (struct type
*type1
, struct type
*type2
)
901 return (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
)
902 || (TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
903 && TYPE_UNSIGNED (type1
)
904 && !TYPE_UNSIGNED (type2
)));
908 /* Return the "wider" of the two types TYPE1 and TYPE2. */
910 max_type (struct type
*type1
, struct type
*type2
)
912 return type_wider_than (type1
, type2
) ? type1
: type2
;
916 /* Generate code to convert a scalar value of type FROM to type TO. */
918 gen_conversion (struct agent_expr
*ax
, struct type
*from
, struct type
*to
)
920 /* Perhaps there is a more graceful way to state these rules. */
922 /* If we're converting to a narrower type, then we need to clear out
924 if (TYPE_LENGTH (to
) < TYPE_LENGTH (from
))
925 gen_extend (ax
, from
);
927 /* If the two values have equal width, but different signednesses,
928 then we need to extend. */
929 else if (TYPE_LENGTH (to
) == TYPE_LENGTH (from
))
931 if (TYPE_UNSIGNED (from
) != TYPE_UNSIGNED (to
))
935 /* If we're converting to a wider type, and becoming unsigned, then
936 we need to zero out any possible sign bits. */
937 else if (TYPE_LENGTH (to
) > TYPE_LENGTH (from
))
939 if (TYPE_UNSIGNED (to
))
945 /* Return non-zero iff the type FROM will require any bytecodes to be
946 emitted to be converted to the type TO. */
948 is_nontrivial_conversion (struct type
*from
, struct type
*to
)
950 struct agent_expr
*ax
= new_agent_expr (NULL
, 0);
953 /* Actually generate the code, and see if anything came out. At the
954 moment, it would be trivial to replicate the code in
955 gen_conversion here, but in the future, when we're supporting
956 floating point and the like, it may not be. Doing things this
957 way allows this function to be independent of the logic in
959 gen_conversion (ax
, from
, to
);
960 nontrivial
= ax
->len
> 0;
961 free_agent_expr (ax
);
966 /* Generate code to perform the "usual arithmetic conversions" (ANSI C
967 6.2.1.5) for the two operands of an arithmetic operator. This
968 effectively finds a "least upper bound" type for the two arguments,
969 and promotes each argument to that type. *VALUE1 and *VALUE2
970 describe the values as they are passed in, and as they are left. */
972 gen_usual_arithmetic (struct expression
*exp
, struct agent_expr
*ax
,
973 struct axs_value
*value1
, struct axs_value
*value2
)
975 /* Do the usual binary conversions. */
976 if (TYPE_CODE (value1
->type
) == TYPE_CODE_INT
977 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
979 /* The ANSI integral promotions seem to work this way: Order the
980 integer types by size, and then by signedness: an n-bit
981 unsigned type is considered "wider" than an n-bit signed
982 type. Promote to the "wider" of the two types, and always
983 promote at least to int. */
984 struct type
*target
= max_type (builtin_type (exp
->gdbarch
)->builtin_int
,
985 max_type (value1
->type
, value2
->type
));
987 /* Deal with value2, on the top of the stack. */
988 gen_conversion (ax
, value2
->type
, target
);
990 /* Deal with value1, not on the top of the stack. Don't
991 generate the `swap' instructions if we're not actually going
993 if (is_nontrivial_conversion (value1
->type
, target
))
995 ax_simple (ax
, aop_swap
);
996 gen_conversion (ax
, value1
->type
, target
);
997 ax_simple (ax
, aop_swap
);
1000 value1
->type
= value2
->type
= check_typedef (target
);
1005 /* Generate code to perform the integral promotions (ANSI 6.2.1.1) on
1006 the value on the top of the stack, as described by VALUE. Assume
1007 the value has integral type. */
1009 gen_integral_promotions (struct expression
*exp
, struct agent_expr
*ax
,
1010 struct axs_value
*value
)
1012 const struct builtin_type
*builtin
= builtin_type (exp
->gdbarch
);
1014 if (!type_wider_than (value
->type
, builtin
->builtin_int
))
1016 gen_conversion (ax
, value
->type
, builtin
->builtin_int
);
1017 value
->type
= builtin
->builtin_int
;
1019 else if (!type_wider_than (value
->type
, builtin
->builtin_unsigned_int
))
1021 gen_conversion (ax
, value
->type
, builtin
->builtin_unsigned_int
);
1022 value
->type
= builtin
->builtin_unsigned_int
;
1027 /* Generate code for a cast to TYPE. */
1029 gen_cast (struct agent_expr
*ax
, struct axs_value
*value
, struct type
*type
)
1031 /* GCC does allow casts to yield lvalues, so this should be fixed
1032 before merging these changes into the trunk. */
1033 require_rvalue (ax
, value
);
1034 /* Dereference typedefs. */
1035 type
= check_typedef (type
);
1037 switch (TYPE_CODE (type
))
1041 /* It's implementation-defined, and I'll bet this is what GCC
1045 case TYPE_CODE_ARRAY
:
1046 case TYPE_CODE_STRUCT
:
1047 case TYPE_CODE_UNION
:
1048 case TYPE_CODE_FUNC
:
1049 error (_("Invalid type cast: intended type must be scalar."));
1051 case TYPE_CODE_ENUM
:
1052 case TYPE_CODE_BOOL
:
1053 /* We don't have to worry about the size of the value, because
1054 all our integral values are fully sign-extended, and when
1055 casting pointers we can do anything we like. Is there any
1056 way for us to know what GCC actually does with a cast like
1061 gen_conversion (ax
, value
->type
, type
);
1064 case TYPE_CODE_VOID
:
1065 /* We could pop the value, and rely on everyone else to check
1066 the type and notice that this value doesn't occupy a stack
1067 slot. But for now, leave the value on the stack, and
1068 preserve the "value == stack element" assumption. */
1072 error (_("Casts to requested type are not yet implemented."));
1080 /* Generating bytecode from GDB expressions: arithmetic */
1082 /* Scale the integer on the top of the stack by the size of the target
1083 of the pointer type TYPE. */
1085 gen_scale (struct agent_expr
*ax
, enum agent_op op
, struct type
*type
)
1087 struct type
*element
= TYPE_TARGET_TYPE (type
);
1089 if (TYPE_LENGTH (element
) != 1)
1091 ax_const_l (ax
, TYPE_LENGTH (element
));
1097 /* Generate code for pointer arithmetic PTR + INT. */
1099 gen_ptradd (struct agent_expr
*ax
, struct axs_value
*value
,
1100 struct axs_value
*value1
, struct axs_value
*value2
)
1102 gdb_assert (pointer_type (value1
->type
));
1103 gdb_assert (TYPE_CODE (value2
->type
) == TYPE_CODE_INT
);
1105 gen_scale (ax
, aop_mul
, value1
->type
);
1106 ax_simple (ax
, aop_add
);
1107 gen_extend (ax
, value1
->type
); /* Catch overflow. */
1108 value
->type
= value1
->type
;
1109 value
->kind
= axs_rvalue
;
1113 /* Generate code for pointer arithmetic PTR - INT. */
1115 gen_ptrsub (struct agent_expr
*ax
, struct axs_value
*value
,
1116 struct axs_value
*value1
, struct axs_value
*value2
)
1118 gdb_assert (pointer_type (value1
->type
));
1119 gdb_assert (TYPE_CODE (value2
->type
) == TYPE_CODE_INT
);
1121 gen_scale (ax
, aop_mul
, value1
->type
);
1122 ax_simple (ax
, aop_sub
);
1123 gen_extend (ax
, value1
->type
); /* Catch overflow. */
1124 value
->type
= value1
->type
;
1125 value
->kind
= axs_rvalue
;
1129 /* Generate code for pointer arithmetic PTR - PTR. */
1131 gen_ptrdiff (struct agent_expr
*ax
, struct axs_value
*value
,
1132 struct axs_value
*value1
, struct axs_value
*value2
,
1133 struct type
*result_type
)
1135 gdb_assert (pointer_type (value1
->type
));
1136 gdb_assert (pointer_type (value2
->type
));
1138 if (TYPE_LENGTH (TYPE_TARGET_TYPE (value1
->type
))
1139 != TYPE_LENGTH (TYPE_TARGET_TYPE (value2
->type
)))
1141 First argument of `-' is a pointer, but second argument is neither\n\
1142 an integer nor a pointer of the same type."));
1144 ax_simple (ax
, aop_sub
);
1145 gen_scale (ax
, aop_div_unsigned
, value1
->type
);
1146 value
->type
= result_type
;
1147 value
->kind
= axs_rvalue
;
1151 gen_equal (struct agent_expr
*ax
, struct axs_value
*value
,
1152 struct axs_value
*value1
, struct axs_value
*value2
,
1153 struct type
*result_type
)
1155 if (pointer_type (value1
->type
) || pointer_type (value2
->type
))
1156 ax_simple (ax
, aop_equal
);
1158 gen_binop (ax
, value
, value1
, value2
,
1159 aop_equal
, aop_equal
, 0, "equal");
1160 value
->type
= result_type
;
1161 value
->kind
= axs_rvalue
;
1165 gen_less (struct agent_expr
*ax
, struct axs_value
*value
,
1166 struct axs_value
*value1
, struct axs_value
*value2
,
1167 struct type
*result_type
)
1169 if (pointer_type (value1
->type
) || pointer_type (value2
->type
))
1170 ax_simple (ax
, aop_less_unsigned
);
1172 gen_binop (ax
, value
, value1
, value2
,
1173 aop_less_signed
, aop_less_unsigned
, 0, "less than");
1174 value
->type
= result_type
;
1175 value
->kind
= axs_rvalue
;
1178 /* Generate code for a binary operator that doesn't do pointer magic.
1179 We set VALUE to describe the result value; we assume VALUE1 and
1180 VALUE2 describe the two operands, and that they've undergone the
1181 usual binary conversions. MAY_CARRY should be non-zero iff the
1182 result needs to be extended. NAME is the English name of the
1183 operator, used in error messages */
1185 gen_binop (struct agent_expr
*ax
, struct axs_value
*value
,
1186 struct axs_value
*value1
, struct axs_value
*value2
,
1187 enum agent_op op
, enum agent_op op_unsigned
,
1188 int may_carry
, char *name
)
1190 /* We only handle INT op INT. */
1191 if ((TYPE_CODE (value1
->type
) != TYPE_CODE_INT
)
1192 || (TYPE_CODE (value2
->type
) != TYPE_CODE_INT
))
1193 error (_("Invalid combination of types in %s."), name
);
1196 TYPE_UNSIGNED (value1
->type
) ? op_unsigned
: op
);
1198 gen_extend (ax
, value1
->type
); /* catch overflow */
1199 value
->type
= value1
->type
;
1200 value
->kind
= axs_rvalue
;
1205 gen_logical_not (struct agent_expr
*ax
, struct axs_value
*value
,
1206 struct type
*result_type
)
1208 if (TYPE_CODE (value
->type
) != TYPE_CODE_INT
1209 && TYPE_CODE (value
->type
) != TYPE_CODE_PTR
)
1210 error (_("Invalid type of operand to `!'."));
1212 ax_simple (ax
, aop_log_not
);
1213 value
->type
= result_type
;
1218 gen_complement (struct agent_expr
*ax
, struct axs_value
*value
)
1220 if (TYPE_CODE (value
->type
) != TYPE_CODE_INT
)
1221 error (_("Invalid type of operand to `~'."));
1223 ax_simple (ax
, aop_bit_not
);
1224 gen_extend (ax
, value
->type
);
1229 /* Generating bytecode from GDB expressions: * & . -> @ sizeof */
1231 /* Dereference the value on the top of the stack. */
1233 gen_deref (struct agent_expr
*ax
, struct axs_value
*value
)
1235 /* The caller should check the type, because several operators use
1236 this, and we don't know what error message to generate. */
1237 if (!pointer_type (value
->type
))
1238 internal_error (__FILE__
, __LINE__
,
1239 _("gen_deref: expected a pointer"));
1241 /* We've got an rvalue now, which is a pointer. We want to yield an
1242 lvalue, whose address is exactly that pointer. So we don't
1243 actually emit any code; we just change the type from "Pointer to
1244 T" to "T", and mark the value as an lvalue in memory. Leave it
1245 to the consumer to actually dereference it. */
1246 value
->type
= check_typedef (TYPE_TARGET_TYPE (value
->type
));
1247 if (TYPE_CODE (value
->type
) == TYPE_CODE_VOID
)
1248 error (_("Attempt to dereference a generic pointer."));
1249 value
->kind
= ((TYPE_CODE (value
->type
) == TYPE_CODE_FUNC
)
1250 ? axs_rvalue
: axs_lvalue_memory
);
1254 /* Produce the address of the lvalue on the top of the stack. */
1256 gen_address_of (struct agent_expr
*ax
, struct axs_value
*value
)
1258 /* Special case for taking the address of a function. The ANSI
1259 standard describes this as a special case, too, so this
1260 arrangement is not without motivation. */
1261 if (TYPE_CODE (value
->type
) == TYPE_CODE_FUNC
)
1262 /* The value's already an rvalue on the stack, so we just need to
1264 value
->type
= lookup_pointer_type (value
->type
);
1266 switch (value
->kind
)
1269 error (_("Operand of `&' is an rvalue, which has no address."));
1271 case axs_lvalue_register
:
1272 error (_("Operand of `&' is in a register, and has no address."));
1274 case axs_lvalue_memory
:
1275 value
->kind
= axs_rvalue
;
1276 value
->type
= lookup_pointer_type (value
->type
);
1281 /* Generate code to push the value of a bitfield of a structure whose
1282 address is on the top of the stack. START and END give the
1283 starting and one-past-ending *bit* numbers of the field within the
1286 gen_bitfield_ref (struct expression
*exp
, struct agent_expr
*ax
,
1287 struct axs_value
*value
, struct type
*type
,
1290 /* Note that ops[i] fetches 8 << i bits. */
1291 static enum agent_op ops
[]
1292 = {aop_ref8
, aop_ref16
, aop_ref32
, aop_ref64
};
1293 static int num_ops
= (sizeof (ops
) / sizeof (ops
[0]));
1295 /* We don't want to touch any byte that the bitfield doesn't
1296 actually occupy; we shouldn't make any accesses we're not
1297 explicitly permitted to. We rely here on the fact that the
1298 bytecode `ref' operators work on unaligned addresses.
1300 It takes some fancy footwork to get the stack to work the way
1301 we'd like. Say we're retrieving a bitfield that requires three
1302 fetches. Initially, the stack just contains the address:
1304 For the first fetch, we duplicate the address
1306 then add the byte offset, do the fetch, and shift and mask as
1307 needed, yielding a fragment of the value, properly aligned for
1308 the final bitwise or:
1310 then we swap, and repeat the process:
1311 frag1 addr --- address on top
1312 frag1 addr addr --- duplicate it
1313 frag1 addr frag2 --- get second fragment
1314 frag1 frag2 addr --- swap again
1315 frag1 frag2 frag3 --- get third fragment
1316 Notice that, since the third fragment is the last one, we don't
1317 bother duplicating the address this time. Now we have all the
1318 fragments on the stack, and we can simply `or' them together,
1319 yielding the final value of the bitfield. */
1321 /* The first and one-after-last bits in the field, but rounded down
1322 and up to byte boundaries. */
1323 int bound_start
= (start
/ TARGET_CHAR_BIT
) * TARGET_CHAR_BIT
;
1324 int bound_end
= (((end
+ TARGET_CHAR_BIT
- 1)
1328 /* current bit offset within the structure */
1331 /* The index in ops of the opcode we're considering. */
1334 /* The number of fragments we generated in the process. Probably
1335 equal to the number of `one' bits in bytesize, but who cares? */
1338 /* Dereference any typedefs. */
1339 type
= check_typedef (type
);
1341 /* Can we fetch the number of bits requested at all? */
1342 if ((end
- start
) > ((1 << num_ops
) * 8))
1343 internal_error (__FILE__
, __LINE__
,
1344 _("gen_bitfield_ref: bitfield too wide"));
1346 /* Note that we know here that we only need to try each opcode once.
1347 That may not be true on machines with weird byte sizes. */
1348 offset
= bound_start
;
1350 for (op
= num_ops
- 1; op
>= 0; op
--)
1352 /* number of bits that ops[op] would fetch */
1353 int op_size
= 8 << op
;
1355 /* The stack at this point, from bottom to top, contains zero or
1356 more fragments, then the address. */
1358 /* Does this fetch fit within the bitfield? */
1359 if (offset
+ op_size
<= bound_end
)
1361 /* Is this the last fragment? */
1362 int last_frag
= (offset
+ op_size
== bound_end
);
1365 ax_simple (ax
, aop_dup
); /* keep a copy of the address */
1367 /* Add the offset. */
1368 gen_offset (ax
, offset
/ TARGET_CHAR_BIT
);
1372 /* Record the area of memory we're about to fetch. */
1373 ax_trace_quick (ax
, op_size
/ TARGET_CHAR_BIT
);
1376 /* Perform the fetch. */
1377 ax_simple (ax
, ops
[op
]);
1379 /* Shift the bits we have to their proper position.
1380 gen_left_shift will generate right shifts when the operand
1383 A big-endian field diagram to ponder:
1384 byte 0 byte 1 byte 2 byte 3 byte 4 byte 5 byte 6 byte 7
1385 +------++------++------++------++------++------++------++------+
1386 xxxxAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCxxxxxxxxxxx
1388 bit number 16 32 48 53
1389 These are bit numbers as supplied by GDB. Note that the
1390 bit numbers run from right to left once you've fetched the
1393 A little-endian field diagram to ponder:
1394 byte 7 byte 6 byte 5 byte 4 byte 3 byte 2 byte 1 byte 0
1395 +------++------++------++------++------++------++------++------+
1396 xxxxxxxxxxxAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCxxxx
1398 bit number 48 32 16 4 0
1400 In both cases, the most significant end is on the left
1401 (i.e. normal numeric writing order), which means that you
1402 don't go crazy thinking about `left' and `right' shifts.
1404 We don't have to worry about masking yet:
1405 - If they contain garbage off the least significant end, then we
1406 must be looking at the low end of the field, and the right
1407 shift will wipe them out.
1408 - If they contain garbage off the most significant end, then we
1409 must be looking at the most significant end of the word, and
1410 the sign/zero extension will wipe them out.
1411 - If we're in the interior of the word, then there is no garbage
1412 on either end, because the ref operators zero-extend. */
1413 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
1414 gen_left_shift (ax
, end
- (offset
+ op_size
));
1416 gen_left_shift (ax
, offset
- start
);
1419 /* Bring the copy of the address up to the top. */
1420 ax_simple (ax
, aop_swap
);
1427 /* Generate enough bitwise `or' operations to combine all the
1428 fragments we left on the stack. */
1429 while (fragment_count
-- > 1)
1430 ax_simple (ax
, aop_bit_or
);
1432 /* Sign- or zero-extend the value as appropriate. */
1433 ((TYPE_UNSIGNED (type
) ? ax_zero_ext
: ax_ext
) (ax
, end
- start
));
1435 /* This is *not* an lvalue. Ugh. */
1436 value
->kind
= axs_rvalue
;
1440 /* Generate bytecodes for field number FIELDNO of type TYPE. OFFSET
1441 is an accumulated offset (in bytes), will be nonzero for objects
1442 embedded in other objects, like C++ base classes. Behavior should
1443 generally follow value_primitive_field. */
1446 gen_primitive_field (struct expression
*exp
,
1447 struct agent_expr
*ax
, struct axs_value
*value
,
1448 int offset
, int fieldno
, struct type
*type
)
1450 /* Is this a bitfield? */
1451 if (TYPE_FIELD_PACKED (type
, fieldno
))
1452 gen_bitfield_ref (exp
, ax
, value
, TYPE_FIELD_TYPE (type
, fieldno
),
1453 (offset
* TARGET_CHAR_BIT
1454 + TYPE_FIELD_BITPOS (type
, fieldno
)),
1455 (offset
* TARGET_CHAR_BIT
1456 + TYPE_FIELD_BITPOS (type
, fieldno
)
1457 + TYPE_FIELD_BITSIZE (type
, fieldno
)));
1460 gen_offset (ax
, offset
1461 + TYPE_FIELD_BITPOS (type
, fieldno
) / TARGET_CHAR_BIT
);
1462 value
->kind
= axs_lvalue_memory
;
1463 value
->type
= TYPE_FIELD_TYPE (type
, fieldno
);
1467 /* Search for the given field in either the given type or one of its
1468 base classes. Return 1 if found, 0 if not. */
1471 gen_struct_ref_recursive (struct expression
*exp
, struct agent_expr
*ax
,
1472 struct axs_value
*value
,
1473 char *field
, int offset
, struct type
*type
)
1476 int nbases
= TYPE_N_BASECLASSES (type
);
1478 CHECK_TYPEDEF (type
);
1480 for (i
= TYPE_NFIELDS (type
) - 1; i
>= nbases
; i
--)
1482 const char *this_name
= TYPE_FIELD_NAME (type
, i
);
1486 if (strcmp (field
, this_name
) == 0)
1488 /* Note that bytecodes for the struct's base (aka
1489 "this") will have been generated already, which will
1490 be unnecessary but not harmful if the static field is
1491 being handled as a global. */
1492 if (field_is_static (&TYPE_FIELD (type
, i
)))
1494 gen_static_field (exp
->gdbarch
, ax
, value
, type
, i
);
1495 if (value
->optimized_out
)
1496 error (_("static field `%s' has been "
1497 "optimized out, cannot use"),
1502 gen_primitive_field (exp
, ax
, value
, offset
, i
, type
);
1505 #if 0 /* is this right? */
1506 if (this_name
[0] == '\0')
1507 internal_error (__FILE__
, __LINE__
,
1508 _("find_field: anonymous unions not supported"));
1513 /* Now scan through base classes recursively. */
1514 for (i
= 0; i
< nbases
; i
++)
1516 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
1518 rslt
= gen_struct_ref_recursive (exp
, ax
, value
, field
,
1519 offset
+ TYPE_BASECLASS_BITPOS (type
, i
)
1526 /* Not found anywhere, flag so caller can complain. */
1530 /* Generate code to reference the member named FIELD of a structure or
1531 union. The top of the stack, as described by VALUE, should have
1532 type (pointer to a)* struct/union. OPERATOR_NAME is the name of
1533 the operator being compiled, and OPERAND_NAME is the kind of thing
1534 it operates on; we use them in error messages. */
1536 gen_struct_ref (struct expression
*exp
, struct agent_expr
*ax
,
1537 struct axs_value
*value
, char *field
,
1538 char *operator_name
, char *operand_name
)
1543 /* Follow pointers until we reach a non-pointer. These aren't the C
1544 semantics, but they're what the normal GDB evaluator does, so we
1545 should at least be consistent. */
1546 while (pointer_type (value
->type
))
1548 require_rvalue (ax
, value
);
1549 gen_deref (ax
, value
);
1551 type
= check_typedef (value
->type
);
1553 /* This must yield a structure or a union. */
1554 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1555 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1556 error (_("The left operand of `%s' is not a %s."),
1557 operator_name
, operand_name
);
1559 /* And it must be in memory; we don't deal with structure rvalues,
1560 or structures living in registers. */
1561 if (value
->kind
!= axs_lvalue_memory
)
1562 error (_("Structure does not live in memory."));
1564 /* Search through fields and base classes recursively. */
1565 found
= gen_struct_ref_recursive (exp
, ax
, value
, field
, 0, type
);
1568 error (_("Couldn't find member named `%s' in struct/union/class `%s'"),
1569 field
, TYPE_TAG_NAME (type
));
1573 gen_namespace_elt (struct expression
*exp
,
1574 struct agent_expr
*ax
, struct axs_value
*value
,
1575 const struct type
*curtype
, char *name
);
1577 gen_maybe_namespace_elt (struct expression
*exp
,
1578 struct agent_expr
*ax
, struct axs_value
*value
,
1579 const struct type
*curtype
, char *name
);
1582 gen_static_field (struct gdbarch
*gdbarch
,
1583 struct agent_expr
*ax
, struct axs_value
*value
,
1584 struct type
*type
, int fieldno
)
1586 if (TYPE_FIELD_LOC_KIND (type
, fieldno
) == FIELD_LOC_KIND_PHYSADDR
)
1588 ax_const_l (ax
, TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
));
1589 value
->kind
= axs_lvalue_memory
;
1590 value
->type
= TYPE_FIELD_TYPE (type
, fieldno
);
1591 value
->optimized_out
= 0;
1595 const char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
1596 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_DOMAIN
, 0);
1600 gen_var_ref (gdbarch
, ax
, value
, sym
);
1602 /* Don't error if the value was optimized out, we may be
1603 scanning all static fields and just want to pass over this
1604 and continue with the rest. */
1608 /* Silently assume this was optimized out; class printing
1609 will let the user know why the data is missing. */
1610 value
->optimized_out
= 1;
1616 gen_struct_elt_for_reference (struct expression
*exp
,
1617 struct agent_expr
*ax
, struct axs_value
*value
,
1618 struct type
*type
, char *fieldname
)
1620 struct type
*t
= type
;
1623 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1624 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1625 internal_error (__FILE__
, __LINE__
,
1626 _("non-aggregate type to gen_struct_elt_for_reference"));
1628 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
1630 const char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
1632 if (t_field_name
&& strcmp (t_field_name
, fieldname
) == 0)
1634 if (field_is_static (&TYPE_FIELD (t
, i
)))
1636 gen_static_field (exp
->gdbarch
, ax
, value
, t
, i
);
1637 if (value
->optimized_out
)
1638 error (_("static field `%s' has been "
1639 "optimized out, cannot use"),
1643 if (TYPE_FIELD_PACKED (t
, i
))
1644 error (_("pointers to bitfield members not allowed"));
1646 /* FIXME we need a way to do "want_address" equivalent */
1648 error (_("Cannot reference non-static field \"%s\""), fieldname
);
1652 /* FIXME add other scoped-reference cases here */
1654 /* Do a last-ditch lookup. */
1655 return gen_maybe_namespace_elt (exp
, ax
, value
, type
, fieldname
);
1658 /* C++: Return the member NAME of the namespace given by the type
1662 gen_namespace_elt (struct expression
*exp
,
1663 struct agent_expr
*ax
, struct axs_value
*value
,
1664 const struct type
*curtype
, char *name
)
1666 int found
= gen_maybe_namespace_elt (exp
, ax
, value
, curtype
, name
);
1669 error (_("No symbol \"%s\" in namespace \"%s\"."),
1670 name
, TYPE_TAG_NAME (curtype
));
1675 /* A helper function used by value_namespace_elt and
1676 value_struct_elt_for_reference. It looks up NAME inside the
1677 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
1678 is a class and NAME refers to a type in CURTYPE itself (as opposed
1679 to, say, some base class of CURTYPE). */
1682 gen_maybe_namespace_elt (struct expression
*exp
,
1683 struct agent_expr
*ax
, struct axs_value
*value
,
1684 const struct type
*curtype
, char *name
)
1686 const char *namespace_name
= TYPE_TAG_NAME (curtype
);
1689 sym
= cp_lookup_symbol_namespace (namespace_name
, name
,
1690 block_for_pc (ax
->scope
),
1696 gen_var_ref (exp
->gdbarch
, ax
, value
, sym
);
1698 if (value
->optimized_out
)
1699 error (_("`%s' has been optimized out, cannot use"),
1700 SYMBOL_PRINT_NAME (sym
));
1707 gen_aggregate_elt_ref (struct expression
*exp
,
1708 struct agent_expr
*ax
, struct axs_value
*value
,
1709 struct type
*type
, char *field
,
1710 char *operator_name
, char *operand_name
)
1712 switch (TYPE_CODE (type
))
1714 case TYPE_CODE_STRUCT
:
1715 case TYPE_CODE_UNION
:
1716 return gen_struct_elt_for_reference (exp
, ax
, value
, type
, field
);
1718 case TYPE_CODE_NAMESPACE
:
1719 return gen_namespace_elt (exp
, ax
, value
, type
, field
);
1722 internal_error (__FILE__
, __LINE__
,
1723 _("non-aggregate type in gen_aggregate_elt_ref"));
1729 /* Generate code for GDB's magical `repeat' operator.
1730 LVALUE @ INT creates an array INT elements long, and whose elements
1731 have the same type as LVALUE, located in memory so that LVALUE is
1732 its first element. For example, argv[0]@argc gives you the array
1733 of command-line arguments.
1735 Unfortunately, because we have to know the types before we actually
1736 have a value for the expression, we can't implement this perfectly
1737 without changing the type system, having values that occupy two
1738 stack slots, doing weird things with sizeof, etc. So we require
1739 the right operand to be a constant expression. */
1741 gen_repeat (struct expression
*exp
, union exp_element
**pc
,
1742 struct agent_expr
*ax
, struct axs_value
*value
)
1744 struct axs_value value1
;
1746 /* We don't want to turn this into an rvalue, so no conversions
1748 gen_expr (exp
, pc
, ax
, &value1
);
1749 if (value1
.kind
!= axs_lvalue_memory
)
1750 error (_("Left operand of `@' must be an object in memory."));
1752 /* Evaluate the length; it had better be a constant. */
1754 struct value
*v
= const_expr (pc
);
1758 error (_("Right operand of `@' must be a "
1759 "constant, in agent expressions."));
1760 if (TYPE_CODE (value_type (v
)) != TYPE_CODE_INT
)
1761 error (_("Right operand of `@' must be an integer."));
1762 length
= value_as_long (v
);
1764 error (_("Right operand of `@' must be positive."));
1766 /* The top of the stack is already the address of the object, so
1767 all we need to do is frob the type of the lvalue. */
1769 /* FIXME-type-allocation: need a way to free this type when we are
1772 = lookup_array_range_type (value1
.type
, 0, length
- 1);
1774 value
->kind
= axs_lvalue_memory
;
1775 value
->type
= array
;
1781 /* Emit code for the `sizeof' operator.
1782 *PC should point at the start of the operand expression; we advance it
1783 to the first instruction after the operand. */
1785 gen_sizeof (struct expression
*exp
, union exp_element
**pc
,
1786 struct agent_expr
*ax
, struct axs_value
*value
,
1787 struct type
*size_type
)
1789 /* We don't care about the value of the operand expression; we only
1790 care about its type. However, in the current arrangement, the
1791 only way to find an expression's type is to generate code for it.
1792 So we generate code for the operand, and then throw it away,
1793 replacing it with code that simply pushes its size. */
1794 int start
= ax
->len
;
1796 gen_expr (exp
, pc
, ax
, value
);
1798 /* Throw away the code we just generated. */
1801 ax_const_l (ax
, TYPE_LENGTH (value
->type
));
1802 value
->kind
= axs_rvalue
;
1803 value
->type
= size_type
;
1807 /* Generating bytecode from GDB expressions: general recursive thingy */
1810 /* A gen_expr function written by a Gen-X'er guy.
1811 Append code for the subexpression of EXPR starting at *POS_P to AX. */
1813 gen_expr (struct expression
*exp
, union exp_element
**pc
,
1814 struct agent_expr
*ax
, struct axs_value
*value
)
1816 /* Used to hold the descriptions of operand expressions. */
1817 struct axs_value value1
, value2
, value3
;
1818 enum exp_opcode op
= (*pc
)[0].opcode
, op2
;
1819 int if1
, go1
, if2
, go2
, end
;
1820 struct type
*int_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
1822 /* If we're looking at a constant expression, just push its value. */
1824 struct value
*v
= maybe_const_expr (pc
);
1828 ax_const_l (ax
, value_as_long (v
));
1829 value
->kind
= axs_rvalue
;
1830 value
->type
= check_typedef (value_type (v
));
1835 /* Otherwise, go ahead and generate code for it. */
1838 /* Binary arithmetic operators. */
1846 case BINOP_SUBSCRIPT
:
1847 case BINOP_BITWISE_AND
:
1848 case BINOP_BITWISE_IOR
:
1849 case BINOP_BITWISE_XOR
:
1851 case BINOP_NOTEQUAL
:
1857 gen_expr (exp
, pc
, ax
, &value1
);
1858 gen_usual_unary (exp
, ax
, &value1
);
1859 gen_expr_binop_rest (exp
, op
, pc
, ax
, value
, &value1
, &value2
);
1862 case BINOP_LOGICAL_AND
:
1864 /* Generate the obvious sequence of tests and jumps. */
1865 gen_expr (exp
, pc
, ax
, &value1
);
1866 gen_usual_unary (exp
, ax
, &value1
);
1867 if1
= ax_goto (ax
, aop_if_goto
);
1868 go1
= ax_goto (ax
, aop_goto
);
1869 ax_label (ax
, if1
, ax
->len
);
1870 gen_expr (exp
, pc
, ax
, &value2
);
1871 gen_usual_unary (exp
, ax
, &value2
);
1872 if2
= ax_goto (ax
, aop_if_goto
);
1873 go2
= ax_goto (ax
, aop_goto
);
1874 ax_label (ax
, if2
, ax
->len
);
1876 end
= ax_goto (ax
, aop_goto
);
1877 ax_label (ax
, go1
, ax
->len
);
1878 ax_label (ax
, go2
, ax
->len
);
1880 ax_label (ax
, end
, ax
->len
);
1881 value
->kind
= axs_rvalue
;
1882 value
->type
= int_type
;
1885 case BINOP_LOGICAL_OR
:
1887 /* Generate the obvious sequence of tests and jumps. */
1888 gen_expr (exp
, pc
, ax
, &value1
);
1889 gen_usual_unary (exp
, ax
, &value1
);
1890 if1
= ax_goto (ax
, aop_if_goto
);
1891 gen_expr (exp
, pc
, ax
, &value2
);
1892 gen_usual_unary (exp
, ax
, &value2
);
1893 if2
= ax_goto (ax
, aop_if_goto
);
1895 end
= ax_goto (ax
, aop_goto
);
1896 ax_label (ax
, if1
, ax
->len
);
1897 ax_label (ax
, if2
, ax
->len
);
1899 ax_label (ax
, end
, ax
->len
);
1900 value
->kind
= axs_rvalue
;
1901 value
->type
= int_type
;
1906 gen_expr (exp
, pc
, ax
, &value1
);
1907 gen_usual_unary (exp
, ax
, &value1
);
1908 /* For (A ? B : C), it's easiest to generate subexpression
1909 bytecodes in order, but if_goto jumps on true, so we invert
1910 the sense of A. Then we can do B by dropping through, and
1912 gen_logical_not (ax
, &value1
, int_type
);
1913 if1
= ax_goto (ax
, aop_if_goto
);
1914 gen_expr (exp
, pc
, ax
, &value2
);
1915 gen_usual_unary (exp
, ax
, &value2
);
1916 end
= ax_goto (ax
, aop_goto
);
1917 ax_label (ax
, if1
, ax
->len
);
1918 gen_expr (exp
, pc
, ax
, &value3
);
1919 gen_usual_unary (exp
, ax
, &value3
);
1920 ax_label (ax
, end
, ax
->len
);
1921 /* This is arbitary - what if B and C are incompatible types? */
1922 value
->type
= value2
.type
;
1923 value
->kind
= value2
.kind
;
1928 if ((*pc
)[0].opcode
== OP_INTERNALVAR
)
1930 char *name
= internalvar_name ((*pc
)[1].internalvar
);
1931 struct trace_state_variable
*tsv
;
1934 gen_expr (exp
, pc
, ax
, value
);
1935 tsv
= find_trace_state_variable (name
);
1938 ax_tsv (ax
, aop_setv
, tsv
->number
);
1940 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1943 error (_("$%s is not a trace state variable, "
1944 "may not assign to it"), name
);
1947 error (_("May only assign to trace state variables"));
1950 case BINOP_ASSIGN_MODIFY
:
1952 op2
= (*pc
)[0].opcode
;
1955 if ((*pc
)[0].opcode
== OP_INTERNALVAR
)
1957 char *name
= internalvar_name ((*pc
)[1].internalvar
);
1958 struct trace_state_variable
*tsv
;
1961 tsv
= find_trace_state_variable (name
);
1964 /* The tsv will be the left half of the binary operation. */
1965 ax_tsv (ax
, aop_getv
, tsv
->number
);
1967 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1968 /* Trace state variables are always 64-bit integers. */
1969 value1
.kind
= axs_rvalue
;
1970 value1
.type
= builtin_type (exp
->gdbarch
)->builtin_long_long
;
1971 /* Now do right half of expression. */
1972 gen_expr_binop_rest (exp
, op2
, pc
, ax
, value
, &value1
, &value2
);
1973 /* We have a result of the binary op, set the tsv. */
1974 ax_tsv (ax
, aop_setv
, tsv
->number
);
1976 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1979 error (_("$%s is not a trace state variable, "
1980 "may not assign to it"), name
);
1983 error (_("May only assign to trace state variables"));
1986 /* Note that we need to be a little subtle about generating code
1987 for comma. In C, we can do some optimizations here because
1988 we know the left operand is only being evaluated for effect.
1989 However, if the tracing kludge is in effect, then we always
1990 need to evaluate the left hand side fully, so that all the
1991 variables it mentions get traced. */
1994 gen_expr (exp
, pc
, ax
, &value1
);
1995 /* Don't just dispose of the left operand. We might be tracing,
1996 in which case we want to emit code to trace it if it's an
1998 gen_traced_pop (exp
->gdbarch
, ax
, &value1
);
1999 gen_expr (exp
, pc
, ax
, value
);
2000 /* It's the consumer's responsibility to trace the right operand. */
2003 case OP_LONG
: /* some integer constant */
2005 struct type
*type
= (*pc
)[1].type
;
2006 LONGEST k
= (*pc
)[2].longconst
;
2009 gen_int_literal (ax
, value
, k
, type
);
2014 gen_var_ref (exp
->gdbarch
, ax
, value
, (*pc
)[2].symbol
);
2016 if (value
->optimized_out
)
2017 error (_("`%s' has been optimized out, cannot use"),
2018 SYMBOL_PRINT_NAME ((*pc
)[2].symbol
));
2025 const char *name
= &(*pc
)[2].string
;
2028 (*pc
) += 4 + BYTES_TO_EXP_ELEM ((*pc
)[1].longconst
+ 1);
2029 reg
= user_reg_map_name_to_regnum (exp
->gdbarch
, name
, strlen (name
));
2031 internal_error (__FILE__
, __LINE__
,
2032 _("Register $%s not available"), name
);
2033 /* No support for tracing user registers yet. */
2034 if (reg
>= gdbarch_num_regs (exp
->gdbarch
)
2035 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
2036 error (_("'%s' is a user-register; "
2037 "GDB cannot yet trace user-register contents."),
2039 value
->kind
= axs_lvalue_register
;
2041 value
->type
= register_type (exp
->gdbarch
, reg
);
2045 case OP_INTERNALVAR
:
2047 const char *name
= internalvar_name ((*pc
)[1].internalvar
);
2048 struct trace_state_variable
*tsv
;
2051 tsv
= find_trace_state_variable (name
);
2054 ax_tsv (ax
, aop_getv
, tsv
->number
);
2056 ax_tsv (ax
, aop_tracev
, tsv
->number
);
2057 /* Trace state variables are always 64-bit integers. */
2058 value
->kind
= axs_rvalue
;
2059 value
->type
= builtin_type (exp
->gdbarch
)->builtin_long_long
;
2062 error (_("$%s is not a trace state variable; GDB agent "
2063 "expressions cannot use convenience variables."), name
);
2067 /* Weirdo operator: see comments for gen_repeat for details. */
2069 /* Note that gen_repeat handles its own argument evaluation. */
2071 gen_repeat (exp
, pc
, ax
, value
);
2076 struct type
*type
= (*pc
)[1].type
;
2079 gen_expr (exp
, pc
, ax
, value
);
2080 gen_cast (ax
, value
, type
);
2086 struct type
*type
= check_typedef ((*pc
)[1].type
);
2089 gen_expr (exp
, pc
, ax
, value
);
2091 /* If we have an axs_rvalue or an axs_lvalue_memory, then we
2092 already have the right value on the stack. For
2093 axs_lvalue_register, we must convert. */
2094 if (value
->kind
== axs_lvalue_register
)
2095 require_rvalue (ax
, value
);
2098 value
->kind
= axs_lvalue_memory
;
2104 /* + FOO is equivalent to 0 + FOO, which can be optimized. */
2105 gen_expr (exp
, pc
, ax
, value
);
2106 gen_usual_unary (exp
, ax
, value
);
2111 /* -FOO is equivalent to 0 - FOO. */
2112 gen_int_literal (ax
, &value1
, 0,
2113 builtin_type (exp
->gdbarch
)->builtin_int
);
2114 gen_usual_unary (exp
, ax
, &value1
); /* shouldn't do much */
2115 gen_expr (exp
, pc
, ax
, &value2
);
2116 gen_usual_unary (exp
, ax
, &value2
);
2117 gen_usual_arithmetic (exp
, ax
, &value1
, &value2
);
2118 gen_binop (ax
, value
, &value1
, &value2
, aop_sub
, aop_sub
, 1, "negation");
2121 case UNOP_LOGICAL_NOT
:
2123 gen_expr (exp
, pc
, ax
, value
);
2124 gen_usual_unary (exp
, ax
, value
);
2125 gen_logical_not (ax
, value
, int_type
);
2128 case UNOP_COMPLEMENT
:
2130 gen_expr (exp
, pc
, ax
, value
);
2131 gen_usual_unary (exp
, ax
, value
);
2132 gen_integral_promotions (exp
, ax
, value
);
2133 gen_complement (ax
, value
);
2138 gen_expr (exp
, pc
, ax
, value
);
2139 gen_usual_unary (exp
, ax
, value
);
2140 if (!pointer_type (value
->type
))
2141 error (_("Argument of unary `*' is not a pointer."));
2142 gen_deref (ax
, value
);
2147 gen_expr (exp
, pc
, ax
, value
);
2148 gen_address_of (ax
, value
);
2153 /* Notice that gen_sizeof handles its own operand, unlike most
2154 of the other unary operator functions. This is because we
2155 have to throw away the code we generate. */
2156 gen_sizeof (exp
, pc
, ax
, value
,
2157 builtin_type (exp
->gdbarch
)->builtin_int
);
2160 case STRUCTOP_STRUCT
:
2163 int length
= (*pc
)[1].longconst
;
2164 char *name
= &(*pc
)[2].string
;
2166 (*pc
) += 4 + BYTES_TO_EXP_ELEM (length
+ 1);
2167 gen_expr (exp
, pc
, ax
, value
);
2168 if (op
== STRUCTOP_STRUCT
)
2169 gen_struct_ref (exp
, ax
, value
, name
, ".", "structure or union");
2170 else if (op
== STRUCTOP_PTR
)
2171 gen_struct_ref (exp
, ax
, value
, name
, "->",
2172 "pointer to a structure or union");
2174 /* If this `if' chain doesn't handle it, then the case list
2175 shouldn't mention it, and we shouldn't be here. */
2176 internal_error (__FILE__
, __LINE__
,
2177 _("gen_expr: unhandled struct case"));
2184 struct symbol
*sym
, *func
;
2186 const struct language_defn
*lang
;
2188 b
= block_for_pc (ax
->scope
);
2189 func
= block_linkage_function (b
);
2190 lang
= language_def (SYMBOL_LANGUAGE (func
));
2192 sym
= lookup_language_this (lang
, b
);
2194 error (_("no `%s' found"), lang
->la_name_of_this
);
2196 gen_var_ref (exp
->gdbarch
, ax
, value
, sym
);
2198 if (value
->optimized_out
)
2199 error (_("`%s' has been optimized out, cannot use"),
2200 SYMBOL_PRINT_NAME (sym
));
2208 struct type
*type
= (*pc
)[1].type
;
2209 int length
= longest_to_int ((*pc
)[2].longconst
);
2210 char *name
= &(*pc
)[3].string
;
2213 found
= gen_aggregate_elt_ref (exp
, ax
, value
, type
, name
,
2216 error (_("There is no field named %s"), name
);
2217 (*pc
) += 5 + BYTES_TO_EXP_ELEM (length
+ 1);
2222 error (_("Attempt to use a type name as an expression."));
2225 error (_("Unsupported operator %s (%d) in expression."),
2226 op_string (op
), op
);
2230 /* This handles the middle-to-right-side of code generation for binary
2231 expressions, which is shared between regular binary operations and
2232 assign-modify (+= and friends) expressions. */
2235 gen_expr_binop_rest (struct expression
*exp
,
2236 enum exp_opcode op
, union exp_element
**pc
,
2237 struct agent_expr
*ax
, struct axs_value
*value
,
2238 struct axs_value
*value1
, struct axs_value
*value2
)
2240 struct type
*int_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2242 gen_expr (exp
, pc
, ax
, value2
);
2243 gen_usual_unary (exp
, ax
, value2
);
2244 gen_usual_arithmetic (exp
, ax
, value1
, value2
);
2248 if (TYPE_CODE (value1
->type
) == TYPE_CODE_INT
2249 && pointer_type (value2
->type
))
2251 /* Swap the values and proceed normally. */
2252 ax_simple (ax
, aop_swap
);
2253 gen_ptradd (ax
, value
, value2
, value1
);
2255 else if (pointer_type (value1
->type
)
2256 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
2257 gen_ptradd (ax
, value
, value1
, value2
);
2259 gen_binop (ax
, value
, value1
, value2
,
2260 aop_add
, aop_add
, 1, "addition");
2263 if (pointer_type (value1
->type
)
2264 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
2265 gen_ptrsub (ax
,value
, value1
, value2
);
2266 else if (pointer_type (value1
->type
)
2267 && pointer_type (value2
->type
))
2268 /* FIXME --- result type should be ptrdiff_t */
2269 gen_ptrdiff (ax
, value
, value1
, value2
,
2270 builtin_type (exp
->gdbarch
)->builtin_long
);
2272 gen_binop (ax
, value
, value1
, value2
,
2273 aop_sub
, aop_sub
, 1, "subtraction");
2276 gen_binop (ax
, value
, value1
, value2
,
2277 aop_mul
, aop_mul
, 1, "multiplication");
2280 gen_binop (ax
, value
, value1
, value2
,
2281 aop_div_signed
, aop_div_unsigned
, 1, "division");
2284 gen_binop (ax
, value
, value1
, value2
,
2285 aop_rem_signed
, aop_rem_unsigned
, 1, "remainder");
2288 gen_binop (ax
, value
, value1
, value2
,
2289 aop_lsh
, aop_lsh
, 1, "left shift");
2292 gen_binop (ax
, value
, value1
, value2
,
2293 aop_rsh_signed
, aop_rsh_unsigned
, 1, "right shift");
2295 case BINOP_SUBSCRIPT
:
2299 if (binop_types_user_defined_p (op
, value1
->type
, value2
->type
))
2301 error (_("cannot subscript requested type: "
2302 "cannot call user defined functions"));
2306 /* If the user attempts to subscript something that is not
2307 an array or pointer type (like a plain int variable for
2308 example), then report this as an error. */
2309 type
= check_typedef (value1
->type
);
2310 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2311 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2313 if (TYPE_NAME (type
))
2314 error (_("cannot subscript something of type `%s'"),
2317 error (_("cannot subscript requested type"));
2321 if (!is_integral_type (value2
->type
))
2322 error (_("Argument to arithmetic operation "
2323 "not a number or boolean."));
2325 gen_ptradd (ax
, value
, value1
, value2
);
2326 gen_deref (ax
, value
);
2329 case BINOP_BITWISE_AND
:
2330 gen_binop (ax
, value
, value1
, value2
,
2331 aop_bit_and
, aop_bit_and
, 0, "bitwise and");
2334 case BINOP_BITWISE_IOR
:
2335 gen_binop (ax
, value
, value1
, value2
,
2336 aop_bit_or
, aop_bit_or
, 0, "bitwise or");
2339 case BINOP_BITWISE_XOR
:
2340 gen_binop (ax
, value
, value1
, value2
,
2341 aop_bit_xor
, aop_bit_xor
, 0, "bitwise exclusive-or");
2345 gen_equal (ax
, value
, value1
, value2
, int_type
);
2348 case BINOP_NOTEQUAL
:
2349 gen_equal (ax
, value
, value1
, value2
, int_type
);
2350 gen_logical_not (ax
, value
, int_type
);
2354 gen_less (ax
, value
, value1
, value2
, int_type
);
2358 ax_simple (ax
, aop_swap
);
2359 gen_less (ax
, value
, value1
, value2
, int_type
);
2363 ax_simple (ax
, aop_swap
);
2364 gen_less (ax
, value
, value1
, value2
, int_type
);
2365 gen_logical_not (ax
, value
, int_type
);
2369 gen_less (ax
, value
, value1
, value2
, int_type
);
2370 gen_logical_not (ax
, value
, int_type
);
2374 /* We should only list operators in the outer case statement
2375 that we actually handle in the inner case statement. */
2376 internal_error (__FILE__
, __LINE__
,
2377 _("gen_expr: op case sets don't match"));
2382 /* Given a single variable and a scope, generate bytecodes to trace
2383 its value. This is for use in situations where we have only a
2384 variable's name, and no parsed expression; for instance, when the
2385 name comes from a list of local variables of a function. */
2388 gen_trace_for_var (CORE_ADDR scope
, struct gdbarch
*gdbarch
,
2391 struct cleanup
*old_chain
= 0;
2392 struct agent_expr
*ax
= new_agent_expr (gdbarch
, scope
);
2393 struct axs_value value
;
2395 old_chain
= make_cleanup_free_agent_expr (ax
);
2398 gen_var_ref (gdbarch
, ax
, &value
, var
);
2400 /* If there is no actual variable to trace, flag it by returning
2401 an empty agent expression. */
2402 if (value
.optimized_out
)
2404 do_cleanups (old_chain
);
2408 /* Make sure we record the final object, and get rid of it. */
2409 gen_traced_pop (gdbarch
, ax
, &value
);
2411 /* Oh, and terminate. */
2412 ax_simple (ax
, aop_end
);
2414 /* We have successfully built the agent expr, so cancel the cleanup
2415 request. If we add more cleanups that we always want done, this
2416 will have to get more complicated. */
2417 discard_cleanups (old_chain
);
2421 /* Generating bytecode from GDB expressions: driver */
2423 /* Given a GDB expression EXPR, return bytecode to trace its value.
2424 The result will use the `trace' and `trace_quick' bytecodes to
2425 record the value of all memory touched by the expression. The
2426 caller can then use the ax_reqs function to discover which
2427 registers it relies upon. */
2429 gen_trace_for_expr (CORE_ADDR scope
, struct expression
*expr
)
2431 struct cleanup
*old_chain
= 0;
2432 struct agent_expr
*ax
= new_agent_expr (expr
->gdbarch
, scope
);
2433 union exp_element
*pc
;
2434 struct axs_value value
;
2436 old_chain
= make_cleanup_free_agent_expr (ax
);
2440 value
.optimized_out
= 0;
2441 gen_expr (expr
, &pc
, ax
, &value
);
2443 /* Make sure we record the final object, and get rid of it. */
2444 gen_traced_pop (expr
->gdbarch
, ax
, &value
);
2446 /* Oh, and terminate. */
2447 ax_simple (ax
, aop_end
);
2449 /* We have successfully built the agent expr, so cancel the cleanup
2450 request. If we add more cleanups that we always want done, this
2451 will have to get more complicated. */
2452 discard_cleanups (old_chain
);
2456 /* Given a GDB expression EXPR, return a bytecode sequence that will
2457 evaluate and return a result. The bytecodes will do a direct
2458 evaluation, using the current data on the target, rather than
2459 recording blocks of memory and registers for later use, as
2460 gen_trace_for_expr does. The generated bytecode sequence leaves
2461 the result of expression evaluation on the top of the stack. */
2464 gen_eval_for_expr (CORE_ADDR scope
, struct expression
*expr
)
2466 struct cleanup
*old_chain
= 0;
2467 struct agent_expr
*ax
= new_agent_expr (expr
->gdbarch
, scope
);
2468 union exp_element
*pc
;
2469 struct axs_value value
;
2471 old_chain
= make_cleanup_free_agent_expr (ax
);
2475 value
.optimized_out
= 0;
2476 gen_expr (expr
, &pc
, ax
, &value
);
2478 require_rvalue (ax
, &value
);
2480 /* Oh, and terminate. */
2481 ax_simple (ax
, aop_end
);
2483 /* We have successfully built the agent expr, so cancel the cleanup
2484 request. If we add more cleanups that we always want done, this
2485 will have to get more complicated. */
2486 discard_cleanups (old_chain
);
2491 gen_trace_for_return_address (CORE_ADDR scope
, struct gdbarch
*gdbarch
)
2493 struct cleanup
*old_chain
= 0;
2494 struct agent_expr
*ax
= new_agent_expr (gdbarch
, scope
);
2495 struct axs_value value
;
2497 old_chain
= make_cleanup_free_agent_expr (ax
);
2501 gdbarch_gen_return_address (gdbarch
, ax
, &value
, scope
);
2503 /* Make sure we record the final object, and get rid of it. */
2504 gen_traced_pop (gdbarch
, ax
, &value
);
2506 /* Oh, and terminate. */
2507 ax_simple (ax
, aop_end
);
2509 /* We have successfully built the agent expr, so cancel the cleanup
2510 request. If we add more cleanups that we always want done, this
2511 will have to get more complicated. */
2512 discard_cleanups (old_chain
);
2517 agent_command (char *exp
, int from_tty
)
2519 struct cleanup
*old_chain
= 0;
2520 struct expression
*expr
;
2521 struct agent_expr
*agent
;
2522 struct frame_info
*fi
= get_current_frame (); /* need current scope */
2524 /* We don't deal with overlay debugging at the moment. We need to
2525 think more carefully about this. If you copy this code into
2526 another command, change the error message; the user shouldn't
2527 have to know anything about agent expressions. */
2528 if (overlay_debugging
)
2529 error (_("GDB can't do agent expression translation with overlays."));
2532 error_no_arg (_("expression to translate"));
2534 trace_string_kludge
= 0;
2536 exp
= decode_agent_options (exp
);
2538 /* Recognize the return address collection directive specially. Note
2539 that it is not really an expression of any sort. */
2540 if (strcmp (exp
, "$_ret") == 0)
2542 agent
= gen_trace_for_return_address (get_frame_pc (fi
),
2543 get_current_arch ());
2544 old_chain
= make_cleanup_free_agent_expr (agent
);
2548 expr
= parse_expression (exp
);
2549 old_chain
= make_cleanup (free_current_contents
, &expr
);
2550 agent
= gen_trace_for_expr (get_frame_pc (fi
), expr
);
2551 make_cleanup_free_agent_expr (agent
);
2555 ax_print (gdb_stdout
, agent
);
2557 /* It would be nice to call ax_reqs here to gather some general info
2558 about the expression, and then print out the result. */
2560 do_cleanups (old_chain
);
2564 /* Parse the given expression, compile it into an agent expression
2565 that does direct evaluation, and display the resulting
2569 agent_eval_command (char *exp
, int from_tty
)
2571 struct cleanup
*old_chain
= 0;
2572 struct expression
*expr
;
2573 struct agent_expr
*agent
;
2574 struct frame_info
*fi
= get_current_frame (); /* need current scope */
2576 /* We don't deal with overlay debugging at the moment. We need to
2577 think more carefully about this. If you copy this code into
2578 another command, change the error message; the user shouldn't
2579 have to know anything about agent expressions. */
2580 if (overlay_debugging
)
2581 error (_("GDB can't do agent expression translation with overlays."));
2584 error_no_arg (_("expression to translate"));
2586 expr
= parse_expression (exp
);
2587 old_chain
= make_cleanup (free_current_contents
, &expr
);
2588 agent
= gen_eval_for_expr (get_frame_pc (fi
), expr
);
2589 make_cleanup_free_agent_expr (agent
);
2591 ax_print (gdb_stdout
, agent
);
2593 /* It would be nice to call ax_reqs here to gather some general info
2594 about the expression, and then print out the result. */
2596 do_cleanups (old_chain
);
2601 /* Initialization code. */
2603 void _initialize_ax_gdb (void);
2605 _initialize_ax_gdb (void)
2607 add_cmd ("agent", class_maintenance
, agent_command
,
2608 _("Translate an expression into "
2609 "remote agent bytecode for tracing."),
2612 add_cmd ("agent-eval", class_maintenance
, agent_eval_command
,
2613 _("Translate an expression into remote "
2614 "agent bytecode for evaluation."),
This page took 0.081604 seconds and 4 git commands to generate.