1 /* GDB-specific functions for operating on agent expressions.
3 Copyright (C) 1998, 1999, 2000, 2001, 2003, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
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"
44 /* To make sense of this file, you should read doc/agentexpr.texi.
45 Then look at the types and enums in ax-gdb.h. For the code itself,
46 look at gen_expr, towards the bottom; that's the main function that
47 looks at the GDB expressions and calls everything else to generate
50 I'm beginning to wonder whether it wouldn't be nicer to internally
51 generate trees, with types, and then spit out the bytecode in
52 linear form afterwards; we could generate fewer `swap', `ext', and
53 `zero_ext' bytecodes that way; it would make good constant folding
54 easier, too. But at the moment, I think we should be willing to
55 pay for the simplicity of this code with less-than-optimal bytecode
58 Remember, "GBD" stands for "Great Britain, Dammit!" So be careful. */
62 /* Prototypes for local functions. */
64 /* There's a standard order to the arguments of these functions:
65 union exp_element ** --- pointer into expression
66 struct agent_expr * --- agent expression buffer to generate code into
67 struct axs_value * --- describes value left on top of stack */
69 static struct value
*const_var_ref (struct symbol
*var
);
70 static struct value
*const_expr (union exp_element
**pc
);
71 static struct value
*maybe_const_expr (union exp_element
**pc
);
73 static void gen_traced_pop (struct gdbarch
*, struct agent_expr
*, struct axs_value
*);
75 static void gen_sign_extend (struct agent_expr
*, struct type
*);
76 static void gen_extend (struct agent_expr
*, struct type
*);
77 static void gen_fetch (struct agent_expr
*, struct type
*);
78 static void gen_left_shift (struct agent_expr
*, int);
81 static void gen_frame_args_address (struct gdbarch
*, struct agent_expr
*);
82 static void gen_frame_locals_address (struct gdbarch
*, struct agent_expr
*);
83 static void gen_offset (struct agent_expr
*ax
, int offset
);
84 static void gen_sym_offset (struct agent_expr
*, struct symbol
*);
85 static void gen_var_ref (struct gdbarch
*, struct agent_expr
*ax
,
86 struct axs_value
*value
, struct symbol
*var
);
89 static void gen_int_literal (struct agent_expr
*ax
,
90 struct axs_value
*value
,
91 LONGEST k
, struct type
*type
);
94 static void require_rvalue (struct agent_expr
*ax
, struct axs_value
*value
);
95 static void gen_usual_unary (struct expression
*exp
, struct agent_expr
*ax
,
96 struct axs_value
*value
);
97 static int type_wider_than (struct type
*type1
, struct type
*type2
);
98 static struct type
*max_type (struct type
*type1
, struct type
*type2
);
99 static void gen_conversion (struct agent_expr
*ax
,
100 struct type
*from
, struct type
*to
);
101 static int is_nontrivial_conversion (struct type
*from
, struct type
*to
);
102 static void gen_usual_arithmetic (struct expression
*exp
,
103 struct agent_expr
*ax
,
104 struct axs_value
*value1
,
105 struct axs_value
*value2
);
106 static void gen_integral_promotions (struct expression
*exp
,
107 struct agent_expr
*ax
,
108 struct axs_value
*value
);
109 static void gen_cast (struct agent_expr
*ax
,
110 struct axs_value
*value
, struct type
*type
);
111 static void gen_scale (struct agent_expr
*ax
,
112 enum agent_op op
, struct type
*type
);
113 static void gen_ptradd (struct agent_expr
*ax
, struct axs_value
*value
,
114 struct axs_value
*value1
, struct axs_value
*value2
);
115 static void gen_ptrsub (struct agent_expr
*ax
, struct axs_value
*value
,
116 struct axs_value
*value1
, struct axs_value
*value2
);
117 static void gen_ptrdiff (struct agent_expr
*ax
, struct axs_value
*value
,
118 struct axs_value
*value1
, struct axs_value
*value2
,
119 struct type
*result_type
);
120 static void gen_binop (struct agent_expr
*ax
,
121 struct axs_value
*value
,
122 struct axs_value
*value1
,
123 struct axs_value
*value2
,
125 enum agent_op op_unsigned
, int may_carry
, char *name
);
126 static void gen_logical_not (struct agent_expr
*ax
, struct axs_value
*value
,
127 struct type
*result_type
);
128 static void gen_complement (struct agent_expr
*ax
, struct axs_value
*value
);
129 static void gen_deref (struct agent_expr
*, struct axs_value
*);
130 static void gen_address_of (struct agent_expr
*, struct axs_value
*);
131 static void gen_bitfield_ref (struct expression
*exp
, struct agent_expr
*ax
,
132 struct axs_value
*value
,
133 struct type
*type
, int start
, int end
);
134 static void gen_primitive_field (struct expression
*exp
,
135 struct agent_expr
*ax
,
136 struct axs_value
*value
,
137 int offset
, int fieldno
, struct type
*type
);
138 static int gen_struct_ref_recursive (struct expression
*exp
,
139 struct agent_expr
*ax
,
140 struct axs_value
*value
,
141 char *field
, int offset
,
143 static void gen_struct_ref (struct expression
*exp
, struct agent_expr
*ax
,
144 struct axs_value
*value
,
146 char *operator_name
, char *operand_name
);
147 static void gen_static_field (struct gdbarch
*gdbarch
,
148 struct agent_expr
*ax
, struct axs_value
*value
,
149 struct type
*type
, int fieldno
);
150 static void gen_repeat (struct expression
*exp
, union exp_element
**pc
,
151 struct agent_expr
*ax
, struct axs_value
*value
);
152 static void gen_sizeof (struct expression
*exp
, union exp_element
**pc
,
153 struct agent_expr
*ax
, struct axs_value
*value
,
154 struct type
*size_type
);
155 static void gen_expr (struct expression
*exp
, union exp_element
**pc
,
156 struct agent_expr
*ax
, struct axs_value
*value
);
157 static void gen_expr_binop_rest (struct expression
*exp
,
158 enum exp_opcode op
, union exp_element
**pc
,
159 struct agent_expr
*ax
,
160 struct axs_value
*value
,
161 struct axs_value
*value1
,
162 struct axs_value
*value2
);
164 static void agent_command (char *exp
, int from_tty
);
167 /* Detecting constant expressions. */
169 /* If the variable reference at *PC is a constant, return its value.
170 Otherwise, return zero.
172 Hey, Wally! How can a variable reference be a constant?
174 Well, Beav, this function really handles the OP_VAR_VALUE operator,
175 not specifically variable references. GDB uses OP_VAR_VALUE to
176 refer to any kind of symbolic reference: function names, enum
177 elements, and goto labels are all handled through the OP_VAR_VALUE
178 operator, even though they're constants. It makes sense given the
181 Gee, Wally, don'cha wonder sometimes if data representations that
182 subvert commonly accepted definitions of terms in favor of heavily
183 context-specific interpretations are really just a tool of the
184 programming hegemony to preserve their power and exclude the
187 static struct value
*
188 const_var_ref (struct symbol
*var
)
190 struct type
*type
= SYMBOL_TYPE (var
);
192 switch (SYMBOL_CLASS (var
))
195 return value_from_longest (type
, (LONGEST
) SYMBOL_VALUE (var
));
198 return value_from_pointer (type
, (CORE_ADDR
) SYMBOL_VALUE_ADDRESS (var
));
206 /* If the expression starting at *PC has a constant value, return it.
207 Otherwise, return zero. If we return a value, then *PC will be
208 advanced to the end of it. If we return zero, *PC could be
210 static struct value
*
211 const_expr (union exp_element
**pc
)
213 enum exp_opcode op
= (*pc
)->opcode
;
220 struct type
*type
= (*pc
)[1].type
;
221 LONGEST k
= (*pc
)[2].longconst
;
223 return value_from_longest (type
, k
);
228 struct value
*v
= const_var_ref ((*pc
)[2].symbol
);
233 /* We could add more operators in here. */
237 v1
= const_expr (pc
);
239 return value_neg (v1
);
249 /* Like const_expr, but guarantee also that *PC is undisturbed if the
250 expression is not constant. */
251 static struct value
*
252 maybe_const_expr (union exp_element
**pc
)
254 union exp_element
*tentative_pc
= *pc
;
255 struct value
*v
= const_expr (&tentative_pc
);
257 /* If we got a value, then update the real PC. */
265 /* Generating bytecode from GDB expressions: general assumptions */
267 /* Here are a few general assumptions made throughout the code; if you
268 want to make a change that contradicts one of these, then you'd
269 better scan things pretty thoroughly.
271 - We assume that all values occupy one stack element. For example,
272 sometimes we'll swap to get at the left argument to a binary
273 operator. If we decide that void values should occupy no stack
274 elements, or that synthetic arrays (whose size is determined at
275 run time, created by the `@' operator) should occupy two stack
276 elements (address and length), then this will cause trouble.
278 - We assume the stack elements are infinitely wide, and that we
279 don't have to worry what happens if the user requests an
280 operation that is wider than the actual interpreter's stack.
281 That is, it's up to the interpreter to handle directly all the
282 integer widths the user has access to. (Woe betide the language
285 - We don't support side effects. Thus, we don't have to worry about
286 GCC's generalized lvalues, function calls, etc.
288 - We don't support floating point. Many places where we switch on
289 some type don't bother to include cases for floating point; there
290 may be even more subtle ways this assumption exists. For
291 example, the arguments to % must be integers.
293 - We assume all subexpressions have a static, unchanging type. If
294 we tried to support convenience variables, this would be a
297 - All values on the stack should always be fully zero- or
300 (I wasn't sure whether to choose this or its opposite --- that
301 only addresses are assumed extended --- but it turns out that
302 neither convention completely eliminates spurious extend
303 operations (if everything is always extended, then you have to
304 extend after add, because it could overflow; if nothing is
305 extended, then you end up producing extends whenever you change
306 sizes), and this is simpler.) */
309 /* Generating bytecode from GDB expressions: the `trace' kludge */
311 /* The compiler in this file is a general-purpose mechanism for
312 translating GDB expressions into bytecode. One ought to be able to
313 find a million and one uses for it.
315 However, at the moment it is HOPELESSLY BRAIN-DAMAGED for the sake
316 of expediency. Let he who is without sin cast the first stone.
318 For the data tracing facility, we need to insert `trace' bytecodes
319 before each data fetch; this records all the memory that the
320 expression touches in the course of evaluation, so that memory will
321 be available when the user later tries to evaluate the expression
324 This should be done (I think) in a post-processing pass, that walks
325 an arbitrary agent expression and inserts `trace' operations at the
326 appropriate points. But it's much faster to just hack them
327 directly into the code. And since we're in a crunch, that's what
330 Setting the flag trace_kludge to non-zero enables the code that
331 emits the trace bytecodes at the appropriate points. */
334 /* Scan for all static fields in the given class, including any base
335 classes, and generate tracing bytecodes for each. */
338 gen_trace_static_fields (struct gdbarch
*gdbarch
,
339 struct agent_expr
*ax
,
342 int i
, nbases
= TYPE_N_BASECLASSES (type
);
343 struct axs_value value
;
345 CHECK_TYPEDEF (type
);
347 for (i
= TYPE_NFIELDS (type
) - 1; i
>= nbases
; i
--)
349 if (field_is_static (&TYPE_FIELD (type
, i
)))
351 gen_static_field (gdbarch
, ax
, &value
, type
, i
);
352 if (value
.optimized_out
)
356 case axs_lvalue_memory
:
358 int length
= TYPE_LENGTH (check_typedef (value
.type
));
360 ax_const_l (ax
, length
);
361 ax_simple (ax
, aop_trace
);
365 case axs_lvalue_register
:
366 /* We don't actually need the register's value to be pushed,
367 just note that we need it to be collected. */
368 ax_reg_mask (ax
, value
.u
.reg
);
376 /* Now scan through base classes recursively. */
377 for (i
= 0; i
< nbases
; i
++)
379 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
381 gen_trace_static_fields (gdbarch
, ax
, basetype
);
385 /* Trace the lvalue on the stack, if it needs it. In either case, pop
386 the value. Useful on the left side of a comma, and at the end of
387 an expression being used for tracing. */
389 gen_traced_pop (struct gdbarch
*gdbarch
,
390 struct agent_expr
*ax
, struct axs_value
*value
)
396 /* We don't trace rvalues, just the lvalues necessary to
397 produce them. So just dispose of this value. */
398 ax_simple (ax
, aop_pop
);
401 case axs_lvalue_memory
:
403 int length
= TYPE_LENGTH (check_typedef (value
->type
));
405 /* There's no point in trying to use a trace_quick bytecode
406 here, since "trace_quick SIZE pop" is three bytes, whereas
407 "const8 SIZE trace" is also three bytes, does the same
408 thing, and the simplest code which generates that will also
409 work correctly for objects with large sizes. */
410 ax_const_l (ax
, length
);
411 ax_simple (ax
, aop_trace
);
415 case axs_lvalue_register
:
416 /* We don't actually need the register's value to be on the
417 stack, and the target will get heartburn if the register is
418 larger than will fit in a stack, so just mark it for
419 collection and be done with it. */
420 ax_reg_mask (ax
, value
->u
.reg
);
424 /* If we're not tracing, just pop the value. */
425 ax_simple (ax
, aop_pop
);
427 /* To trace C++ classes with static fields stored elsewhere. */
429 && (TYPE_CODE (value
->type
) == TYPE_CODE_STRUCT
430 || TYPE_CODE (value
->type
) == TYPE_CODE_UNION
))
431 gen_trace_static_fields (gdbarch
, ax
, value
->type
);
436 /* Generating bytecode from GDB expressions: helper functions */
438 /* Assume that the lower bits of the top of the stack is a value of
439 type TYPE, and the upper bits are zero. Sign-extend if necessary. */
441 gen_sign_extend (struct agent_expr
*ax
, struct type
*type
)
443 /* Do we need to sign-extend this? */
444 if (!TYPE_UNSIGNED (type
))
445 ax_ext (ax
, TYPE_LENGTH (type
) * TARGET_CHAR_BIT
);
449 /* Assume the lower bits of the top of the stack hold a value of type
450 TYPE, and the upper bits are garbage. Sign-extend or truncate as
453 gen_extend (struct agent_expr
*ax
, struct type
*type
)
455 int bits
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
457 ((TYPE_UNSIGNED (type
) ? ax_zero_ext
: ax_ext
) (ax
, bits
));
461 /* Assume that the top of the stack contains a value of type "pointer
462 to TYPE"; generate code to fetch its value. Note that TYPE is the
463 target type, not the pointer type. */
465 gen_fetch (struct agent_expr
*ax
, struct type
*type
)
469 /* Record the area of memory we're about to fetch. */
470 ax_trace_quick (ax
, TYPE_LENGTH (type
));
473 switch (TYPE_CODE (type
))
481 /* It's a scalar value, so we know how to dereference it. How
482 many bytes long is it? */
483 switch (TYPE_LENGTH (type
))
485 case 8 / TARGET_CHAR_BIT
:
486 ax_simple (ax
, aop_ref8
);
488 case 16 / TARGET_CHAR_BIT
:
489 ax_simple (ax
, aop_ref16
);
491 case 32 / TARGET_CHAR_BIT
:
492 ax_simple (ax
, aop_ref32
);
494 case 64 / TARGET_CHAR_BIT
:
495 ax_simple (ax
, aop_ref64
);
498 /* Either our caller shouldn't have asked us to dereference
499 that pointer (other code's fault), or we're not
500 implementing something we should be (this code's fault).
501 In any case, it's a bug the user shouldn't see. */
503 internal_error (__FILE__
, __LINE__
,
504 _("gen_fetch: strange size"));
507 gen_sign_extend (ax
, type
);
511 /* Either our caller shouldn't have asked us to dereference that
512 pointer (other code's fault), or we're not implementing
513 something we should be (this code's fault). In any case,
514 it's a bug the user shouldn't see. */
515 internal_error (__FILE__
, __LINE__
,
516 _("gen_fetch: bad type code"));
521 /* Generate code to left shift the top of the stack by DISTANCE bits, or
522 right shift it by -DISTANCE bits if DISTANCE < 0. This generates
523 unsigned (logical) right shifts. */
525 gen_left_shift (struct agent_expr
*ax
, int distance
)
529 ax_const_l (ax
, distance
);
530 ax_simple (ax
, aop_lsh
);
532 else if (distance
< 0)
534 ax_const_l (ax
, -distance
);
535 ax_simple (ax
, aop_rsh_unsigned
);
541 /* Generating bytecode from GDB expressions: symbol references */
543 /* Generate code to push the base address of the argument portion of
544 the top stack frame. */
546 gen_frame_args_address (struct gdbarch
*gdbarch
, struct agent_expr
*ax
)
549 LONGEST frame_offset
;
551 gdbarch_virtual_frame_pointer (gdbarch
,
552 ax
->scope
, &frame_reg
, &frame_offset
);
553 ax_reg (ax
, frame_reg
);
554 gen_offset (ax
, frame_offset
);
558 /* Generate code to push the base address of the locals portion of the
561 gen_frame_locals_address (struct gdbarch
*gdbarch
, struct agent_expr
*ax
)
564 LONGEST frame_offset
;
566 gdbarch_virtual_frame_pointer (gdbarch
,
567 ax
->scope
, &frame_reg
, &frame_offset
);
568 ax_reg (ax
, frame_reg
);
569 gen_offset (ax
, frame_offset
);
573 /* Generate code to add OFFSET to the top of the stack. Try to
574 generate short and readable code. We use this for getting to
575 variables on the stack, and structure members. If we were
576 programming in ML, it would be clearer why these are the same
579 gen_offset (struct agent_expr
*ax
, int offset
)
581 /* It would suffice to simply push the offset and add it, but this
582 makes it easier to read positive and negative offsets in the
586 ax_const_l (ax
, offset
);
587 ax_simple (ax
, aop_add
);
591 ax_const_l (ax
, -offset
);
592 ax_simple (ax
, aop_sub
);
597 /* In many cases, a symbol's value is the offset from some other
598 address (stack frame, base register, etc.) Generate code to add
599 VAR's value to the top of the stack. */
601 gen_sym_offset (struct agent_expr
*ax
, struct symbol
*var
)
603 gen_offset (ax
, SYMBOL_VALUE (var
));
607 /* Generate code for a variable reference to AX. The variable is the
608 symbol VAR. Set VALUE to describe the result. */
611 gen_var_ref (struct gdbarch
*gdbarch
, struct agent_expr
*ax
,
612 struct axs_value
*value
, struct symbol
*var
)
614 /* Dereference any typedefs. */
615 value
->type
= check_typedef (SYMBOL_TYPE (var
));
616 value
->optimized_out
= 0;
618 /* I'm imitating the code in read_var_value. */
619 switch (SYMBOL_CLASS (var
))
621 case LOC_CONST
: /* A constant, like an enum value. */
622 ax_const_l (ax
, (LONGEST
) SYMBOL_VALUE (var
));
623 value
->kind
= axs_rvalue
;
626 case LOC_LABEL
: /* A goto label, being used as a value. */
627 ax_const_l (ax
, (LONGEST
) SYMBOL_VALUE_ADDRESS (var
));
628 value
->kind
= axs_rvalue
;
631 case LOC_CONST_BYTES
:
632 internal_error (__FILE__
, __LINE__
,
633 _("gen_var_ref: LOC_CONST_BYTES symbols are not supported"));
635 /* Variable at a fixed location in memory. Easy. */
637 /* Push the address of the variable. */
638 ax_const_l (ax
, SYMBOL_VALUE_ADDRESS (var
));
639 value
->kind
= axs_lvalue_memory
;
642 case LOC_ARG
: /* var lives in argument area of frame */
643 gen_frame_args_address (gdbarch
, ax
);
644 gen_sym_offset (ax
, var
);
645 value
->kind
= axs_lvalue_memory
;
648 case LOC_REF_ARG
: /* As above, but the frame slot really
649 holds the address of the variable. */
650 gen_frame_args_address (gdbarch
, ax
);
651 gen_sym_offset (ax
, var
);
652 /* Don't assume any particular pointer size. */
653 gen_fetch (ax
, builtin_type (gdbarch
)->builtin_data_ptr
);
654 value
->kind
= axs_lvalue_memory
;
657 case LOC_LOCAL
: /* var lives in locals area of frame */
658 gen_frame_locals_address (gdbarch
, ax
);
659 gen_sym_offset (ax
, var
);
660 value
->kind
= axs_lvalue_memory
;
664 error (_("Cannot compute value of typedef `%s'."),
665 SYMBOL_PRINT_NAME (var
));
669 ax_const_l (ax
, BLOCK_START (SYMBOL_BLOCK_VALUE (var
)));
670 value
->kind
= axs_rvalue
;
674 /* Don't generate any code at all; in the process of treating
675 this as an lvalue or rvalue, the caller will generate the
677 value
->kind
= axs_lvalue_register
;
678 value
->u
.reg
= SYMBOL_REGISTER_OPS (var
)->register_number (var
, gdbarch
);
681 /* A lot like LOC_REF_ARG, but the pointer lives directly in a
682 register, not on the stack. Simpler than LOC_REGISTER
683 because it's just like any other case where the thing
684 has a real address. */
685 case LOC_REGPARM_ADDR
:
686 ax_reg (ax
, SYMBOL_REGISTER_OPS (var
)->register_number (var
, gdbarch
));
687 value
->kind
= axs_lvalue_memory
;
692 struct minimal_symbol
*msym
693 = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var
), NULL
, NULL
);
695 error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var
));
697 /* Push the address of the variable. */
698 ax_const_l (ax
, SYMBOL_VALUE_ADDRESS (msym
));
699 value
->kind
= axs_lvalue_memory
;
704 /* FIXME: cagney/2004-01-26: It should be possible to
705 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
706 Unfortunately DWARF 2 stores the frame-base (instead of the
707 function) location in a function's symbol. Oops! For the
708 moment enable this when/where applicable. */
709 SYMBOL_COMPUTED_OPS (var
)->tracepoint_var_ref (var
, gdbarch
, ax
, value
);
712 case LOC_OPTIMIZED_OUT
:
713 /* Flag this, but don't say anything; leave it up to callers to
715 value
->optimized_out
= 1;
719 error (_("Cannot find value of botched symbol `%s'."),
720 SYMBOL_PRINT_NAME (var
));
727 /* Generating bytecode from GDB expressions: literals */
730 gen_int_literal (struct agent_expr
*ax
, struct axs_value
*value
, LONGEST k
,
734 value
->kind
= axs_rvalue
;
735 value
->type
= check_typedef (type
);
740 /* Generating bytecode from GDB expressions: unary conversions, casts */
742 /* Take what's on the top of the stack (as described by VALUE), and
743 try to make an rvalue out of it. Signal an error if we can't do
746 require_rvalue (struct agent_expr
*ax
, struct axs_value
*value
)
748 /* Only deal with scalars, structs and such may be too large
749 to fit in a stack entry. */
750 value
->type
= check_typedef (value
->type
);
751 if (TYPE_CODE (value
->type
) == TYPE_CODE_ARRAY
752 || TYPE_CODE (value
->type
) == TYPE_CODE_STRUCT
753 || TYPE_CODE (value
->type
) == TYPE_CODE_UNION
754 || TYPE_CODE (value
->type
) == TYPE_CODE_FUNC
)
755 error (_("Value not scalar: cannot be an rvalue."));
760 /* It's already an rvalue. */
763 case axs_lvalue_memory
:
764 /* The top of stack is the address of the object. Dereference. */
765 gen_fetch (ax
, value
->type
);
768 case axs_lvalue_register
:
769 /* There's nothing on the stack, but value->u.reg is the
770 register number containing the value.
772 When we add floating-point support, this is going to have to
773 change. What about SPARC register pairs, for example? */
774 ax_reg (ax
, value
->u
.reg
);
775 gen_extend (ax
, value
->type
);
779 value
->kind
= axs_rvalue
;
783 /* Assume the top of the stack is described by VALUE, and perform the
784 usual unary conversions. This is motivated by ANSI 6.2.2, but of
785 course GDB expressions are not ANSI; they're the mishmash union of
786 a bunch of languages. Rah.
788 NOTE! This function promises to produce an rvalue only when the
789 incoming value is of an appropriate type. In other words, the
790 consumer of the value this function produces may assume the value
791 is an rvalue only after checking its type.
793 The immediate issue is that if the user tries to use a structure or
794 union as an operand of, say, the `+' operator, we don't want to try
795 to convert that structure to an rvalue; require_rvalue will bomb on
796 structs and unions. Rather, we want to simply pass the struct
797 lvalue through unchanged, and let `+' raise an error. */
800 gen_usual_unary (struct expression
*exp
, struct agent_expr
*ax
,
801 struct axs_value
*value
)
803 /* We don't have to generate any code for the usual integral
804 conversions, since values are always represented as full-width on
805 the stack. Should we tweak the type? */
807 /* Some types require special handling. */
808 switch (TYPE_CODE (value
->type
))
810 /* Functions get converted to a pointer to the function. */
812 value
->type
= lookup_pointer_type (value
->type
);
813 value
->kind
= axs_rvalue
; /* Should always be true, but just in case. */
816 /* Arrays get converted to a pointer to their first element, and
817 are no longer an lvalue. */
818 case TYPE_CODE_ARRAY
:
820 struct type
*elements
= TYPE_TARGET_TYPE (value
->type
);
821 value
->type
= lookup_pointer_type (elements
);
822 value
->kind
= axs_rvalue
;
823 /* We don't need to generate any code; the address of the array
824 is also the address of its first element. */
828 /* Don't try to convert structures and unions to rvalues. Let the
829 consumer signal an error. */
830 case TYPE_CODE_STRUCT
:
831 case TYPE_CODE_UNION
:
834 /* If the value is an enum or a bool, call it an integer. */
837 value
->type
= builtin_type (exp
->gdbarch
)->builtin_int
;
841 /* If the value is an lvalue, dereference it. */
842 require_rvalue (ax
, value
);
846 /* Return non-zero iff the type TYPE1 is considered "wider" than the
847 type TYPE2, according to the rules described in gen_usual_arithmetic. */
849 type_wider_than (struct type
*type1
, struct type
*type2
)
851 return (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
)
852 || (TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
853 && TYPE_UNSIGNED (type1
)
854 && !TYPE_UNSIGNED (type2
)));
858 /* Return the "wider" of the two types TYPE1 and TYPE2. */
860 max_type (struct type
*type1
, struct type
*type2
)
862 return type_wider_than (type1
, type2
) ? type1
: type2
;
866 /* Generate code to convert a scalar value of type FROM to type TO. */
868 gen_conversion (struct agent_expr
*ax
, struct type
*from
, struct type
*to
)
870 /* Perhaps there is a more graceful way to state these rules. */
872 /* If we're converting to a narrower type, then we need to clear out
874 if (TYPE_LENGTH (to
) < TYPE_LENGTH (from
))
875 gen_extend (ax
, from
);
877 /* If the two values have equal width, but different signednesses,
878 then we need to extend. */
879 else if (TYPE_LENGTH (to
) == TYPE_LENGTH (from
))
881 if (TYPE_UNSIGNED (from
) != TYPE_UNSIGNED (to
))
885 /* If we're converting to a wider type, and becoming unsigned, then
886 we need to zero out any possible sign bits. */
887 else if (TYPE_LENGTH (to
) > TYPE_LENGTH (from
))
889 if (TYPE_UNSIGNED (to
))
895 /* Return non-zero iff the type FROM will require any bytecodes to be
896 emitted to be converted to the type TO. */
898 is_nontrivial_conversion (struct type
*from
, struct type
*to
)
900 struct agent_expr
*ax
= new_agent_expr (NULL
, 0);
903 /* Actually generate the code, and see if anything came out. At the
904 moment, it would be trivial to replicate the code in
905 gen_conversion here, but in the future, when we're supporting
906 floating point and the like, it may not be. Doing things this
907 way allows this function to be independent of the logic in
909 gen_conversion (ax
, from
, to
);
910 nontrivial
= ax
->len
> 0;
911 free_agent_expr (ax
);
916 /* Generate code to perform the "usual arithmetic conversions" (ANSI C
917 6.2.1.5) for the two operands of an arithmetic operator. This
918 effectively finds a "least upper bound" type for the two arguments,
919 and promotes each argument to that type. *VALUE1 and *VALUE2
920 describe the values as they are passed in, and as they are left. */
922 gen_usual_arithmetic (struct expression
*exp
, struct agent_expr
*ax
,
923 struct axs_value
*value1
, struct axs_value
*value2
)
925 /* Do the usual binary conversions. */
926 if (TYPE_CODE (value1
->type
) == TYPE_CODE_INT
927 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
929 /* The ANSI integral promotions seem to work this way: Order the
930 integer types by size, and then by signedness: an n-bit
931 unsigned type is considered "wider" than an n-bit signed
932 type. Promote to the "wider" of the two types, and always
933 promote at least to int. */
934 struct type
*target
= max_type (builtin_type (exp
->gdbarch
)->builtin_int
,
935 max_type (value1
->type
, value2
->type
));
937 /* Deal with value2, on the top of the stack. */
938 gen_conversion (ax
, value2
->type
, target
);
940 /* Deal with value1, not on the top of the stack. Don't
941 generate the `swap' instructions if we're not actually going
943 if (is_nontrivial_conversion (value1
->type
, target
))
945 ax_simple (ax
, aop_swap
);
946 gen_conversion (ax
, value1
->type
, target
);
947 ax_simple (ax
, aop_swap
);
950 value1
->type
= value2
->type
= check_typedef (target
);
955 /* Generate code to perform the integral promotions (ANSI 6.2.1.1) on
956 the value on the top of the stack, as described by VALUE. Assume
957 the value has integral type. */
959 gen_integral_promotions (struct expression
*exp
, struct agent_expr
*ax
,
960 struct axs_value
*value
)
962 const struct builtin_type
*builtin
= builtin_type (exp
->gdbarch
);
964 if (!type_wider_than (value
->type
, builtin
->builtin_int
))
966 gen_conversion (ax
, value
->type
, builtin
->builtin_int
);
967 value
->type
= builtin
->builtin_int
;
969 else if (!type_wider_than (value
->type
, builtin
->builtin_unsigned_int
))
971 gen_conversion (ax
, value
->type
, builtin
->builtin_unsigned_int
);
972 value
->type
= builtin
->builtin_unsigned_int
;
977 /* Generate code for a cast to TYPE. */
979 gen_cast (struct agent_expr
*ax
, struct axs_value
*value
, struct type
*type
)
981 /* GCC does allow casts to yield lvalues, so this should be fixed
982 before merging these changes into the trunk. */
983 require_rvalue (ax
, value
);
984 /* Dereference typedefs. */
985 type
= check_typedef (type
);
987 switch (TYPE_CODE (type
))
991 /* It's implementation-defined, and I'll bet this is what GCC
995 case TYPE_CODE_ARRAY
:
996 case TYPE_CODE_STRUCT
:
997 case TYPE_CODE_UNION
:
999 error (_("Invalid type cast: intended type must be scalar."));
1001 case TYPE_CODE_ENUM
:
1002 case TYPE_CODE_BOOL
:
1003 /* We don't have to worry about the size of the value, because
1004 all our integral values are fully sign-extended, and when
1005 casting pointers we can do anything we like. Is there any
1006 way for us to know what GCC actually does with a cast like
1011 gen_conversion (ax
, value
->type
, type
);
1014 case TYPE_CODE_VOID
:
1015 /* We could pop the value, and rely on everyone else to check
1016 the type and notice that this value doesn't occupy a stack
1017 slot. But for now, leave the value on the stack, and
1018 preserve the "value == stack element" assumption. */
1022 error (_("Casts to requested type are not yet implemented."));
1030 /* Generating bytecode from GDB expressions: arithmetic */
1032 /* Scale the integer on the top of the stack by the size of the target
1033 of the pointer type TYPE. */
1035 gen_scale (struct agent_expr
*ax
, enum agent_op op
, struct type
*type
)
1037 struct type
*element
= TYPE_TARGET_TYPE (type
);
1039 if (TYPE_LENGTH (element
) != 1)
1041 ax_const_l (ax
, TYPE_LENGTH (element
));
1047 /* Generate code for pointer arithmetic PTR + INT. */
1049 gen_ptradd (struct agent_expr
*ax
, struct axs_value
*value
,
1050 struct axs_value
*value1
, struct axs_value
*value2
)
1052 gdb_assert (pointer_type (value1
->type
));
1053 gdb_assert (TYPE_CODE (value2
->type
) == TYPE_CODE_INT
);
1055 gen_scale (ax
, aop_mul
, value1
->type
);
1056 ax_simple (ax
, aop_add
);
1057 gen_extend (ax
, value1
->type
); /* Catch overflow. */
1058 value
->type
= value1
->type
;
1059 value
->kind
= axs_rvalue
;
1063 /* Generate code for pointer arithmetic PTR - INT. */
1065 gen_ptrsub (struct agent_expr
*ax
, struct axs_value
*value
,
1066 struct axs_value
*value1
, struct axs_value
*value2
)
1068 gdb_assert (pointer_type (value1
->type
));
1069 gdb_assert (TYPE_CODE (value2
->type
) == TYPE_CODE_INT
);
1071 gen_scale (ax
, aop_mul
, value1
->type
);
1072 ax_simple (ax
, aop_sub
);
1073 gen_extend (ax
, value1
->type
); /* Catch overflow. */
1074 value
->type
= value1
->type
;
1075 value
->kind
= axs_rvalue
;
1079 /* Generate code for pointer arithmetic PTR - PTR. */
1081 gen_ptrdiff (struct agent_expr
*ax
, struct axs_value
*value
,
1082 struct axs_value
*value1
, struct axs_value
*value2
,
1083 struct type
*result_type
)
1085 gdb_assert (pointer_type (value1
->type
));
1086 gdb_assert (pointer_type (value2
->type
));
1088 if (TYPE_LENGTH (TYPE_TARGET_TYPE (value1
->type
))
1089 != TYPE_LENGTH (TYPE_TARGET_TYPE (value2
->type
)))
1091 First argument of `-' is a pointer, but second argument is neither\n\
1092 an integer nor a pointer of the same type."));
1094 ax_simple (ax
, aop_sub
);
1095 gen_scale (ax
, aop_div_unsigned
, value1
->type
);
1096 value
->type
= result_type
;
1097 value
->kind
= axs_rvalue
;
1101 gen_equal (struct agent_expr
*ax
, struct axs_value
*value
,
1102 struct axs_value
*value1
, struct axs_value
*value2
,
1103 struct type
*result_type
)
1105 if (pointer_type (value1
->type
) || pointer_type (value2
->type
))
1106 ax_simple (ax
, aop_equal
);
1108 gen_binop (ax
, value
, value1
, value2
,
1109 aop_equal
, aop_equal
, 0, "equal");
1110 value
->type
= result_type
;
1111 value
->kind
= axs_rvalue
;
1115 gen_less (struct agent_expr
*ax
, struct axs_value
*value
,
1116 struct axs_value
*value1
, struct axs_value
*value2
,
1117 struct type
*result_type
)
1119 if (pointer_type (value1
->type
) || pointer_type (value2
->type
))
1120 ax_simple (ax
, aop_less_unsigned
);
1122 gen_binop (ax
, value
, value1
, value2
,
1123 aop_less_signed
, aop_less_unsigned
, 0, "less than");
1124 value
->type
= result_type
;
1125 value
->kind
= axs_rvalue
;
1128 /* Generate code for a binary operator that doesn't do pointer magic.
1129 We set VALUE to describe the result value; we assume VALUE1 and
1130 VALUE2 describe the two operands, and that they've undergone the
1131 usual binary conversions. MAY_CARRY should be non-zero iff the
1132 result needs to be extended. NAME is the English name of the
1133 operator, used in error messages */
1135 gen_binop (struct agent_expr
*ax
, struct axs_value
*value
,
1136 struct axs_value
*value1
, struct axs_value
*value2
, enum agent_op op
,
1137 enum agent_op op_unsigned
, int may_carry
, char *name
)
1139 /* We only handle INT op INT. */
1140 if ((TYPE_CODE (value1
->type
) != TYPE_CODE_INT
)
1141 || (TYPE_CODE (value2
->type
) != TYPE_CODE_INT
))
1142 error (_("Invalid combination of types in %s."), name
);
1145 TYPE_UNSIGNED (value1
->type
) ? op_unsigned
: op
);
1147 gen_extend (ax
, value1
->type
); /* catch overflow */
1148 value
->type
= value1
->type
;
1149 value
->kind
= axs_rvalue
;
1154 gen_logical_not (struct agent_expr
*ax
, struct axs_value
*value
,
1155 struct type
*result_type
)
1157 if (TYPE_CODE (value
->type
) != TYPE_CODE_INT
1158 && TYPE_CODE (value
->type
) != TYPE_CODE_PTR
)
1159 error (_("Invalid type of operand to `!'."));
1161 ax_simple (ax
, aop_log_not
);
1162 value
->type
= result_type
;
1167 gen_complement (struct agent_expr
*ax
, struct axs_value
*value
)
1169 if (TYPE_CODE (value
->type
) != TYPE_CODE_INT
)
1170 error (_("Invalid type of operand to `~'."));
1172 ax_simple (ax
, aop_bit_not
);
1173 gen_extend (ax
, value
->type
);
1178 /* Generating bytecode from GDB expressions: * & . -> @ sizeof */
1180 /* Dereference the value on the top of the stack. */
1182 gen_deref (struct agent_expr
*ax
, struct axs_value
*value
)
1184 /* The caller should check the type, because several operators use
1185 this, and we don't know what error message to generate. */
1186 if (!pointer_type (value
->type
))
1187 internal_error (__FILE__
, __LINE__
,
1188 _("gen_deref: expected a pointer"));
1190 /* We've got an rvalue now, which is a pointer. We want to yield an
1191 lvalue, whose address is exactly that pointer. So we don't
1192 actually emit any code; we just change the type from "Pointer to
1193 T" to "T", and mark the value as an lvalue in memory. Leave it
1194 to the consumer to actually dereference it. */
1195 value
->type
= check_typedef (TYPE_TARGET_TYPE (value
->type
));
1196 if (TYPE_CODE (value
->type
) == TYPE_CODE_VOID
)
1197 error (_("Attempt to dereference a generic pointer."));
1198 value
->kind
= ((TYPE_CODE (value
->type
) == TYPE_CODE_FUNC
)
1199 ? axs_rvalue
: axs_lvalue_memory
);
1203 /* Produce the address of the lvalue on the top of the stack. */
1205 gen_address_of (struct agent_expr
*ax
, struct axs_value
*value
)
1207 /* Special case for taking the address of a function. The ANSI
1208 standard describes this as a special case, too, so this
1209 arrangement is not without motivation. */
1210 if (TYPE_CODE (value
->type
) == TYPE_CODE_FUNC
)
1211 /* The value's already an rvalue on the stack, so we just need to
1213 value
->type
= lookup_pointer_type (value
->type
);
1215 switch (value
->kind
)
1218 error (_("Operand of `&' is an rvalue, which has no address."));
1220 case axs_lvalue_register
:
1221 error (_("Operand of `&' is in a register, and has no address."));
1223 case axs_lvalue_memory
:
1224 value
->kind
= axs_rvalue
;
1225 value
->type
= lookup_pointer_type (value
->type
);
1230 /* Generate code to push the value of a bitfield of a structure whose
1231 address is on the top of the stack. START and END give the
1232 starting and one-past-ending *bit* numbers of the field within the
1235 gen_bitfield_ref (struct expression
*exp
, struct agent_expr
*ax
,
1236 struct axs_value
*value
, struct type
*type
,
1239 /* Note that ops[i] fetches 8 << i bits. */
1240 static enum agent_op ops
[]
1242 {aop_ref8
, aop_ref16
, aop_ref32
, aop_ref64
};
1243 static int num_ops
= (sizeof (ops
) / sizeof (ops
[0]));
1245 /* We don't want to touch any byte that the bitfield doesn't
1246 actually occupy; we shouldn't make any accesses we're not
1247 explicitly permitted to. We rely here on the fact that the
1248 bytecode `ref' operators work on unaligned addresses.
1250 It takes some fancy footwork to get the stack to work the way
1251 we'd like. Say we're retrieving a bitfield that requires three
1252 fetches. Initially, the stack just contains the address:
1254 For the first fetch, we duplicate the address
1256 then add the byte offset, do the fetch, and shift and mask as
1257 needed, yielding a fragment of the value, properly aligned for
1258 the final bitwise or:
1260 then we swap, and repeat the process:
1261 frag1 addr --- address on top
1262 frag1 addr addr --- duplicate it
1263 frag1 addr frag2 --- get second fragment
1264 frag1 frag2 addr --- swap again
1265 frag1 frag2 frag3 --- get third fragment
1266 Notice that, since the third fragment is the last one, we don't
1267 bother duplicating the address this time. Now we have all the
1268 fragments on the stack, and we can simply `or' them together,
1269 yielding the final value of the bitfield. */
1271 /* The first and one-after-last bits in the field, but rounded down
1272 and up to byte boundaries. */
1273 int bound_start
= (start
/ TARGET_CHAR_BIT
) * TARGET_CHAR_BIT
;
1274 int bound_end
= (((end
+ TARGET_CHAR_BIT
- 1)
1278 /* current bit offset within the structure */
1281 /* The index in ops of the opcode we're considering. */
1284 /* The number of fragments we generated in the process. Probably
1285 equal to the number of `one' bits in bytesize, but who cares? */
1288 /* Dereference any typedefs. */
1289 type
= check_typedef (type
);
1291 /* Can we fetch the number of bits requested at all? */
1292 if ((end
- start
) > ((1 << num_ops
) * 8))
1293 internal_error (__FILE__
, __LINE__
,
1294 _("gen_bitfield_ref: bitfield too wide"));
1296 /* Note that we know here that we only need to try each opcode once.
1297 That may not be true on machines with weird byte sizes. */
1298 offset
= bound_start
;
1300 for (op
= num_ops
- 1; op
>= 0; op
--)
1302 /* number of bits that ops[op] would fetch */
1303 int op_size
= 8 << op
;
1305 /* The stack at this point, from bottom to top, contains zero or
1306 more fragments, then the address. */
1308 /* Does this fetch fit within the bitfield? */
1309 if (offset
+ op_size
<= bound_end
)
1311 /* Is this the last fragment? */
1312 int last_frag
= (offset
+ op_size
== bound_end
);
1315 ax_simple (ax
, aop_dup
); /* keep a copy of the address */
1317 /* Add the offset. */
1318 gen_offset (ax
, offset
/ TARGET_CHAR_BIT
);
1322 /* Record the area of memory we're about to fetch. */
1323 ax_trace_quick (ax
, op_size
/ TARGET_CHAR_BIT
);
1326 /* Perform the fetch. */
1327 ax_simple (ax
, ops
[op
]);
1329 /* Shift the bits we have to their proper position.
1330 gen_left_shift will generate right shifts when the operand
1333 A big-endian field diagram to ponder:
1334 byte 0 byte 1 byte 2 byte 3 byte 4 byte 5 byte 6 byte 7
1335 +------++------++------++------++------++------++------++------+
1336 xxxxAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCxxxxxxxxxxx
1338 bit number 16 32 48 53
1339 These are bit numbers as supplied by GDB. Note that the
1340 bit numbers run from right to left once you've fetched the
1343 A little-endian field diagram to ponder:
1344 byte 7 byte 6 byte 5 byte 4 byte 3 byte 2 byte 1 byte 0
1345 +------++------++------++------++------++------++------++------+
1346 xxxxxxxxxxxAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCxxxx
1348 bit number 48 32 16 4 0
1350 In both cases, the most significant end is on the left
1351 (i.e. normal numeric writing order), which means that you
1352 don't go crazy thinking about `left' and `right' shifts.
1354 We don't have to worry about masking yet:
1355 - If they contain garbage off the least significant end, then we
1356 must be looking at the low end of the field, and the right
1357 shift will wipe them out.
1358 - If they contain garbage off the most significant end, then we
1359 must be looking at the most significant end of the word, and
1360 the sign/zero extension will wipe them out.
1361 - If we're in the interior of the word, then there is no garbage
1362 on either end, because the ref operators zero-extend. */
1363 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
1364 gen_left_shift (ax
, end
- (offset
+ op_size
));
1366 gen_left_shift (ax
, offset
- start
);
1369 /* Bring the copy of the address up to the top. */
1370 ax_simple (ax
, aop_swap
);
1377 /* Generate enough bitwise `or' operations to combine all the
1378 fragments we left on the stack. */
1379 while (fragment_count
-- > 1)
1380 ax_simple (ax
, aop_bit_or
);
1382 /* Sign- or zero-extend the value as appropriate. */
1383 ((TYPE_UNSIGNED (type
) ? ax_zero_ext
: ax_ext
) (ax
, end
- start
));
1385 /* This is *not* an lvalue. Ugh. */
1386 value
->kind
= axs_rvalue
;
1390 /* Generate bytecodes for field number FIELDNO of type TYPE. OFFSET
1391 is an accumulated offset (in bytes), will be nonzero for objects
1392 embedded in other objects, like C++ base classes. Behavior should
1393 generally follow value_primitive_field. */
1396 gen_primitive_field (struct expression
*exp
,
1397 struct agent_expr
*ax
, struct axs_value
*value
,
1398 int offset
, int fieldno
, struct type
*type
)
1400 /* Is this a bitfield? */
1401 if (TYPE_FIELD_PACKED (type
, fieldno
))
1402 gen_bitfield_ref (exp
, ax
, value
, TYPE_FIELD_TYPE (type
, fieldno
),
1403 (offset
* TARGET_CHAR_BIT
1404 + TYPE_FIELD_BITPOS (type
, fieldno
)),
1405 (offset
* TARGET_CHAR_BIT
1406 + TYPE_FIELD_BITPOS (type
, fieldno
)
1407 + TYPE_FIELD_BITSIZE (type
, fieldno
)));
1410 gen_offset (ax
, offset
1411 + TYPE_FIELD_BITPOS (type
, fieldno
) / TARGET_CHAR_BIT
);
1412 value
->kind
= axs_lvalue_memory
;
1413 value
->type
= TYPE_FIELD_TYPE (type
, fieldno
);
1417 /* Search for the given field in either the given type or one of its
1418 base classes. Return 1 if found, 0 if not. */
1421 gen_struct_ref_recursive (struct expression
*exp
, struct agent_expr
*ax
,
1422 struct axs_value
*value
,
1423 char *field
, int offset
, struct type
*type
)
1426 int nbases
= TYPE_N_BASECLASSES (type
);
1428 CHECK_TYPEDEF (type
);
1430 for (i
= TYPE_NFIELDS (type
) - 1; i
>= nbases
; i
--)
1432 char *this_name
= TYPE_FIELD_NAME (type
, i
);
1436 if (strcmp (field
, this_name
) == 0)
1438 /* Note that bytecodes for the struct's base (aka
1439 "this") will have been generated already, which will
1440 be unnecessary but not harmful if the static field is
1441 being handled as a global. */
1442 if (field_is_static (&TYPE_FIELD (type
, i
)))
1444 gen_static_field (exp
->gdbarch
, ax
, value
, type
, i
);
1445 if (value
->optimized_out
)
1446 error (_("static field `%s' has been optimized out, cannot use"),
1451 gen_primitive_field (exp
, ax
, value
, offset
, i
, type
);
1454 #if 0 /* is this right? */
1455 if (this_name
[0] == '\0')
1456 internal_error (__FILE__
, __LINE__
,
1457 _("find_field: anonymous unions not supported"));
1462 /* Now scan through base classes recursively. */
1463 for (i
= 0; i
< nbases
; i
++)
1465 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
1467 rslt
= gen_struct_ref_recursive (exp
, ax
, value
, field
,
1468 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / TARGET_CHAR_BIT
,
1474 /* Not found anywhere, flag so caller can complain. */
1478 /* Generate code to reference the member named FIELD of a structure or
1479 union. The top of the stack, as described by VALUE, should have
1480 type (pointer to a)* struct/union. OPERATOR_NAME is the name of
1481 the operator being compiled, and OPERAND_NAME is the kind of thing
1482 it operates on; we use them in error messages. */
1484 gen_struct_ref (struct expression
*exp
, struct agent_expr
*ax
,
1485 struct axs_value
*value
, char *field
,
1486 char *operator_name
, char *operand_name
)
1491 /* Follow pointers until we reach a non-pointer. These aren't the C
1492 semantics, but they're what the normal GDB evaluator does, so we
1493 should at least be consistent. */
1494 while (pointer_type (value
->type
))
1496 require_rvalue (ax
, value
);
1497 gen_deref (ax
, value
);
1499 type
= check_typedef (value
->type
);
1501 /* This must yield a structure or a union. */
1502 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1503 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1504 error (_("The left operand of `%s' is not a %s."),
1505 operator_name
, operand_name
);
1507 /* And it must be in memory; we don't deal with structure rvalues,
1508 or structures living in registers. */
1509 if (value
->kind
!= axs_lvalue_memory
)
1510 error (_("Structure does not live in memory."));
1512 /* Search through fields and base classes recursively. */
1513 found
= gen_struct_ref_recursive (exp
, ax
, value
, field
, 0, type
);
1516 error (_("Couldn't find member named `%s' in struct/union/class `%s'"),
1517 field
, TYPE_TAG_NAME (type
));
1521 gen_namespace_elt (struct expression
*exp
,
1522 struct agent_expr
*ax
, struct axs_value
*value
,
1523 const struct type
*curtype
, char *name
);
1525 gen_maybe_namespace_elt (struct expression
*exp
,
1526 struct agent_expr
*ax
, struct axs_value
*value
,
1527 const struct type
*curtype
, char *name
);
1530 gen_static_field (struct gdbarch
*gdbarch
,
1531 struct agent_expr
*ax
, struct axs_value
*value
,
1532 struct type
*type
, int fieldno
)
1534 if (TYPE_FIELD_LOC_KIND (type
, fieldno
) == FIELD_LOC_KIND_PHYSADDR
)
1536 ax_const_l (ax
, TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
));
1537 value
->kind
= axs_lvalue_memory
;
1538 value
->type
= TYPE_FIELD_TYPE (type
, fieldno
);
1539 value
->optimized_out
= 0;
1543 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
1544 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_DOMAIN
, 0);
1548 gen_var_ref (gdbarch
, ax
, value
, sym
);
1550 /* Don't error if the value was optimized out, we may be
1551 scanning all static fields and just want to pass over this
1552 and continue with the rest. */
1556 /* Silently assume this was optimized out; class printing
1557 will let the user know why the data is missing. */
1558 value
->optimized_out
= 1;
1564 gen_struct_elt_for_reference (struct expression
*exp
,
1565 struct agent_expr
*ax
, struct axs_value
*value
,
1566 struct type
*type
, char *fieldname
)
1568 struct type
*t
= type
;
1570 struct value
*v
, *result
;
1572 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1573 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1574 internal_error (__FILE__
, __LINE__
,
1575 _("non-aggregate type to gen_struct_elt_for_reference"));
1577 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
1579 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
1581 if (t_field_name
&& strcmp (t_field_name
, fieldname
) == 0)
1583 if (field_is_static (&TYPE_FIELD (t
, i
)))
1585 gen_static_field (exp
->gdbarch
, ax
, value
, t
, i
);
1586 if (value
->optimized_out
)
1587 error (_("static field `%s' has been optimized out, cannot use"),
1591 if (TYPE_FIELD_PACKED (t
, i
))
1592 error (_("pointers to bitfield members not allowed"));
1594 /* FIXME we need a way to do "want_address" equivalent */
1596 error (_("Cannot reference non-static field \"%s\""), fieldname
);
1600 /* FIXME add other scoped-reference cases here */
1602 /* Do a last-ditch lookup. */
1603 return gen_maybe_namespace_elt (exp
, ax
, value
, type
, fieldname
);
1606 /* C++: Return the member NAME of the namespace given by the type
1610 gen_namespace_elt (struct expression
*exp
,
1611 struct agent_expr
*ax
, struct axs_value
*value
,
1612 const struct type
*curtype
, char *name
)
1614 int found
= gen_maybe_namespace_elt (exp
, ax
, value
, curtype
, name
);
1617 error (_("No symbol \"%s\" in namespace \"%s\"."),
1618 name
, TYPE_TAG_NAME (curtype
));
1623 /* A helper function used by value_namespace_elt and
1624 value_struct_elt_for_reference. It looks up NAME inside the
1625 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
1626 is a class and NAME refers to a type in CURTYPE itself (as opposed
1627 to, say, some base class of CURTYPE). */
1630 gen_maybe_namespace_elt (struct expression
*exp
,
1631 struct agent_expr
*ax
, struct axs_value
*value
,
1632 const struct type
*curtype
, char *name
)
1634 const char *namespace_name
= TYPE_TAG_NAME (curtype
);
1637 sym
= cp_lookup_symbol_namespace (namespace_name
, name
,
1638 block_for_pc (ax
->scope
),
1644 gen_var_ref (exp
->gdbarch
, ax
, value
, sym
);
1646 if (value
->optimized_out
)
1647 error (_("`%s' has been optimized out, cannot use"),
1648 SYMBOL_PRINT_NAME (sym
));
1655 gen_aggregate_elt_ref (struct expression
*exp
,
1656 struct agent_expr
*ax
, struct axs_value
*value
,
1657 struct type
*type
, char *field
,
1658 char *operator_name
, char *operand_name
)
1660 switch (TYPE_CODE (type
))
1662 case TYPE_CODE_STRUCT
:
1663 case TYPE_CODE_UNION
:
1664 return gen_struct_elt_for_reference (exp
, ax
, value
, type
, field
);
1666 case TYPE_CODE_NAMESPACE
:
1667 return gen_namespace_elt (exp
, ax
, value
, type
, field
);
1670 internal_error (__FILE__
, __LINE__
,
1671 _("non-aggregate type in gen_aggregate_elt_ref"));
1677 /* Generate code for GDB's magical `repeat' operator.
1678 LVALUE @ INT creates an array INT elements long, and whose elements
1679 have the same type as LVALUE, located in memory so that LVALUE is
1680 its first element. For example, argv[0]@argc gives you the array
1681 of command-line arguments.
1683 Unfortunately, because we have to know the types before we actually
1684 have a value for the expression, we can't implement this perfectly
1685 without changing the type system, having values that occupy two
1686 stack slots, doing weird things with sizeof, etc. So we require
1687 the right operand to be a constant expression. */
1689 gen_repeat (struct expression
*exp
, union exp_element
**pc
,
1690 struct agent_expr
*ax
, struct axs_value
*value
)
1692 struct axs_value value1
;
1693 /* We don't want to turn this into an rvalue, so no conversions
1695 gen_expr (exp
, pc
, ax
, &value1
);
1696 if (value1
.kind
!= axs_lvalue_memory
)
1697 error (_("Left operand of `@' must be an object in memory."));
1699 /* Evaluate the length; it had better be a constant. */
1701 struct value
*v
= const_expr (pc
);
1705 error (_("Right operand of `@' must be a constant, in agent expressions."));
1706 if (TYPE_CODE (value_type (v
)) != TYPE_CODE_INT
)
1707 error (_("Right operand of `@' must be an integer."));
1708 length
= value_as_long (v
);
1710 error (_("Right operand of `@' must be positive."));
1712 /* The top of the stack is already the address of the object, so
1713 all we need to do is frob the type of the lvalue. */
1715 /* FIXME-type-allocation: need a way to free this type when we are
1718 = lookup_array_range_type (value1
.type
, 0, length
- 1);
1720 value
->kind
= axs_lvalue_memory
;
1721 value
->type
= array
;
1727 /* Emit code for the `sizeof' operator.
1728 *PC should point at the start of the operand expression; we advance it
1729 to the first instruction after the operand. */
1731 gen_sizeof (struct expression
*exp
, union exp_element
**pc
,
1732 struct agent_expr
*ax
, struct axs_value
*value
,
1733 struct type
*size_type
)
1735 /* We don't care about the value of the operand expression; we only
1736 care about its type. However, in the current arrangement, the
1737 only way to find an expression's type is to generate code for it.
1738 So we generate code for the operand, and then throw it away,
1739 replacing it with code that simply pushes its size. */
1740 int start
= ax
->len
;
1741 gen_expr (exp
, pc
, ax
, value
);
1743 /* Throw away the code we just generated. */
1746 ax_const_l (ax
, TYPE_LENGTH (value
->type
));
1747 value
->kind
= axs_rvalue
;
1748 value
->type
= size_type
;
1752 /* Generating bytecode from GDB expressions: general recursive thingy */
1755 /* A gen_expr function written by a Gen-X'er guy.
1756 Append code for the subexpression of EXPR starting at *POS_P to AX. */
1758 gen_expr (struct expression
*exp
, union exp_element
**pc
,
1759 struct agent_expr
*ax
, struct axs_value
*value
)
1761 /* Used to hold the descriptions of operand expressions. */
1762 struct axs_value value1
, value2
, value3
;
1763 enum exp_opcode op
= (*pc
)[0].opcode
, op2
;
1764 int if1
, go1
, if2
, go2
, end
;
1765 struct type
*int_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
1767 /* If we're looking at a constant expression, just push its value. */
1769 struct value
*v
= maybe_const_expr (pc
);
1773 ax_const_l (ax
, value_as_long (v
));
1774 value
->kind
= axs_rvalue
;
1775 value
->type
= check_typedef (value_type (v
));
1780 /* Otherwise, go ahead and generate code for it. */
1783 /* Binary arithmetic operators. */
1791 case BINOP_SUBSCRIPT
:
1792 case BINOP_BITWISE_AND
:
1793 case BINOP_BITWISE_IOR
:
1794 case BINOP_BITWISE_XOR
:
1796 case BINOP_NOTEQUAL
:
1802 gen_expr (exp
, pc
, ax
, &value1
);
1803 gen_usual_unary (exp
, ax
, &value1
);
1804 gen_expr_binop_rest (exp
, op
, pc
, ax
, value
, &value1
, &value2
);
1807 case BINOP_LOGICAL_AND
:
1809 /* Generate the obvious sequence of tests and jumps. */
1810 gen_expr (exp
, pc
, ax
, &value1
);
1811 gen_usual_unary (exp
, ax
, &value1
);
1812 if1
= ax_goto (ax
, aop_if_goto
);
1813 go1
= ax_goto (ax
, aop_goto
);
1814 ax_label (ax
, if1
, ax
->len
);
1815 gen_expr (exp
, pc
, ax
, &value2
);
1816 gen_usual_unary (exp
, ax
, &value2
);
1817 if2
= ax_goto (ax
, aop_if_goto
);
1818 go2
= ax_goto (ax
, aop_goto
);
1819 ax_label (ax
, if2
, ax
->len
);
1821 end
= ax_goto (ax
, aop_goto
);
1822 ax_label (ax
, go1
, ax
->len
);
1823 ax_label (ax
, go2
, ax
->len
);
1825 ax_label (ax
, end
, ax
->len
);
1826 value
->kind
= axs_rvalue
;
1827 value
->type
= int_type
;
1830 case BINOP_LOGICAL_OR
:
1832 /* Generate the obvious sequence of tests and jumps. */
1833 gen_expr (exp
, pc
, ax
, &value1
);
1834 gen_usual_unary (exp
, ax
, &value1
);
1835 if1
= ax_goto (ax
, aop_if_goto
);
1836 gen_expr (exp
, pc
, ax
, &value2
);
1837 gen_usual_unary (exp
, ax
, &value2
);
1838 if2
= ax_goto (ax
, aop_if_goto
);
1840 end
= ax_goto (ax
, aop_goto
);
1841 ax_label (ax
, if1
, ax
->len
);
1842 ax_label (ax
, if2
, ax
->len
);
1844 ax_label (ax
, end
, ax
->len
);
1845 value
->kind
= axs_rvalue
;
1846 value
->type
= int_type
;
1851 gen_expr (exp
, pc
, ax
, &value1
);
1852 gen_usual_unary (exp
, ax
, &value1
);
1853 /* For (A ? B : C), it's easiest to generate subexpression
1854 bytecodes in order, but if_goto jumps on true, so we invert
1855 the sense of A. Then we can do B by dropping through, and
1857 gen_logical_not (ax
, &value1
, int_type
);
1858 if1
= ax_goto (ax
, aop_if_goto
);
1859 gen_expr (exp
, pc
, ax
, &value2
);
1860 gen_usual_unary (exp
, ax
, &value2
);
1861 end
= ax_goto (ax
, aop_goto
);
1862 ax_label (ax
, if1
, ax
->len
);
1863 gen_expr (exp
, pc
, ax
, &value3
);
1864 gen_usual_unary (exp
, ax
, &value3
);
1865 ax_label (ax
, end
, ax
->len
);
1866 /* This is arbitary - what if B and C are incompatible types? */
1867 value
->type
= value2
.type
;
1868 value
->kind
= value2
.kind
;
1873 if ((*pc
)[0].opcode
== OP_INTERNALVAR
)
1875 char *name
= internalvar_name ((*pc
)[1].internalvar
);
1876 struct trace_state_variable
*tsv
;
1878 gen_expr (exp
, pc
, ax
, value
);
1879 tsv
= find_trace_state_variable (name
);
1882 ax_tsv (ax
, aop_setv
, tsv
->number
);
1884 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1887 error (_("$%s is not a trace state variable, may not assign to it"), name
);
1890 error (_("May only assign to trace state variables"));
1893 case BINOP_ASSIGN_MODIFY
:
1895 op2
= (*pc
)[0].opcode
;
1898 if ((*pc
)[0].opcode
== OP_INTERNALVAR
)
1900 char *name
= internalvar_name ((*pc
)[1].internalvar
);
1901 struct trace_state_variable
*tsv
;
1903 tsv
= find_trace_state_variable (name
);
1906 /* The tsv will be the left half of the binary operation. */
1907 ax_tsv (ax
, aop_getv
, tsv
->number
);
1909 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1910 /* Trace state variables are always 64-bit integers. */
1911 value1
.kind
= axs_rvalue
;
1912 value1
.type
= builtin_type (exp
->gdbarch
)->builtin_long_long
;
1913 /* Now do right half of expression. */
1914 gen_expr_binop_rest (exp
, op2
, pc
, ax
, value
, &value1
, &value2
);
1915 /* We have a result of the binary op, set the tsv. */
1916 ax_tsv (ax
, aop_setv
, tsv
->number
);
1918 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1921 error (_("$%s is not a trace state variable, may not assign to it"), name
);
1924 error (_("May only assign to trace state variables"));
1927 /* Note that we need to be a little subtle about generating code
1928 for comma. In C, we can do some optimizations here because
1929 we know the left operand is only being evaluated for effect.
1930 However, if the tracing kludge is in effect, then we always
1931 need to evaluate the left hand side fully, so that all the
1932 variables it mentions get traced. */
1935 gen_expr (exp
, pc
, ax
, &value1
);
1936 /* Don't just dispose of the left operand. We might be tracing,
1937 in which case we want to emit code to trace it if it's an
1939 gen_traced_pop (exp
->gdbarch
, ax
, &value1
);
1940 gen_expr (exp
, pc
, ax
, value
);
1941 /* It's the consumer's responsibility to trace the right operand. */
1944 case OP_LONG
: /* some integer constant */
1946 struct type
*type
= (*pc
)[1].type
;
1947 LONGEST k
= (*pc
)[2].longconst
;
1949 gen_int_literal (ax
, value
, k
, type
);
1954 gen_var_ref (exp
->gdbarch
, ax
, value
, (*pc
)[2].symbol
);
1956 if (value
->optimized_out
)
1957 error (_("`%s' has been optimized out, cannot use"),
1958 SYMBOL_PRINT_NAME ((*pc
)[2].symbol
));
1965 const char *name
= &(*pc
)[2].string
;
1967 (*pc
) += 4 + BYTES_TO_EXP_ELEM ((*pc
)[1].longconst
+ 1);
1968 reg
= user_reg_map_name_to_regnum (exp
->gdbarch
, name
, strlen (name
));
1970 internal_error (__FILE__
, __LINE__
,
1971 _("Register $%s not available"), name
);
1972 if (reg
>= gdbarch_num_regs (exp
->gdbarch
))
1973 error (_("'%s' is a pseudo-register; "
1974 "GDB cannot yet trace pseudoregister contents."),
1976 value
->kind
= axs_lvalue_register
;
1978 value
->type
= register_type (exp
->gdbarch
, reg
);
1982 case OP_INTERNALVAR
:
1984 const char *name
= internalvar_name ((*pc
)[1].internalvar
);
1985 struct trace_state_variable
*tsv
;
1987 tsv
= find_trace_state_variable (name
);
1990 ax_tsv (ax
, aop_getv
, tsv
->number
);
1992 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1993 /* Trace state variables are always 64-bit integers. */
1994 value
->kind
= axs_rvalue
;
1995 value
->type
= builtin_type (exp
->gdbarch
)->builtin_long_long
;
1998 error (_("$%s is not a trace state variable; GDB agent expressions cannot use convenience variables."), name
);
2002 /* Weirdo operator: see comments for gen_repeat for details. */
2004 /* Note that gen_repeat handles its own argument evaluation. */
2006 gen_repeat (exp
, pc
, ax
, value
);
2011 struct type
*type
= (*pc
)[1].type
;
2013 gen_expr (exp
, pc
, ax
, value
);
2014 gen_cast (ax
, value
, type
);
2020 struct type
*type
= check_typedef ((*pc
)[1].type
);
2022 gen_expr (exp
, pc
, ax
, value
);
2023 /* I'm not sure I understand UNOP_MEMVAL entirely. I think
2024 it's just a hack for dealing with minsyms; you take some
2025 integer constant, pretend it's the address of an lvalue of
2026 the given type, and dereference it. */
2027 if (value
->kind
!= axs_rvalue
)
2028 /* This would be weird. */
2029 internal_error (__FILE__
, __LINE__
,
2030 _("gen_expr: OP_MEMVAL operand isn't an rvalue???"));
2032 value
->kind
= axs_lvalue_memory
;
2038 /* + FOO is equivalent to 0 + FOO, which can be optimized. */
2039 gen_expr (exp
, pc
, ax
, value
);
2040 gen_usual_unary (exp
, ax
, value
);
2045 /* -FOO is equivalent to 0 - FOO. */
2046 gen_int_literal (ax
, &value1
, 0,
2047 builtin_type (exp
->gdbarch
)->builtin_int
);
2048 gen_usual_unary (exp
, ax
, &value1
); /* shouldn't do much */
2049 gen_expr (exp
, pc
, ax
, &value2
);
2050 gen_usual_unary (exp
, ax
, &value2
);
2051 gen_usual_arithmetic (exp
, ax
, &value1
, &value2
);
2052 gen_binop (ax
, value
, &value1
, &value2
, aop_sub
, aop_sub
, 1, "negation");
2055 case UNOP_LOGICAL_NOT
:
2057 gen_expr (exp
, pc
, ax
, value
);
2058 gen_usual_unary (exp
, ax
, value
);
2059 gen_logical_not (ax
, value
, int_type
);
2062 case UNOP_COMPLEMENT
:
2064 gen_expr (exp
, pc
, ax
, value
);
2065 gen_usual_unary (exp
, ax
, value
);
2066 gen_integral_promotions (exp
, ax
, value
);
2067 gen_complement (ax
, value
);
2072 gen_expr (exp
, pc
, ax
, value
);
2073 gen_usual_unary (exp
, ax
, value
);
2074 if (!pointer_type (value
->type
))
2075 error (_("Argument of unary `*' is not a pointer."));
2076 gen_deref (ax
, value
);
2081 gen_expr (exp
, pc
, ax
, value
);
2082 gen_address_of (ax
, value
);
2087 /* Notice that gen_sizeof handles its own operand, unlike most
2088 of the other unary operator functions. This is because we
2089 have to throw away the code we generate. */
2090 gen_sizeof (exp
, pc
, ax
, value
,
2091 builtin_type (exp
->gdbarch
)->builtin_int
);
2094 case STRUCTOP_STRUCT
:
2097 int length
= (*pc
)[1].longconst
;
2098 char *name
= &(*pc
)[2].string
;
2100 (*pc
) += 4 + BYTES_TO_EXP_ELEM (length
+ 1);
2101 gen_expr (exp
, pc
, ax
, value
);
2102 if (op
== STRUCTOP_STRUCT
)
2103 gen_struct_ref (exp
, ax
, value
, name
, ".", "structure or union");
2104 else if (op
== STRUCTOP_PTR
)
2105 gen_struct_ref (exp
, ax
, value
, name
, "->",
2106 "pointer to a structure or union");
2108 /* If this `if' chain doesn't handle it, then the case list
2109 shouldn't mention it, and we shouldn't be here. */
2110 internal_error (__FILE__
, __LINE__
,
2111 _("gen_expr: unhandled struct case"));
2118 struct symbol
*func
, *sym
;
2121 func
= block_linkage_function (block_for_pc (ax
->scope
));
2122 this_name
= language_def (SYMBOL_LANGUAGE (func
))->la_name_of_this
;
2123 b
= SYMBOL_BLOCK_VALUE (func
);
2125 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
2126 symbol instead of the LOC_ARG one (if both exist). */
2127 sym
= lookup_block_symbol (b
, this_name
, VAR_DOMAIN
);
2129 error (_("no `%s' found"), this_name
);
2131 gen_var_ref (exp
->gdbarch
, ax
, value
, sym
);
2133 if (value
->optimized_out
)
2134 error (_("`%s' has been optimized out, cannot use"),
2135 SYMBOL_PRINT_NAME (sym
));
2143 struct type
*type
= (*pc
)[1].type
;
2144 int length
= longest_to_int ((*pc
)[2].longconst
);
2145 char *name
= &(*pc
)[3].string
;
2148 found
= gen_aggregate_elt_ref (exp
, ax
, value
, type
, name
,
2151 error (_("There is no field named %s"), name
);
2152 (*pc
) += 5 + BYTES_TO_EXP_ELEM (length
+ 1);
2157 error (_("Attempt to use a type name as an expression."));
2160 error (_("Unsupported operator %s (%d) in expression."),
2161 op_string (op
), op
);
2165 /* This handles the middle-to-right-side of code generation for binary
2166 expressions, which is shared between regular binary operations and
2167 assign-modify (+= and friends) expressions. */
2170 gen_expr_binop_rest (struct expression
*exp
,
2171 enum exp_opcode op
, union exp_element
**pc
,
2172 struct agent_expr
*ax
, struct axs_value
*value
,
2173 struct axs_value
*value1
, struct axs_value
*value2
)
2175 struct type
*int_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2177 gen_expr (exp
, pc
, ax
, value2
);
2178 gen_usual_unary (exp
, ax
, value2
);
2179 gen_usual_arithmetic (exp
, ax
, value1
, value2
);
2183 if (TYPE_CODE (value1
->type
) == TYPE_CODE_INT
2184 && pointer_type (value2
->type
))
2186 /* Swap the values and proceed normally. */
2187 ax_simple (ax
, aop_swap
);
2188 gen_ptradd (ax
, value
, value2
, value1
);
2190 else if (pointer_type (value1
->type
)
2191 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
2192 gen_ptradd (ax
, value
, value1
, value2
);
2194 gen_binop (ax
, value
, value1
, value2
,
2195 aop_add
, aop_add
, 1, "addition");
2198 if (pointer_type (value1
->type
)
2199 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
2200 gen_ptrsub (ax
,value
, value1
, value2
);
2201 else if (pointer_type (value1
->type
)
2202 && pointer_type (value2
->type
))
2203 /* FIXME --- result type should be ptrdiff_t */
2204 gen_ptrdiff (ax
, value
, value1
, value2
,
2205 builtin_type (exp
->gdbarch
)->builtin_long
);
2207 gen_binop (ax
, value
, value1
, value2
,
2208 aop_sub
, aop_sub
, 1, "subtraction");
2211 gen_binop (ax
, value
, value1
, value2
,
2212 aop_mul
, aop_mul
, 1, "multiplication");
2215 gen_binop (ax
, value
, value1
, value2
,
2216 aop_div_signed
, aop_div_unsigned
, 1, "division");
2219 gen_binop (ax
, value
, value1
, value2
,
2220 aop_rem_signed
, aop_rem_unsigned
, 1, "remainder");
2223 gen_binop (ax
, value
, value1
, value2
,
2224 aop_lsh
, aop_lsh
, 1, "left shift");
2227 gen_binop (ax
, value
, value1
, value2
,
2228 aop_rsh_signed
, aop_rsh_unsigned
, 1, "right shift");
2230 case BINOP_SUBSCRIPT
:
2234 if (binop_types_user_defined_p (op
, value1
->type
, value2
->type
))
2237 cannot subscript requested type: cannot call user defined functions"));
2241 /* If the user attempts to subscript something that is not
2242 an array or pointer type (like a plain int variable for
2243 example), then report this as an error. */
2244 type
= check_typedef (value1
->type
);
2245 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2246 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2248 if (TYPE_NAME (type
))
2249 error (_("cannot subscript something of type `%s'"),
2252 error (_("cannot subscript requested type"));
2256 if (!is_integral_type (value2
->type
))
2257 error (_("Argument to arithmetic operation not a number or boolean."));
2259 gen_ptradd (ax
, value
, value1
, value2
);
2260 gen_deref (ax
, value
);
2263 case BINOP_BITWISE_AND
:
2264 gen_binop (ax
, value
, value1
, value2
,
2265 aop_bit_and
, aop_bit_and
, 0, "bitwise and");
2268 case BINOP_BITWISE_IOR
:
2269 gen_binop (ax
, value
, value1
, value2
,
2270 aop_bit_or
, aop_bit_or
, 0, "bitwise or");
2273 case BINOP_BITWISE_XOR
:
2274 gen_binop (ax
, value
, value1
, value2
,
2275 aop_bit_xor
, aop_bit_xor
, 0, "bitwise exclusive-or");
2279 gen_equal (ax
, value
, value1
, value2
, int_type
);
2282 case BINOP_NOTEQUAL
:
2283 gen_equal (ax
, value
, value1
, value2
, int_type
);
2284 gen_logical_not (ax
, value
, int_type
);
2288 gen_less (ax
, value
, value1
, value2
, int_type
);
2292 ax_simple (ax
, aop_swap
);
2293 gen_less (ax
, value
, value1
, value2
, int_type
);
2297 ax_simple (ax
, aop_swap
);
2298 gen_less (ax
, value
, value1
, value2
, int_type
);
2299 gen_logical_not (ax
, value
, int_type
);
2303 gen_less (ax
, value
, value1
, value2
, int_type
);
2304 gen_logical_not (ax
, value
, int_type
);
2308 /* We should only list operators in the outer case statement
2309 that we actually handle in the inner case statement. */
2310 internal_error (__FILE__
, __LINE__
,
2311 _("gen_expr: op case sets don't match"));
2316 /* Given a single variable and a scope, generate bytecodes to trace
2317 its value. This is for use in situations where we have only a
2318 variable's name, and no parsed expression; for instance, when the
2319 name comes from a list of local variables of a function. */
2322 gen_trace_for_var (CORE_ADDR scope
, struct gdbarch
*gdbarch
,
2325 struct cleanup
*old_chain
= 0;
2326 struct agent_expr
*ax
= new_agent_expr (gdbarch
, scope
);
2327 struct axs_value value
;
2329 old_chain
= make_cleanup_free_agent_expr (ax
);
2332 gen_var_ref (gdbarch
, ax
, &value
, var
);
2334 /* If there is no actual variable to trace, flag it by returning
2335 an empty agent expression. */
2336 if (value
.optimized_out
)
2338 do_cleanups (old_chain
);
2342 /* Make sure we record the final object, and get rid of it. */
2343 gen_traced_pop (gdbarch
, ax
, &value
);
2345 /* Oh, and terminate. */
2346 ax_simple (ax
, aop_end
);
2348 /* We have successfully built the agent expr, so cancel the cleanup
2349 request. If we add more cleanups that we always want done, this
2350 will have to get more complicated. */
2351 discard_cleanups (old_chain
);
2355 /* Generating bytecode from GDB expressions: driver */
2357 /* Given a GDB expression EXPR, return bytecode to trace its value.
2358 The result will use the `trace' and `trace_quick' bytecodes to
2359 record the value of all memory touched by the expression. The
2360 caller can then use the ax_reqs function to discover which
2361 registers it relies upon. */
2363 gen_trace_for_expr (CORE_ADDR scope
, struct expression
*expr
)
2365 struct cleanup
*old_chain
= 0;
2366 struct agent_expr
*ax
= new_agent_expr (expr
->gdbarch
, scope
);
2367 union exp_element
*pc
;
2368 struct axs_value value
;
2370 old_chain
= make_cleanup_free_agent_expr (ax
);
2374 value
.optimized_out
= 0;
2375 gen_expr (expr
, &pc
, ax
, &value
);
2377 /* Make sure we record the final object, and get rid of it. */
2378 gen_traced_pop (expr
->gdbarch
, ax
, &value
);
2380 /* Oh, and terminate. */
2381 ax_simple (ax
, aop_end
);
2383 /* We have successfully built the agent expr, so cancel the cleanup
2384 request. If we add more cleanups that we always want done, this
2385 will have to get more complicated. */
2386 discard_cleanups (old_chain
);
2390 /* Given a GDB expression EXPR, return a bytecode sequence that will
2391 evaluate and return a result. The bytecodes will do a direct
2392 evaluation, using the current data on the target, rather than
2393 recording blocks of memory and registers for later use, as
2394 gen_trace_for_expr does. The generated bytecode sequence leaves
2395 the result of expression evaluation on the top of the stack. */
2398 gen_eval_for_expr (CORE_ADDR scope
, struct expression
*expr
)
2400 struct cleanup
*old_chain
= 0;
2401 struct agent_expr
*ax
= new_agent_expr (expr
->gdbarch
, scope
);
2402 union exp_element
*pc
;
2403 struct axs_value value
;
2405 old_chain
= make_cleanup_free_agent_expr (ax
);
2409 value
.optimized_out
= 0;
2410 gen_expr (expr
, &pc
, ax
, &value
);
2412 require_rvalue (ax
, &value
);
2414 /* Oh, and terminate. */
2415 ax_simple (ax
, aop_end
);
2417 /* We have successfully built the agent expr, so cancel the cleanup
2418 request. If we add more cleanups that we always want done, this
2419 will have to get more complicated. */
2420 discard_cleanups (old_chain
);
2425 agent_command (char *exp
, int from_tty
)
2427 struct cleanup
*old_chain
= 0;
2428 struct expression
*expr
;
2429 struct agent_expr
*agent
;
2430 struct frame_info
*fi
= get_current_frame (); /* need current scope */
2432 /* We don't deal with overlay debugging at the moment. We need to
2433 think more carefully about this. If you copy this code into
2434 another command, change the error message; the user shouldn't
2435 have to know anything about agent expressions. */
2436 if (overlay_debugging
)
2437 error (_("GDB can't do agent expression translation with overlays."));
2440 error_no_arg (_("expression to translate"));
2442 expr
= parse_expression (exp
);
2443 old_chain
= make_cleanup (free_current_contents
, &expr
);
2444 agent
= gen_trace_for_expr (get_frame_pc (fi
), expr
);
2445 make_cleanup_free_agent_expr (agent
);
2447 ax_print (gdb_stdout
, agent
);
2449 /* It would be nice to call ax_reqs here to gather some general info
2450 about the expression, and then print out the result. */
2452 do_cleanups (old_chain
);
2456 /* Parse the given expression, compile it into an agent expression
2457 that does direct evaluation, and display the resulting
2461 agent_eval_command (char *exp
, int from_tty
)
2463 struct cleanup
*old_chain
= 0;
2464 struct expression
*expr
;
2465 struct agent_expr
*agent
;
2466 struct frame_info
*fi
= get_current_frame (); /* need current scope */
2468 /* We don't deal with overlay debugging at the moment. We need to
2469 think more carefully about this. If you copy this code into
2470 another command, change the error message; the user shouldn't
2471 have to know anything about agent expressions. */
2472 if (overlay_debugging
)
2473 error (_("GDB can't do agent expression translation with overlays."));
2476 error_no_arg (_("expression to translate"));
2478 expr
= parse_expression (exp
);
2479 old_chain
= make_cleanup (free_current_contents
, &expr
);
2480 agent
= gen_eval_for_expr (get_frame_pc (fi
), expr
);
2481 make_cleanup_free_agent_expr (agent
);
2483 ax_print (gdb_stdout
, agent
);
2485 /* It would be nice to call ax_reqs here to gather some general info
2486 about the expression, and then print out the result. */
2488 do_cleanups (old_chain
);
2493 /* Initialization code. */
2495 void _initialize_ax_gdb (void);
2497 _initialize_ax_gdb (void)
2499 add_cmd ("agent", class_maintenance
, agent_command
,
2500 _("Translate an expression into remote agent bytecode for tracing."),
2503 add_cmd ("agent-eval", class_maintenance
, agent_eval_command
,
2504 _("Translate an expression into remote agent bytecode for evaluation."),
This page took 0.083113 seconds and 4 git commands to generate.