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. */
332 static int trace_kludge
;
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 need to mention the register somewhere in the bytecode,
367 so ax_reqs will pick it up and add it to the mask of
369 ax_reg (ax
, value
.u
.reg
);
377 /* Now scan through base classes recursively. */
378 for (i
= 0; i
< nbases
; i
++)
380 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
382 gen_trace_static_fields (gdbarch
, ax
, basetype
);
386 /* Trace the lvalue on the stack, if it needs it. In either case, pop
387 the value. Useful on the left side of a comma, and at the end of
388 an expression being used for tracing. */
390 gen_traced_pop (struct gdbarch
*gdbarch
,
391 struct agent_expr
*ax
, struct axs_value
*value
)
397 /* We don't trace rvalues, just the lvalues necessary to
398 produce them. So just dispose of this value. */
399 ax_simple (ax
, aop_pop
);
402 case axs_lvalue_memory
:
404 int length
= TYPE_LENGTH (check_typedef (value
->type
));
406 /* There's no point in trying to use a trace_quick bytecode
407 here, since "trace_quick SIZE pop" is three bytes, whereas
408 "const8 SIZE trace" is also three bytes, does the same
409 thing, and the simplest code which generates that will also
410 work correctly for objects with large sizes. */
411 ax_const_l (ax
, length
);
412 ax_simple (ax
, aop_trace
);
416 case axs_lvalue_register
:
417 /* We need to mention the register somewhere in the bytecode,
418 so ax_reqs will pick it up and add it to the mask of
420 ax_reg (ax
, value
->u
.reg
);
421 ax_simple (ax
, aop_pop
);
425 /* If we're not tracing, just pop the value. */
426 ax_simple (ax
, aop_pop
);
428 /* To trace C++ classes with static fields stored elsewhere. */
430 && (TYPE_CODE (value
->type
) == TYPE_CODE_STRUCT
431 || TYPE_CODE (value
->type
) == TYPE_CODE_UNION
))
432 gen_trace_static_fields (gdbarch
, ax
, value
->type
);
437 /* Generating bytecode from GDB expressions: helper functions */
439 /* Assume that the lower bits of the top of the stack is a value of
440 type TYPE, and the upper bits are zero. Sign-extend if necessary. */
442 gen_sign_extend (struct agent_expr
*ax
, struct type
*type
)
444 /* Do we need to sign-extend this? */
445 if (!TYPE_UNSIGNED (type
))
446 ax_ext (ax
, TYPE_LENGTH (type
) * TARGET_CHAR_BIT
);
450 /* Assume the lower bits of the top of the stack hold a value of type
451 TYPE, and the upper bits are garbage. Sign-extend or truncate as
454 gen_extend (struct agent_expr
*ax
, struct type
*type
)
456 int bits
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
458 ((TYPE_UNSIGNED (type
) ? ax_zero_ext
: ax_ext
) (ax
, bits
));
462 /* Assume that the top of the stack contains a value of type "pointer
463 to TYPE"; generate code to fetch its value. Note that TYPE is the
464 target type, not the pointer type. */
466 gen_fetch (struct agent_expr
*ax
, struct type
*type
)
470 /* Record the area of memory we're about to fetch. */
471 ax_trace_quick (ax
, TYPE_LENGTH (type
));
474 switch (TYPE_CODE (type
))
482 /* It's a scalar value, so we know how to dereference it. How
483 many bytes long is it? */
484 switch (TYPE_LENGTH (type
))
486 case 8 / TARGET_CHAR_BIT
:
487 ax_simple (ax
, aop_ref8
);
489 case 16 / TARGET_CHAR_BIT
:
490 ax_simple (ax
, aop_ref16
);
492 case 32 / TARGET_CHAR_BIT
:
493 ax_simple (ax
, aop_ref32
);
495 case 64 / TARGET_CHAR_BIT
:
496 ax_simple (ax
, aop_ref64
);
499 /* Either our caller shouldn't have asked us to dereference
500 that pointer (other code's fault), or we're not
501 implementing something we should be (this code's fault).
502 In any case, it's a bug the user shouldn't see. */
504 internal_error (__FILE__
, __LINE__
,
505 _("gen_fetch: strange size"));
508 gen_sign_extend (ax
, type
);
512 /* Either our caller shouldn't have asked us to dereference that
513 pointer (other code's fault), or we're not implementing
514 something we should be (this code's fault). In any case,
515 it's a bug the user shouldn't see. */
516 internal_error (__FILE__
, __LINE__
,
517 _("gen_fetch: bad type code"));
522 /* Generate code to left shift the top of the stack by DISTANCE bits, or
523 right shift it by -DISTANCE bits if DISTANCE < 0. This generates
524 unsigned (logical) right shifts. */
526 gen_left_shift (struct agent_expr
*ax
, int distance
)
530 ax_const_l (ax
, distance
);
531 ax_simple (ax
, aop_lsh
);
533 else if (distance
< 0)
535 ax_const_l (ax
, -distance
);
536 ax_simple (ax
, aop_rsh_unsigned
);
542 /* Generating bytecode from GDB expressions: symbol references */
544 /* Generate code to push the base address of the argument portion of
545 the top stack frame. */
547 gen_frame_args_address (struct gdbarch
*gdbarch
, struct agent_expr
*ax
)
550 LONGEST frame_offset
;
552 gdbarch_virtual_frame_pointer (gdbarch
,
553 ax
->scope
, &frame_reg
, &frame_offset
);
554 ax_reg (ax
, frame_reg
);
555 gen_offset (ax
, frame_offset
);
559 /* Generate code to push the base address of the locals portion of the
562 gen_frame_locals_address (struct gdbarch
*gdbarch
, struct agent_expr
*ax
)
565 LONGEST frame_offset
;
567 gdbarch_virtual_frame_pointer (gdbarch
,
568 ax
->scope
, &frame_reg
, &frame_offset
);
569 ax_reg (ax
, frame_reg
);
570 gen_offset (ax
, frame_offset
);
574 /* Generate code to add OFFSET to the top of the stack. Try to
575 generate short and readable code. We use this for getting to
576 variables on the stack, and structure members. If we were
577 programming in ML, it would be clearer why these are the same
580 gen_offset (struct agent_expr
*ax
, int offset
)
582 /* It would suffice to simply push the offset and add it, but this
583 makes it easier to read positive and negative offsets in the
587 ax_const_l (ax
, offset
);
588 ax_simple (ax
, aop_add
);
592 ax_const_l (ax
, -offset
);
593 ax_simple (ax
, aop_sub
);
598 /* In many cases, a symbol's value is the offset from some other
599 address (stack frame, base register, etc.) Generate code to add
600 VAR's value to the top of the stack. */
602 gen_sym_offset (struct agent_expr
*ax
, struct symbol
*var
)
604 gen_offset (ax
, SYMBOL_VALUE (var
));
608 /* Generate code for a variable reference to AX. The variable is the
609 symbol VAR. Set VALUE to describe the result. */
612 gen_var_ref (struct gdbarch
*gdbarch
, struct agent_expr
*ax
,
613 struct axs_value
*value
, struct symbol
*var
)
615 /* Dereference any typedefs. */
616 value
->type
= check_typedef (SYMBOL_TYPE (var
));
617 value
->optimized_out
= 0;
619 /* I'm imitating the code in read_var_value. */
620 switch (SYMBOL_CLASS (var
))
622 case LOC_CONST
: /* A constant, like an enum value. */
623 ax_const_l (ax
, (LONGEST
) SYMBOL_VALUE (var
));
624 value
->kind
= axs_rvalue
;
627 case LOC_LABEL
: /* A goto label, being used as a value. */
628 ax_const_l (ax
, (LONGEST
) SYMBOL_VALUE_ADDRESS (var
));
629 value
->kind
= axs_rvalue
;
632 case LOC_CONST_BYTES
:
633 internal_error (__FILE__
, __LINE__
,
634 _("gen_var_ref: LOC_CONST_BYTES symbols are not supported"));
636 /* Variable at a fixed location in memory. Easy. */
638 /* Push the address of the variable. */
639 ax_const_l (ax
, SYMBOL_VALUE_ADDRESS (var
));
640 value
->kind
= axs_lvalue_memory
;
643 case LOC_ARG
: /* var lives in argument area of frame */
644 gen_frame_args_address (gdbarch
, ax
);
645 gen_sym_offset (ax
, var
);
646 value
->kind
= axs_lvalue_memory
;
649 case LOC_REF_ARG
: /* As above, but the frame slot really
650 holds the address of the variable. */
651 gen_frame_args_address (gdbarch
, ax
);
652 gen_sym_offset (ax
, var
);
653 /* Don't assume any particular pointer size. */
654 gen_fetch (ax
, builtin_type (gdbarch
)->builtin_data_ptr
);
655 value
->kind
= axs_lvalue_memory
;
658 case LOC_LOCAL
: /* var lives in locals area of frame */
659 gen_frame_locals_address (gdbarch
, ax
);
660 gen_sym_offset (ax
, var
);
661 value
->kind
= axs_lvalue_memory
;
665 error (_("Cannot compute value of typedef `%s'."),
666 SYMBOL_PRINT_NAME (var
));
670 ax_const_l (ax
, BLOCK_START (SYMBOL_BLOCK_VALUE (var
)));
671 value
->kind
= axs_rvalue
;
675 /* Don't generate any code at all; in the process of treating
676 this as an lvalue or rvalue, the caller will generate the
678 value
->kind
= axs_lvalue_register
;
679 value
->u
.reg
= SYMBOL_REGISTER_OPS (var
)->register_number (var
, gdbarch
);
682 /* A lot like LOC_REF_ARG, but the pointer lives directly in a
683 register, not on the stack. Simpler than LOC_REGISTER
684 because it's just like any other case where the thing
685 has a real address. */
686 case LOC_REGPARM_ADDR
:
687 ax_reg (ax
, SYMBOL_REGISTER_OPS (var
)->register_number (var
, gdbarch
));
688 value
->kind
= axs_lvalue_memory
;
693 struct minimal_symbol
*msym
694 = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var
), NULL
, NULL
);
696 error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var
));
698 /* Push the address of the variable. */
699 ax_const_l (ax
, SYMBOL_VALUE_ADDRESS (msym
));
700 value
->kind
= axs_lvalue_memory
;
705 /* FIXME: cagney/2004-01-26: It should be possible to
706 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
707 Unfortunately DWARF 2 stores the frame-base (instead of the
708 function) location in a function's symbol. Oops! For the
709 moment enable this when/where applicable. */
710 SYMBOL_COMPUTED_OPS (var
)->tracepoint_var_ref (var
, gdbarch
, ax
, value
);
713 case LOC_OPTIMIZED_OUT
:
714 /* Flag this, but don't say anything; leave it up to callers to
716 value
->optimized_out
= 1;
720 error (_("Cannot find value of botched symbol `%s'."),
721 SYMBOL_PRINT_NAME (var
));
728 /* Generating bytecode from GDB expressions: literals */
731 gen_int_literal (struct agent_expr
*ax
, struct axs_value
*value
, LONGEST k
,
735 value
->kind
= axs_rvalue
;
736 value
->type
= check_typedef (type
);
741 /* Generating bytecode from GDB expressions: unary conversions, casts */
743 /* Take what's on the top of the stack (as described by VALUE), and
744 try to make an rvalue out of it. Signal an error if we can't do
747 require_rvalue (struct agent_expr
*ax
, struct axs_value
*value
)
749 /* Only deal with scalars, structs and such may be too large
750 to fit in a stack entry. */
751 value
->type
= check_typedef (value
->type
);
752 if (TYPE_CODE (value
->type
) == TYPE_CODE_ARRAY
753 || TYPE_CODE (value
->type
) == TYPE_CODE_STRUCT
754 || TYPE_CODE (value
->type
) == TYPE_CODE_UNION
755 || TYPE_CODE (value
->type
) == TYPE_CODE_FUNC
)
756 error (_("Value not scalar: cannot be an rvalue."));
761 /* It's already an rvalue. */
764 case axs_lvalue_memory
:
765 /* The top of stack is the address of the object. Dereference. */
766 gen_fetch (ax
, value
->type
);
769 case axs_lvalue_register
:
770 /* There's nothing on the stack, but value->u.reg is the
771 register number containing the value.
773 When we add floating-point support, this is going to have to
774 change. What about SPARC register pairs, for example? */
775 ax_reg (ax
, value
->u
.reg
);
776 gen_extend (ax
, value
->type
);
780 value
->kind
= axs_rvalue
;
784 /* Assume the top of the stack is described by VALUE, and perform the
785 usual unary conversions. This is motivated by ANSI 6.2.2, but of
786 course GDB expressions are not ANSI; they're the mishmash union of
787 a bunch of languages. Rah.
789 NOTE! This function promises to produce an rvalue only when the
790 incoming value is of an appropriate type. In other words, the
791 consumer of the value this function produces may assume the value
792 is an rvalue only after checking its type.
794 The immediate issue is that if the user tries to use a structure or
795 union as an operand of, say, the `+' operator, we don't want to try
796 to convert that structure to an rvalue; require_rvalue will bomb on
797 structs and unions. Rather, we want to simply pass the struct
798 lvalue through unchanged, and let `+' raise an error. */
801 gen_usual_unary (struct expression
*exp
, struct agent_expr
*ax
,
802 struct axs_value
*value
)
804 /* We don't have to generate any code for the usual integral
805 conversions, since values are always represented as full-width on
806 the stack. Should we tweak the type? */
808 /* Some types require special handling. */
809 switch (TYPE_CODE (value
->type
))
811 /* Functions get converted to a pointer to the function. */
813 value
->type
= lookup_pointer_type (value
->type
);
814 value
->kind
= axs_rvalue
; /* Should always be true, but just in case. */
817 /* Arrays get converted to a pointer to their first element, and
818 are no longer an lvalue. */
819 case TYPE_CODE_ARRAY
:
821 struct type
*elements
= TYPE_TARGET_TYPE (value
->type
);
822 value
->type
= lookup_pointer_type (elements
);
823 value
->kind
= axs_rvalue
;
824 /* We don't need to generate any code; the address of the array
825 is also the address of its first element. */
829 /* Don't try to convert structures and unions to rvalues. Let the
830 consumer signal an error. */
831 case TYPE_CODE_STRUCT
:
832 case TYPE_CODE_UNION
:
835 /* If the value is an enum or a bool, call it an integer. */
838 value
->type
= builtin_type (exp
->gdbarch
)->builtin_int
;
842 /* If the value is an lvalue, dereference it. */
843 require_rvalue (ax
, value
);
847 /* Return non-zero iff the type TYPE1 is considered "wider" than the
848 type TYPE2, according to the rules described in gen_usual_arithmetic. */
850 type_wider_than (struct type
*type1
, struct type
*type2
)
852 return (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
)
853 || (TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
854 && TYPE_UNSIGNED (type1
)
855 && !TYPE_UNSIGNED (type2
)));
859 /* Return the "wider" of the two types TYPE1 and TYPE2. */
861 max_type (struct type
*type1
, struct type
*type2
)
863 return type_wider_than (type1
, type2
) ? type1
: type2
;
867 /* Generate code to convert a scalar value of type FROM to type TO. */
869 gen_conversion (struct agent_expr
*ax
, struct type
*from
, struct type
*to
)
871 /* Perhaps there is a more graceful way to state these rules. */
873 /* If we're converting to a narrower type, then we need to clear out
875 if (TYPE_LENGTH (to
) < TYPE_LENGTH (from
))
876 gen_extend (ax
, from
);
878 /* If the two values have equal width, but different signednesses,
879 then we need to extend. */
880 else if (TYPE_LENGTH (to
) == TYPE_LENGTH (from
))
882 if (TYPE_UNSIGNED (from
) != TYPE_UNSIGNED (to
))
886 /* If we're converting to a wider type, and becoming unsigned, then
887 we need to zero out any possible sign bits. */
888 else if (TYPE_LENGTH (to
) > TYPE_LENGTH (from
))
890 if (TYPE_UNSIGNED (to
))
896 /* Return non-zero iff the type FROM will require any bytecodes to be
897 emitted to be converted to the type TO. */
899 is_nontrivial_conversion (struct type
*from
, struct type
*to
)
901 struct agent_expr
*ax
= new_agent_expr (0);
904 /* Actually generate the code, and see if anything came out. At the
905 moment, it would be trivial to replicate the code in
906 gen_conversion here, but in the future, when we're supporting
907 floating point and the like, it may not be. Doing things this
908 way allows this function to be independent of the logic in
910 gen_conversion (ax
, from
, to
);
911 nontrivial
= ax
->len
> 0;
912 free_agent_expr (ax
);
917 /* Generate code to perform the "usual arithmetic conversions" (ANSI C
918 6.2.1.5) for the two operands of an arithmetic operator. This
919 effectively finds a "least upper bound" type for the two arguments,
920 and promotes each argument to that type. *VALUE1 and *VALUE2
921 describe the values as they are passed in, and as they are left. */
923 gen_usual_arithmetic (struct expression
*exp
, struct agent_expr
*ax
,
924 struct axs_value
*value1
, struct axs_value
*value2
)
926 /* Do the usual binary conversions. */
927 if (TYPE_CODE (value1
->type
) == TYPE_CODE_INT
928 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
930 /* The ANSI integral promotions seem to work this way: Order the
931 integer types by size, and then by signedness: an n-bit
932 unsigned type is considered "wider" than an n-bit signed
933 type. Promote to the "wider" of the two types, and always
934 promote at least to int. */
935 struct type
*target
= max_type (builtin_type (exp
->gdbarch
)->builtin_int
,
936 max_type (value1
->type
, value2
->type
));
938 /* Deal with value2, on the top of the stack. */
939 gen_conversion (ax
, value2
->type
, target
);
941 /* Deal with value1, not on the top of the stack. Don't
942 generate the `swap' instructions if we're not actually going
944 if (is_nontrivial_conversion (value1
->type
, target
))
946 ax_simple (ax
, aop_swap
);
947 gen_conversion (ax
, value1
->type
, target
);
948 ax_simple (ax
, aop_swap
);
951 value1
->type
= value2
->type
= check_typedef (target
);
956 /* Generate code to perform the integral promotions (ANSI 6.2.1.1) on
957 the value on the top of the stack, as described by VALUE. Assume
958 the value has integral type. */
960 gen_integral_promotions (struct expression
*exp
, struct agent_expr
*ax
,
961 struct axs_value
*value
)
963 const struct builtin_type
*builtin
= builtin_type (exp
->gdbarch
);
965 if (!type_wider_than (value
->type
, builtin
->builtin_int
))
967 gen_conversion (ax
, value
->type
, builtin
->builtin_int
);
968 value
->type
= builtin
->builtin_int
;
970 else if (!type_wider_than (value
->type
, builtin
->builtin_unsigned_int
))
972 gen_conversion (ax
, value
->type
, builtin
->builtin_unsigned_int
);
973 value
->type
= builtin
->builtin_unsigned_int
;
978 /* Generate code for a cast to TYPE. */
980 gen_cast (struct agent_expr
*ax
, struct axs_value
*value
, struct type
*type
)
982 /* GCC does allow casts to yield lvalues, so this should be fixed
983 before merging these changes into the trunk. */
984 require_rvalue (ax
, value
);
985 /* Dereference typedefs. */
986 type
= check_typedef (type
);
988 switch (TYPE_CODE (type
))
992 /* It's implementation-defined, and I'll bet this is what GCC
996 case TYPE_CODE_ARRAY
:
997 case TYPE_CODE_STRUCT
:
998 case TYPE_CODE_UNION
:
1000 error (_("Invalid type cast: intended type must be scalar."));
1002 case TYPE_CODE_ENUM
:
1003 case TYPE_CODE_BOOL
:
1004 /* We don't have to worry about the size of the value, because
1005 all our integral values are fully sign-extended, and when
1006 casting pointers we can do anything we like. Is there any
1007 way for us to know what GCC actually does with a cast like
1012 gen_conversion (ax
, value
->type
, type
);
1015 case TYPE_CODE_VOID
:
1016 /* We could pop the value, and rely on everyone else to check
1017 the type and notice that this value doesn't occupy a stack
1018 slot. But for now, leave the value on the stack, and
1019 preserve the "value == stack element" assumption. */
1023 error (_("Casts to requested type are not yet implemented."));
1031 /* Generating bytecode from GDB expressions: arithmetic */
1033 /* Scale the integer on the top of the stack by the size of the target
1034 of the pointer type TYPE. */
1036 gen_scale (struct agent_expr
*ax
, enum agent_op op
, struct type
*type
)
1038 struct type
*element
= TYPE_TARGET_TYPE (type
);
1040 if (TYPE_LENGTH (element
) != 1)
1042 ax_const_l (ax
, TYPE_LENGTH (element
));
1048 /* Generate code for pointer arithmetic PTR + INT. */
1050 gen_ptradd (struct agent_expr
*ax
, struct axs_value
*value
,
1051 struct axs_value
*value1
, struct axs_value
*value2
)
1053 gdb_assert (pointer_type (value1
->type
));
1054 gdb_assert (TYPE_CODE (value2
->type
) == TYPE_CODE_INT
);
1056 gen_scale (ax
, aop_mul
, value1
->type
);
1057 ax_simple (ax
, aop_add
);
1058 gen_extend (ax
, value1
->type
); /* Catch overflow. */
1059 value
->type
= value1
->type
;
1060 value
->kind
= axs_rvalue
;
1064 /* Generate code for pointer arithmetic PTR - INT. */
1066 gen_ptrsub (struct agent_expr
*ax
, struct axs_value
*value
,
1067 struct axs_value
*value1
, struct axs_value
*value2
)
1069 gdb_assert (pointer_type (value1
->type
));
1070 gdb_assert (TYPE_CODE (value2
->type
) == TYPE_CODE_INT
);
1072 gen_scale (ax
, aop_mul
, value1
->type
);
1073 ax_simple (ax
, aop_sub
);
1074 gen_extend (ax
, value1
->type
); /* Catch overflow. */
1075 value
->type
= value1
->type
;
1076 value
->kind
= axs_rvalue
;
1080 /* Generate code for pointer arithmetic PTR - PTR. */
1082 gen_ptrdiff (struct agent_expr
*ax
, struct axs_value
*value
,
1083 struct axs_value
*value1
, struct axs_value
*value2
,
1084 struct type
*result_type
)
1086 gdb_assert (pointer_type (value1
->type
));
1087 gdb_assert (pointer_type (value2
->type
));
1089 if (TYPE_LENGTH (TYPE_TARGET_TYPE (value1
->type
))
1090 != TYPE_LENGTH (TYPE_TARGET_TYPE (value2
->type
)))
1092 First argument of `-' is a pointer, but second argument is neither\n\
1093 an integer nor a pointer of the same type."));
1095 ax_simple (ax
, aop_sub
);
1096 gen_scale (ax
, aop_div_unsigned
, value1
->type
);
1097 value
->type
= result_type
;
1098 value
->kind
= axs_rvalue
;
1102 gen_equal (struct agent_expr
*ax
, struct axs_value
*value
,
1103 struct axs_value
*value1
, struct axs_value
*value2
,
1104 struct type
*result_type
)
1106 if (pointer_type (value1
->type
) || pointer_type (value2
->type
))
1107 ax_simple (ax
, aop_equal
);
1109 gen_binop (ax
, value
, value1
, value2
,
1110 aop_equal
, aop_equal
, 0, "equal");
1111 value
->type
= result_type
;
1112 value
->kind
= axs_rvalue
;
1116 gen_less (struct agent_expr
*ax
, struct axs_value
*value
,
1117 struct axs_value
*value1
, struct axs_value
*value2
,
1118 struct type
*result_type
)
1120 if (pointer_type (value1
->type
) || pointer_type (value2
->type
))
1121 ax_simple (ax
, aop_less_unsigned
);
1123 gen_binop (ax
, value
, value1
, value2
,
1124 aop_less_signed
, aop_less_unsigned
, 0, "less than");
1125 value
->type
= result_type
;
1126 value
->kind
= axs_rvalue
;
1129 /* Generate code for a binary operator that doesn't do pointer magic.
1130 We set VALUE to describe the result value; we assume VALUE1 and
1131 VALUE2 describe the two operands, and that they've undergone the
1132 usual binary conversions. MAY_CARRY should be non-zero iff the
1133 result needs to be extended. NAME is the English name of the
1134 operator, used in error messages */
1136 gen_binop (struct agent_expr
*ax
, struct axs_value
*value
,
1137 struct axs_value
*value1
, struct axs_value
*value2
, enum agent_op op
,
1138 enum agent_op op_unsigned
, int may_carry
, char *name
)
1140 /* We only handle INT op INT. */
1141 if ((TYPE_CODE (value1
->type
) != TYPE_CODE_INT
)
1142 || (TYPE_CODE (value2
->type
) != TYPE_CODE_INT
))
1143 error (_("Invalid combination of types in %s."), name
);
1146 TYPE_UNSIGNED (value1
->type
) ? op_unsigned
: op
);
1148 gen_extend (ax
, value1
->type
); /* catch overflow */
1149 value
->type
= value1
->type
;
1150 value
->kind
= axs_rvalue
;
1155 gen_logical_not (struct agent_expr
*ax
, struct axs_value
*value
,
1156 struct type
*result_type
)
1158 if (TYPE_CODE (value
->type
) != TYPE_CODE_INT
1159 && TYPE_CODE (value
->type
) != TYPE_CODE_PTR
)
1160 error (_("Invalid type of operand to `!'."));
1162 ax_simple (ax
, aop_log_not
);
1163 value
->type
= result_type
;
1168 gen_complement (struct agent_expr
*ax
, struct axs_value
*value
)
1170 if (TYPE_CODE (value
->type
) != TYPE_CODE_INT
)
1171 error (_("Invalid type of operand to `~'."));
1173 ax_simple (ax
, aop_bit_not
);
1174 gen_extend (ax
, value
->type
);
1179 /* Generating bytecode from GDB expressions: * & . -> @ sizeof */
1181 /* Dereference the value on the top of the stack. */
1183 gen_deref (struct agent_expr
*ax
, struct axs_value
*value
)
1185 /* The caller should check the type, because several operators use
1186 this, and we don't know what error message to generate. */
1187 if (!pointer_type (value
->type
))
1188 internal_error (__FILE__
, __LINE__
,
1189 _("gen_deref: expected a pointer"));
1191 /* We've got an rvalue now, which is a pointer. We want to yield an
1192 lvalue, whose address is exactly that pointer. So we don't
1193 actually emit any code; we just change the type from "Pointer to
1194 T" to "T", and mark the value as an lvalue in memory. Leave it
1195 to the consumer to actually dereference it. */
1196 value
->type
= check_typedef (TYPE_TARGET_TYPE (value
->type
));
1197 if (TYPE_CODE (value
->type
) == TYPE_CODE_VOID
)
1198 error (_("Attempt to dereference a generic pointer."));
1199 value
->kind
= ((TYPE_CODE (value
->type
) == TYPE_CODE_FUNC
)
1200 ? axs_rvalue
: axs_lvalue_memory
);
1204 /* Produce the address of the lvalue on the top of the stack. */
1206 gen_address_of (struct agent_expr
*ax
, struct axs_value
*value
)
1208 /* Special case for taking the address of a function. The ANSI
1209 standard describes this as a special case, too, so this
1210 arrangement is not without motivation. */
1211 if (TYPE_CODE (value
->type
) == TYPE_CODE_FUNC
)
1212 /* The value's already an rvalue on the stack, so we just need to
1214 value
->type
= lookup_pointer_type (value
->type
);
1216 switch (value
->kind
)
1219 error (_("Operand of `&' is an rvalue, which has no address."));
1221 case axs_lvalue_register
:
1222 error (_("Operand of `&' is in a register, and has no address."));
1224 case axs_lvalue_memory
:
1225 value
->kind
= axs_rvalue
;
1226 value
->type
= lookup_pointer_type (value
->type
);
1231 /* Generate code to push the value of a bitfield of a structure whose
1232 address is on the top of the stack. START and END give the
1233 starting and one-past-ending *bit* numbers of the field within the
1236 gen_bitfield_ref (struct expression
*exp
, struct agent_expr
*ax
,
1237 struct axs_value
*value
, struct type
*type
,
1240 /* Note that ops[i] fetches 8 << i bits. */
1241 static enum agent_op ops
[]
1243 {aop_ref8
, aop_ref16
, aop_ref32
, aop_ref64
};
1244 static int num_ops
= (sizeof (ops
) / sizeof (ops
[0]));
1246 /* We don't want to touch any byte that the bitfield doesn't
1247 actually occupy; we shouldn't make any accesses we're not
1248 explicitly permitted to. We rely here on the fact that the
1249 bytecode `ref' operators work on unaligned addresses.
1251 It takes some fancy footwork to get the stack to work the way
1252 we'd like. Say we're retrieving a bitfield that requires three
1253 fetches. Initially, the stack just contains the address:
1255 For the first fetch, we duplicate the address
1257 then add the byte offset, do the fetch, and shift and mask as
1258 needed, yielding a fragment of the value, properly aligned for
1259 the final bitwise or:
1261 then we swap, and repeat the process:
1262 frag1 addr --- address on top
1263 frag1 addr addr --- duplicate it
1264 frag1 addr frag2 --- get second fragment
1265 frag1 frag2 addr --- swap again
1266 frag1 frag2 frag3 --- get third fragment
1267 Notice that, since the third fragment is the last one, we don't
1268 bother duplicating the address this time. Now we have all the
1269 fragments on the stack, and we can simply `or' them together,
1270 yielding the final value of the bitfield. */
1272 /* The first and one-after-last bits in the field, but rounded down
1273 and up to byte boundaries. */
1274 int bound_start
= (start
/ TARGET_CHAR_BIT
) * TARGET_CHAR_BIT
;
1275 int bound_end
= (((end
+ TARGET_CHAR_BIT
- 1)
1279 /* current bit offset within the structure */
1282 /* The index in ops of the opcode we're considering. */
1285 /* The number of fragments we generated in the process. Probably
1286 equal to the number of `one' bits in bytesize, but who cares? */
1289 /* Dereference any typedefs. */
1290 type
= check_typedef (type
);
1292 /* Can we fetch the number of bits requested at all? */
1293 if ((end
- start
) > ((1 << num_ops
) * 8))
1294 internal_error (__FILE__
, __LINE__
,
1295 _("gen_bitfield_ref: bitfield too wide"));
1297 /* Note that we know here that we only need to try each opcode once.
1298 That may not be true on machines with weird byte sizes. */
1299 offset
= bound_start
;
1301 for (op
= num_ops
- 1; op
>= 0; op
--)
1303 /* number of bits that ops[op] would fetch */
1304 int op_size
= 8 << op
;
1306 /* The stack at this point, from bottom to top, contains zero or
1307 more fragments, then the address. */
1309 /* Does this fetch fit within the bitfield? */
1310 if (offset
+ op_size
<= bound_end
)
1312 /* Is this the last fragment? */
1313 int last_frag
= (offset
+ op_size
== bound_end
);
1316 ax_simple (ax
, aop_dup
); /* keep a copy of the address */
1318 /* Add the offset. */
1319 gen_offset (ax
, offset
/ TARGET_CHAR_BIT
);
1323 /* Record the area of memory we're about to fetch. */
1324 ax_trace_quick (ax
, op_size
/ TARGET_CHAR_BIT
);
1327 /* Perform the fetch. */
1328 ax_simple (ax
, ops
[op
]);
1330 /* Shift the bits we have to their proper position.
1331 gen_left_shift will generate right shifts when the operand
1334 A big-endian field diagram to ponder:
1335 byte 0 byte 1 byte 2 byte 3 byte 4 byte 5 byte 6 byte 7
1336 +------++------++------++------++------++------++------++------+
1337 xxxxAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCxxxxxxxxxxx
1339 bit number 16 32 48 53
1340 These are bit numbers as supplied by GDB. Note that the
1341 bit numbers run from right to left once you've fetched the
1344 A little-endian field diagram to ponder:
1345 byte 7 byte 6 byte 5 byte 4 byte 3 byte 2 byte 1 byte 0
1346 +------++------++------++------++------++------++------++------+
1347 xxxxxxxxxxxAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCxxxx
1349 bit number 48 32 16 4 0
1351 In both cases, the most significant end is on the left
1352 (i.e. normal numeric writing order), which means that you
1353 don't go crazy thinking about `left' and `right' shifts.
1355 We don't have to worry about masking yet:
1356 - If they contain garbage off the least significant end, then we
1357 must be looking at the low end of the field, and the right
1358 shift will wipe them out.
1359 - If they contain garbage off the most significant end, then we
1360 must be looking at the most significant end of the word, and
1361 the sign/zero extension will wipe them out.
1362 - If we're in the interior of the word, then there is no garbage
1363 on either end, because the ref operators zero-extend. */
1364 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
1365 gen_left_shift (ax
, end
- (offset
+ op_size
));
1367 gen_left_shift (ax
, offset
- start
);
1370 /* Bring the copy of the address up to the top. */
1371 ax_simple (ax
, aop_swap
);
1378 /* Generate enough bitwise `or' operations to combine all the
1379 fragments we left on the stack. */
1380 while (fragment_count
-- > 1)
1381 ax_simple (ax
, aop_bit_or
);
1383 /* Sign- or zero-extend the value as appropriate. */
1384 ((TYPE_UNSIGNED (type
) ? ax_zero_ext
: ax_ext
) (ax
, end
- start
));
1386 /* This is *not* an lvalue. Ugh. */
1387 value
->kind
= axs_rvalue
;
1391 /* Generate bytecodes for field number FIELDNO of type TYPE. OFFSET
1392 is an accumulated offset (in bytes), will be nonzero for objects
1393 embedded in other objects, like C++ base classes. Behavior should
1394 generally follow value_primitive_field. */
1397 gen_primitive_field (struct expression
*exp
,
1398 struct agent_expr
*ax
, struct axs_value
*value
,
1399 int offset
, int fieldno
, struct type
*type
)
1401 /* Is this a bitfield? */
1402 if (TYPE_FIELD_PACKED (type
, fieldno
))
1403 gen_bitfield_ref (exp
, ax
, value
, TYPE_FIELD_TYPE (type
, fieldno
),
1404 (offset
* TARGET_CHAR_BIT
1405 + TYPE_FIELD_BITPOS (type
, fieldno
)),
1406 (offset
* TARGET_CHAR_BIT
1407 + TYPE_FIELD_BITPOS (type
, fieldno
)
1408 + TYPE_FIELD_BITSIZE (type
, fieldno
)));
1411 gen_offset (ax
, offset
1412 + TYPE_FIELD_BITPOS (type
, fieldno
) / TARGET_CHAR_BIT
);
1413 value
->kind
= axs_lvalue_memory
;
1414 value
->type
= TYPE_FIELD_TYPE (type
, fieldno
);
1418 /* Search for the given field in either the given type or one of its
1419 base classes. Return 1 if found, 0 if not. */
1422 gen_struct_ref_recursive (struct expression
*exp
, struct agent_expr
*ax
,
1423 struct axs_value
*value
,
1424 char *field
, int offset
, struct type
*type
)
1427 int nbases
= TYPE_N_BASECLASSES (type
);
1429 CHECK_TYPEDEF (type
);
1431 for (i
= TYPE_NFIELDS (type
) - 1; i
>= nbases
; i
--)
1433 char *this_name
= TYPE_FIELD_NAME (type
, i
);
1437 if (strcmp (field
, this_name
) == 0)
1439 /* Note that bytecodes for the struct's base (aka
1440 "this") will have been generated already, which will
1441 be unnecessary but not harmful if the static field is
1442 being handled as a global. */
1443 if (field_is_static (&TYPE_FIELD (type
, i
)))
1445 gen_static_field (exp
->gdbarch
, ax
, value
, type
, i
);
1446 if (value
->optimized_out
)
1447 error (_("static field `%s' has been optimized out, cannot use"),
1452 gen_primitive_field (exp
, ax
, value
, offset
, i
, type
);
1455 #if 0 /* is this right? */
1456 if (this_name
[0] == '\0')
1457 internal_error (__FILE__
, __LINE__
,
1458 _("find_field: anonymous unions not supported"));
1463 /* Now scan through base classes recursively. */
1464 for (i
= 0; i
< nbases
; i
++)
1466 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
1468 rslt
= gen_struct_ref_recursive (exp
, ax
, value
, field
,
1469 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / TARGET_CHAR_BIT
,
1475 /* Not found anywhere, flag so caller can complain. */
1479 /* Generate code to reference the member named FIELD of a structure or
1480 union. The top of the stack, as described by VALUE, should have
1481 type (pointer to a)* struct/union. OPERATOR_NAME is the name of
1482 the operator being compiled, and OPERAND_NAME is the kind of thing
1483 it operates on; we use them in error messages. */
1485 gen_struct_ref (struct expression
*exp
, struct agent_expr
*ax
,
1486 struct axs_value
*value
, char *field
,
1487 char *operator_name
, char *operand_name
)
1492 /* Follow pointers until we reach a non-pointer. These aren't the C
1493 semantics, but they're what the normal GDB evaluator does, so we
1494 should at least be consistent. */
1495 while (pointer_type (value
->type
))
1497 require_rvalue (ax
, value
);
1498 gen_deref (ax
, value
);
1500 type
= check_typedef (value
->type
);
1502 /* This must yield a structure or a union. */
1503 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1504 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1505 error (_("The left operand of `%s' is not a %s."),
1506 operator_name
, operand_name
);
1508 /* And it must be in memory; we don't deal with structure rvalues,
1509 or structures living in registers. */
1510 if (value
->kind
!= axs_lvalue_memory
)
1511 error (_("Structure does not live in memory."));
1513 /* Search through fields and base classes recursively. */
1514 found
= gen_struct_ref_recursive (exp
, ax
, value
, field
, 0, type
);
1517 error (_("Couldn't find member named `%s' in struct/union/class `%s'"),
1518 field
, TYPE_TAG_NAME (type
));
1522 gen_namespace_elt (struct expression
*exp
,
1523 struct agent_expr
*ax
, struct axs_value
*value
,
1524 const struct type
*curtype
, char *name
);
1526 gen_maybe_namespace_elt (struct expression
*exp
,
1527 struct agent_expr
*ax
, struct axs_value
*value
,
1528 const struct type
*curtype
, char *name
);
1531 gen_static_field (struct gdbarch
*gdbarch
,
1532 struct agent_expr
*ax
, struct axs_value
*value
,
1533 struct type
*type
, int fieldno
)
1535 if (TYPE_FIELD_LOC_KIND (type
, fieldno
) == FIELD_LOC_KIND_PHYSADDR
)
1537 ax_const_l (ax
, TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
));
1538 value
->kind
= axs_lvalue_memory
;
1539 value
->type
= TYPE_FIELD_TYPE (type
, fieldno
);
1540 value
->optimized_out
= 0;
1544 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
1545 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_DOMAIN
, 0);
1549 gen_var_ref (gdbarch
, ax
, value
, sym
);
1551 /* Don't error if the value was optimized out, we may be
1552 scanning all static fields and just want to pass over this
1553 and continue with the rest. */
1557 /* Silently assume this was optimized out; class printing
1558 will let the user know why the data is missing. */
1559 value
->optimized_out
= 1;
1565 gen_struct_elt_for_reference (struct expression
*exp
,
1566 struct agent_expr
*ax
, struct axs_value
*value
,
1567 struct type
*type
, char *fieldname
)
1569 struct type
*t
= type
;
1571 struct value
*v
, *result
;
1573 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1574 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1575 internal_error (__FILE__
, __LINE__
,
1576 _("non-aggregate type to gen_struct_elt_for_reference"));
1578 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
1580 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
1582 if (t_field_name
&& strcmp (t_field_name
, fieldname
) == 0)
1584 if (field_is_static (&TYPE_FIELD (t
, i
)))
1586 gen_static_field (exp
->gdbarch
, ax
, value
, t
, i
);
1587 if (value
->optimized_out
)
1588 error (_("static field `%s' has been optimized out, cannot use"),
1592 if (TYPE_FIELD_PACKED (t
, i
))
1593 error (_("pointers to bitfield members not allowed"));
1595 /* FIXME we need a way to do "want_address" equivalent */
1597 error (_("Cannot reference non-static field \"%s\""), fieldname
);
1601 /* FIXME add other scoped-reference cases here */
1603 /* Do a last-ditch lookup. */
1604 return gen_maybe_namespace_elt (exp
, ax
, value
, type
, fieldname
);
1607 /* C++: Return the member NAME of the namespace given by the type
1611 gen_namespace_elt (struct expression
*exp
,
1612 struct agent_expr
*ax
, struct axs_value
*value
,
1613 const struct type
*curtype
, char *name
)
1615 int found
= gen_maybe_namespace_elt (exp
, ax
, value
, curtype
, name
);
1618 error (_("No symbol \"%s\" in namespace \"%s\"."),
1619 name
, TYPE_TAG_NAME (curtype
));
1624 /* A helper function used by value_namespace_elt and
1625 value_struct_elt_for_reference. It looks up NAME inside the
1626 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
1627 is a class and NAME refers to a type in CURTYPE itself (as opposed
1628 to, say, some base class of CURTYPE). */
1631 gen_maybe_namespace_elt (struct expression
*exp
,
1632 struct agent_expr
*ax
, struct axs_value
*value
,
1633 const struct type
*curtype
, char *name
)
1635 const char *namespace_name
= TYPE_TAG_NAME (curtype
);
1638 sym
= cp_lookup_symbol_namespace (namespace_name
, name
,
1639 block_for_pc (ax
->scope
),
1645 gen_var_ref (exp
->gdbarch
, ax
, value
, sym
);
1647 if (value
->optimized_out
)
1648 error (_("`%s' has been optimized out, cannot use"),
1649 SYMBOL_PRINT_NAME (sym
));
1656 gen_aggregate_elt_ref (struct expression
*exp
,
1657 struct agent_expr
*ax
, struct axs_value
*value
,
1658 struct type
*type
, char *field
,
1659 char *operator_name
, char *operand_name
)
1661 switch (TYPE_CODE (type
))
1663 case TYPE_CODE_STRUCT
:
1664 case TYPE_CODE_UNION
:
1665 return gen_struct_elt_for_reference (exp
, ax
, value
, type
, field
);
1667 case TYPE_CODE_NAMESPACE
:
1668 return gen_namespace_elt (exp
, ax
, value
, type
, field
);
1671 internal_error (__FILE__
, __LINE__
,
1672 _("non-aggregate type in gen_aggregate_elt_ref"));
1678 /* Generate code for GDB's magical `repeat' operator.
1679 LVALUE @ INT creates an array INT elements long, and whose elements
1680 have the same type as LVALUE, located in memory so that LVALUE is
1681 its first element. For example, argv[0]@argc gives you the array
1682 of command-line arguments.
1684 Unfortunately, because we have to know the types before we actually
1685 have a value for the expression, we can't implement this perfectly
1686 without changing the type system, having values that occupy two
1687 stack slots, doing weird things with sizeof, etc. So we require
1688 the right operand to be a constant expression. */
1690 gen_repeat (struct expression
*exp
, union exp_element
**pc
,
1691 struct agent_expr
*ax
, struct axs_value
*value
)
1693 struct axs_value value1
;
1694 /* We don't want to turn this into an rvalue, so no conversions
1696 gen_expr (exp
, pc
, ax
, &value1
);
1697 if (value1
.kind
!= axs_lvalue_memory
)
1698 error (_("Left operand of `@' must be an object in memory."));
1700 /* Evaluate the length; it had better be a constant. */
1702 struct value
*v
= const_expr (pc
);
1706 error (_("Right operand of `@' must be a constant, in agent expressions."));
1707 if (TYPE_CODE (value_type (v
)) != TYPE_CODE_INT
)
1708 error (_("Right operand of `@' must be an integer."));
1709 length
= value_as_long (v
);
1711 error (_("Right operand of `@' must be positive."));
1713 /* The top of the stack is already the address of the object, so
1714 all we need to do is frob the type of the lvalue. */
1716 /* FIXME-type-allocation: need a way to free this type when we are
1719 = lookup_array_range_type (value1
.type
, 0, length
- 1);
1721 value
->kind
= axs_lvalue_memory
;
1722 value
->type
= array
;
1728 /* Emit code for the `sizeof' operator.
1729 *PC should point at the start of the operand expression; we advance it
1730 to the first instruction after the operand. */
1732 gen_sizeof (struct expression
*exp
, union exp_element
**pc
,
1733 struct agent_expr
*ax
, struct axs_value
*value
,
1734 struct type
*size_type
)
1736 /* We don't care about the value of the operand expression; we only
1737 care about its type. However, in the current arrangement, the
1738 only way to find an expression's type is to generate code for it.
1739 So we generate code for the operand, and then throw it away,
1740 replacing it with code that simply pushes its size. */
1741 int start
= ax
->len
;
1742 gen_expr (exp
, pc
, ax
, value
);
1744 /* Throw away the code we just generated. */
1747 ax_const_l (ax
, TYPE_LENGTH (value
->type
));
1748 value
->kind
= axs_rvalue
;
1749 value
->type
= size_type
;
1753 /* Generating bytecode from GDB expressions: general recursive thingy */
1756 /* A gen_expr function written by a Gen-X'er guy.
1757 Append code for the subexpression of EXPR starting at *POS_P to AX. */
1759 gen_expr (struct expression
*exp
, union exp_element
**pc
,
1760 struct agent_expr
*ax
, struct axs_value
*value
)
1762 /* Used to hold the descriptions of operand expressions. */
1763 struct axs_value value1
, value2
, value3
;
1764 enum exp_opcode op
= (*pc
)[0].opcode
, op2
;
1765 int if1
, go1
, if2
, go2
, end
;
1766 struct type
*int_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
1768 /* If we're looking at a constant expression, just push its value. */
1770 struct value
*v
= maybe_const_expr (pc
);
1774 ax_const_l (ax
, value_as_long (v
));
1775 value
->kind
= axs_rvalue
;
1776 value
->type
= check_typedef (value_type (v
));
1781 /* Otherwise, go ahead and generate code for it. */
1784 /* Binary arithmetic operators. */
1792 case BINOP_SUBSCRIPT
:
1793 case BINOP_BITWISE_AND
:
1794 case BINOP_BITWISE_IOR
:
1795 case BINOP_BITWISE_XOR
:
1797 case BINOP_NOTEQUAL
:
1803 gen_expr (exp
, pc
, ax
, &value1
);
1804 gen_usual_unary (exp
, ax
, &value1
);
1805 gen_expr_binop_rest (exp
, op
, pc
, ax
, value
, &value1
, &value2
);
1808 case BINOP_LOGICAL_AND
:
1810 /* Generate the obvious sequence of tests and jumps. */
1811 gen_expr (exp
, pc
, ax
, &value1
);
1812 gen_usual_unary (exp
, ax
, &value1
);
1813 if1
= ax_goto (ax
, aop_if_goto
);
1814 go1
= ax_goto (ax
, aop_goto
);
1815 ax_label (ax
, if1
, ax
->len
);
1816 gen_expr (exp
, pc
, ax
, &value2
);
1817 gen_usual_unary (exp
, ax
, &value2
);
1818 if2
= ax_goto (ax
, aop_if_goto
);
1819 go2
= ax_goto (ax
, aop_goto
);
1820 ax_label (ax
, if2
, ax
->len
);
1822 end
= ax_goto (ax
, aop_goto
);
1823 ax_label (ax
, go1
, ax
->len
);
1824 ax_label (ax
, go2
, ax
->len
);
1826 ax_label (ax
, end
, ax
->len
);
1827 value
->kind
= axs_rvalue
;
1828 value
->type
= int_type
;
1831 case BINOP_LOGICAL_OR
:
1833 /* Generate the obvious sequence of tests and jumps. */
1834 gen_expr (exp
, pc
, ax
, &value1
);
1835 gen_usual_unary (exp
, ax
, &value1
);
1836 if1
= ax_goto (ax
, aop_if_goto
);
1837 gen_expr (exp
, pc
, ax
, &value2
);
1838 gen_usual_unary (exp
, ax
, &value2
);
1839 if2
= ax_goto (ax
, aop_if_goto
);
1841 end
= ax_goto (ax
, aop_goto
);
1842 ax_label (ax
, if1
, ax
->len
);
1843 ax_label (ax
, if2
, ax
->len
);
1845 ax_label (ax
, end
, ax
->len
);
1846 value
->kind
= axs_rvalue
;
1847 value
->type
= int_type
;
1852 gen_expr (exp
, pc
, ax
, &value1
);
1853 gen_usual_unary (exp
, ax
, &value1
);
1854 /* For (A ? B : C), it's easiest to generate subexpression
1855 bytecodes in order, but if_goto jumps on true, so we invert
1856 the sense of A. Then we can do B by dropping through, and
1858 gen_logical_not (ax
, &value1
, int_type
);
1859 if1
= ax_goto (ax
, aop_if_goto
);
1860 gen_expr (exp
, pc
, ax
, &value2
);
1861 gen_usual_unary (exp
, ax
, &value2
);
1862 end
= ax_goto (ax
, aop_goto
);
1863 ax_label (ax
, if1
, ax
->len
);
1864 gen_expr (exp
, pc
, ax
, &value3
);
1865 gen_usual_unary (exp
, ax
, &value3
);
1866 ax_label (ax
, end
, ax
->len
);
1867 /* This is arbitary - what if B and C are incompatible types? */
1868 value
->type
= value2
.type
;
1869 value
->kind
= value2
.kind
;
1874 if ((*pc
)[0].opcode
== OP_INTERNALVAR
)
1876 char *name
= internalvar_name ((*pc
)[1].internalvar
);
1877 struct trace_state_variable
*tsv
;
1879 gen_expr (exp
, pc
, ax
, value
);
1880 tsv
= find_trace_state_variable (name
);
1883 ax_tsv (ax
, aop_setv
, tsv
->number
);
1885 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1888 error (_("$%s is not a trace state variable, may not assign to it"), name
);
1891 error (_("May only assign to trace state variables"));
1894 case BINOP_ASSIGN_MODIFY
:
1896 op2
= (*pc
)[0].opcode
;
1899 if ((*pc
)[0].opcode
== OP_INTERNALVAR
)
1901 char *name
= internalvar_name ((*pc
)[1].internalvar
);
1902 struct trace_state_variable
*tsv
;
1904 tsv
= find_trace_state_variable (name
);
1907 /* The tsv will be the left half of the binary operation. */
1908 ax_tsv (ax
, aop_getv
, tsv
->number
);
1910 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1911 /* Trace state variables are always 64-bit integers. */
1912 value1
.kind
= axs_rvalue
;
1913 value1
.type
= builtin_type (exp
->gdbarch
)->builtin_long_long
;
1914 /* Now do right half of expression. */
1915 gen_expr_binop_rest (exp
, op2
, pc
, ax
, value
, &value1
, &value2
);
1916 /* We have a result of the binary op, set the tsv. */
1917 ax_tsv (ax
, aop_setv
, tsv
->number
);
1919 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1922 error (_("$%s is not a trace state variable, may not assign to it"), name
);
1925 error (_("May only assign to trace state variables"));
1928 /* Note that we need to be a little subtle about generating code
1929 for comma. In C, we can do some optimizations here because
1930 we know the left operand is only being evaluated for effect.
1931 However, if the tracing kludge is in effect, then we always
1932 need to evaluate the left hand side fully, so that all the
1933 variables it mentions get traced. */
1936 gen_expr (exp
, pc
, ax
, &value1
);
1937 /* Don't just dispose of the left operand. We might be tracing,
1938 in which case we want to emit code to trace it if it's an
1940 gen_traced_pop (exp
->gdbarch
, ax
, &value1
);
1941 gen_expr (exp
, pc
, ax
, value
);
1942 /* It's the consumer's responsibility to trace the right operand. */
1945 case OP_LONG
: /* some integer constant */
1947 struct type
*type
= (*pc
)[1].type
;
1948 LONGEST k
= (*pc
)[2].longconst
;
1950 gen_int_literal (ax
, value
, k
, type
);
1955 gen_var_ref (exp
->gdbarch
, ax
, value
, (*pc
)[2].symbol
);
1957 if (value
->optimized_out
)
1958 error (_("`%s' has been optimized out, cannot use"),
1959 SYMBOL_PRINT_NAME ((*pc
)[2].symbol
));
1966 const char *name
= &(*pc
)[2].string
;
1968 (*pc
) += 4 + BYTES_TO_EXP_ELEM ((*pc
)[1].longconst
+ 1);
1969 reg
= user_reg_map_name_to_regnum (exp
->gdbarch
, name
, strlen (name
));
1971 internal_error (__FILE__
, __LINE__
,
1972 _("Register $%s not available"), name
);
1973 if (reg
>= gdbarch_num_regs (exp
->gdbarch
))
1974 error (_("'%s' is a pseudo-register; "
1975 "GDB cannot yet trace pseudoregister contents."),
1977 value
->kind
= axs_lvalue_register
;
1979 value
->type
= register_type (exp
->gdbarch
, reg
);
1983 case OP_INTERNALVAR
:
1985 const char *name
= internalvar_name ((*pc
)[1].internalvar
);
1986 struct trace_state_variable
*tsv
;
1988 tsv
= find_trace_state_variable (name
);
1991 ax_tsv (ax
, aop_getv
, tsv
->number
);
1993 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1994 /* Trace state variables are always 64-bit integers. */
1995 value
->kind
= axs_rvalue
;
1996 value
->type
= builtin_type (exp
->gdbarch
)->builtin_long_long
;
1999 error (_("$%s is not a trace state variable; GDB agent expressions cannot use convenience variables."), name
);
2003 /* Weirdo operator: see comments for gen_repeat for details. */
2005 /* Note that gen_repeat handles its own argument evaluation. */
2007 gen_repeat (exp
, pc
, ax
, value
);
2012 struct type
*type
= (*pc
)[1].type
;
2014 gen_expr (exp
, pc
, ax
, value
);
2015 gen_cast (ax
, value
, type
);
2021 struct type
*type
= check_typedef ((*pc
)[1].type
);
2023 gen_expr (exp
, pc
, ax
, value
);
2024 /* I'm not sure I understand UNOP_MEMVAL entirely. I think
2025 it's just a hack for dealing with minsyms; you take some
2026 integer constant, pretend it's the address of an lvalue of
2027 the given type, and dereference it. */
2028 if (value
->kind
!= axs_rvalue
)
2029 /* This would be weird. */
2030 internal_error (__FILE__
, __LINE__
,
2031 _("gen_expr: OP_MEMVAL operand isn't an rvalue???"));
2033 value
->kind
= axs_lvalue_memory
;
2039 /* + FOO is equivalent to 0 + FOO, which can be optimized. */
2040 gen_expr (exp
, pc
, ax
, value
);
2041 gen_usual_unary (exp
, ax
, value
);
2046 /* -FOO is equivalent to 0 - FOO. */
2047 gen_int_literal (ax
, &value1
, 0,
2048 builtin_type (exp
->gdbarch
)->builtin_int
);
2049 gen_usual_unary (exp
, ax
, &value1
); /* shouldn't do much */
2050 gen_expr (exp
, pc
, ax
, &value2
);
2051 gen_usual_unary (exp
, ax
, &value2
);
2052 gen_usual_arithmetic (exp
, ax
, &value1
, &value2
);
2053 gen_binop (ax
, value
, &value1
, &value2
, aop_sub
, aop_sub
, 1, "negation");
2056 case UNOP_LOGICAL_NOT
:
2058 gen_expr (exp
, pc
, ax
, value
);
2059 gen_usual_unary (exp
, ax
, value
);
2060 gen_logical_not (ax
, value
, int_type
);
2063 case UNOP_COMPLEMENT
:
2065 gen_expr (exp
, pc
, ax
, value
);
2066 gen_usual_unary (exp
, ax
, value
);
2067 gen_integral_promotions (exp
, ax
, value
);
2068 gen_complement (ax
, value
);
2073 gen_expr (exp
, pc
, ax
, value
);
2074 gen_usual_unary (exp
, ax
, value
);
2075 if (!pointer_type (value
->type
))
2076 error (_("Argument of unary `*' is not a pointer."));
2077 gen_deref (ax
, value
);
2082 gen_expr (exp
, pc
, ax
, value
);
2083 gen_address_of (ax
, value
);
2088 /* Notice that gen_sizeof handles its own operand, unlike most
2089 of the other unary operator functions. This is because we
2090 have to throw away the code we generate. */
2091 gen_sizeof (exp
, pc
, ax
, value
,
2092 builtin_type (exp
->gdbarch
)->builtin_int
);
2095 case STRUCTOP_STRUCT
:
2098 int length
= (*pc
)[1].longconst
;
2099 char *name
= &(*pc
)[2].string
;
2101 (*pc
) += 4 + BYTES_TO_EXP_ELEM (length
+ 1);
2102 gen_expr (exp
, pc
, ax
, value
);
2103 if (op
== STRUCTOP_STRUCT
)
2104 gen_struct_ref (exp
, ax
, value
, name
, ".", "structure or union");
2105 else if (op
== STRUCTOP_PTR
)
2106 gen_struct_ref (exp
, ax
, value
, name
, "->",
2107 "pointer to a structure or union");
2109 /* If this `if' chain doesn't handle it, then the case list
2110 shouldn't mention it, and we shouldn't be here. */
2111 internal_error (__FILE__
, __LINE__
,
2112 _("gen_expr: unhandled struct case"));
2119 struct symbol
*func
, *sym
;
2122 func
= block_linkage_function (block_for_pc (ax
->scope
));
2123 this_name
= language_def (SYMBOL_LANGUAGE (func
))->la_name_of_this
;
2124 b
= SYMBOL_BLOCK_VALUE (func
);
2126 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
2127 symbol instead of the LOC_ARG one (if both exist). */
2128 sym
= lookup_block_symbol (b
, this_name
, VAR_DOMAIN
);
2130 error (_("no `%s' found"), this_name
);
2132 gen_var_ref (exp
->gdbarch
, ax
, value
, sym
);
2134 if (value
->optimized_out
)
2135 error (_("`%s' has been optimized out, cannot use"),
2136 SYMBOL_PRINT_NAME (sym
));
2144 struct type
*type
= (*pc
)[1].type
;
2145 int length
= longest_to_int ((*pc
)[2].longconst
);
2146 char *name
= &(*pc
)[3].string
;
2149 found
= gen_aggregate_elt_ref (exp
, ax
, value
, type
, name
,
2152 error (_("There is no field named %s"), name
);
2153 (*pc
) += 5 + BYTES_TO_EXP_ELEM (length
+ 1);
2158 error (_("Attempt to use a type name as an expression."));
2161 error (_("Unsupported operator %s (%d) in expression."),
2162 op_string (op
), op
);
2166 /* This handles the middle-to-right-side of code generation for binary
2167 expressions, which is shared between regular binary operations and
2168 assign-modify (+= and friends) expressions. */
2171 gen_expr_binop_rest (struct expression
*exp
,
2172 enum exp_opcode op
, union exp_element
**pc
,
2173 struct agent_expr
*ax
, struct axs_value
*value
,
2174 struct axs_value
*value1
, struct axs_value
*value2
)
2176 struct type
*int_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2178 gen_expr (exp
, pc
, ax
, value2
);
2179 gen_usual_unary (exp
, ax
, value2
);
2180 gen_usual_arithmetic (exp
, ax
, value1
, value2
);
2184 if (TYPE_CODE (value1
->type
) == TYPE_CODE_INT
2185 && pointer_type (value2
->type
))
2187 /* Swap the values and proceed normally. */
2188 ax_simple (ax
, aop_swap
);
2189 gen_ptradd (ax
, value
, value2
, value1
);
2191 else if (pointer_type (value1
->type
)
2192 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
2193 gen_ptradd (ax
, value
, value1
, value2
);
2195 gen_binop (ax
, value
, value1
, value2
,
2196 aop_add
, aop_add
, 1, "addition");
2199 if (pointer_type (value1
->type
)
2200 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
2201 gen_ptrsub (ax
,value
, value1
, value2
);
2202 else if (pointer_type (value1
->type
)
2203 && pointer_type (value2
->type
))
2204 /* FIXME --- result type should be ptrdiff_t */
2205 gen_ptrdiff (ax
, value
, value1
, value2
,
2206 builtin_type (exp
->gdbarch
)->builtin_long
);
2208 gen_binop (ax
, value
, value1
, value2
,
2209 aop_sub
, aop_sub
, 1, "subtraction");
2212 gen_binop (ax
, value
, value1
, value2
,
2213 aop_mul
, aop_mul
, 1, "multiplication");
2216 gen_binop (ax
, value
, value1
, value2
,
2217 aop_div_signed
, aop_div_unsigned
, 1, "division");
2220 gen_binop (ax
, value
, value1
, value2
,
2221 aop_rem_signed
, aop_rem_unsigned
, 1, "remainder");
2224 gen_binop (ax
, value
, value1
, value2
,
2225 aop_lsh
, aop_lsh
, 1, "left shift");
2228 gen_binop (ax
, value
, value1
, value2
,
2229 aop_rsh_signed
, aop_rsh_unsigned
, 1, "right shift");
2231 case BINOP_SUBSCRIPT
:
2235 if (binop_types_user_defined_p (op
, value1
->type
, value2
->type
))
2238 cannot subscript requested type: cannot call user defined functions"));
2242 /* If the user attempts to subscript something that is not
2243 an array or pointer type (like a plain int variable for
2244 example), then report this as an error. */
2245 type
= check_typedef (value1
->type
);
2246 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2247 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2249 if (TYPE_NAME (type
))
2250 error (_("cannot subscript something of type `%s'"),
2253 error (_("cannot subscript requested type"));
2257 if (!is_integral_type (value2
->type
))
2258 error (_("Argument to arithmetic operation not a number or boolean."));
2260 gen_ptradd (ax
, value
, value1
, value2
);
2261 gen_deref (ax
, value
);
2264 case BINOP_BITWISE_AND
:
2265 gen_binop (ax
, value
, value1
, value2
,
2266 aop_bit_and
, aop_bit_and
, 0, "bitwise and");
2269 case BINOP_BITWISE_IOR
:
2270 gen_binop (ax
, value
, value1
, value2
,
2271 aop_bit_or
, aop_bit_or
, 0, "bitwise or");
2274 case BINOP_BITWISE_XOR
:
2275 gen_binop (ax
, value
, value1
, value2
,
2276 aop_bit_xor
, aop_bit_xor
, 0, "bitwise exclusive-or");
2280 gen_equal (ax
, value
, value1
, value2
, int_type
);
2283 case BINOP_NOTEQUAL
:
2284 gen_equal (ax
, value
, value1
, value2
, int_type
);
2285 gen_logical_not (ax
, value
, int_type
);
2289 gen_less (ax
, value
, value1
, value2
, int_type
);
2293 ax_simple (ax
, aop_swap
);
2294 gen_less (ax
, value
, value1
, value2
, int_type
);
2298 ax_simple (ax
, aop_swap
);
2299 gen_less (ax
, value
, value1
, value2
, int_type
);
2300 gen_logical_not (ax
, value
, int_type
);
2304 gen_less (ax
, value
, value1
, value2
, int_type
);
2305 gen_logical_not (ax
, value
, int_type
);
2309 /* We should only list operators in the outer case statement
2310 that we actually handle in the inner case statement. */
2311 internal_error (__FILE__
, __LINE__
,
2312 _("gen_expr: op case sets don't match"));
2317 /* Given a single variable and a scope, generate bytecodes to trace
2318 its value. This is for use in situations where we have only a
2319 variable's name, and no parsed expression; for instance, when the
2320 name comes from a list of local variables of a function. */
2323 gen_trace_for_var (CORE_ADDR scope
, struct gdbarch
*gdbarch
,
2326 struct cleanup
*old_chain
= 0;
2327 struct agent_expr
*ax
= new_agent_expr (scope
);
2328 struct axs_value value
;
2330 old_chain
= make_cleanup_free_agent_expr (ax
);
2333 gen_var_ref (gdbarch
, ax
, &value
, var
);
2335 /* If there is no actual variable to trace, flag it by returning
2336 an empty agent expression. */
2337 if (value
.optimized_out
)
2339 do_cleanups (old_chain
);
2343 /* Make sure we record the final object, and get rid of it. */
2344 gen_traced_pop (gdbarch
, ax
, &value
);
2346 /* Oh, and terminate. */
2347 ax_simple (ax
, aop_end
);
2349 /* We have successfully built the agent expr, so cancel the cleanup
2350 request. If we add more cleanups that we always want done, this
2351 will have to get more complicated. */
2352 discard_cleanups (old_chain
);
2356 /* Generating bytecode from GDB expressions: driver */
2358 /* Given a GDB expression EXPR, return bytecode to trace its value.
2359 The result will use the `trace' and `trace_quick' bytecodes to
2360 record the value of all memory touched by the expression. The
2361 caller can then use the ax_reqs function to discover which
2362 registers it relies upon. */
2364 gen_trace_for_expr (CORE_ADDR scope
, struct expression
*expr
)
2366 struct cleanup
*old_chain
= 0;
2367 struct agent_expr
*ax
= new_agent_expr (scope
);
2368 union exp_element
*pc
;
2369 struct axs_value value
;
2371 old_chain
= make_cleanup_free_agent_expr (ax
);
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 (scope
);
2402 union exp_element
*pc
;
2403 struct axs_value value
;
2405 old_chain
= make_cleanup_free_agent_expr (ax
);
2409 gen_expr (expr
, &pc
, 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
);
2422 agent_command (char *exp
, int from_tty
)
2424 struct cleanup
*old_chain
= 0;
2425 struct expression
*expr
;
2426 struct agent_expr
*agent
;
2427 struct frame_info
*fi
= get_current_frame (); /* need current scope */
2429 /* We don't deal with overlay debugging at the moment. We need to
2430 think more carefully about this. If you copy this code into
2431 another command, change the error message; the user shouldn't
2432 have to know anything about agent expressions. */
2433 if (overlay_debugging
)
2434 error (_("GDB can't do agent expression translation with overlays."));
2437 error_no_arg (_("expression to translate"));
2439 expr
= parse_expression (exp
);
2440 old_chain
= make_cleanup (free_current_contents
, &expr
);
2441 agent
= gen_trace_for_expr (get_frame_pc (fi
), expr
);
2442 make_cleanup_free_agent_expr (agent
);
2443 ax_print (gdb_stdout
, agent
);
2445 /* It would be nice to call ax_reqs here to gather some general info
2446 about the expression, and then print out the result. */
2448 do_cleanups (old_chain
);
2452 /* Parse the given expression, compile it into an agent expression
2453 that does direct evaluation, and display the resulting
2457 agent_eval_command (char *exp
, int from_tty
)
2459 struct cleanup
*old_chain
= 0;
2460 struct expression
*expr
;
2461 struct agent_expr
*agent
;
2462 struct frame_info
*fi
= get_current_frame (); /* need current scope */
2464 /* We don't deal with overlay debugging at the moment. We need to
2465 think more carefully about this. If you copy this code into
2466 another command, change the error message; the user shouldn't
2467 have to know anything about agent expressions. */
2468 if (overlay_debugging
)
2469 error (_("GDB can't do agent expression translation with overlays."));
2472 error_no_arg (_("expression to translate"));
2474 expr
= parse_expression (exp
);
2475 old_chain
= make_cleanup (free_current_contents
, &expr
);
2476 agent
= gen_eval_for_expr (get_frame_pc (fi
), expr
);
2477 make_cleanup_free_agent_expr (agent
);
2478 ax_print (gdb_stdout
, agent
);
2480 /* It would be nice to call ax_reqs here to gather some general info
2481 about the expression, and then print out the result. */
2483 do_cleanups (old_chain
);
2488 /* Initialization code. */
2490 void _initialize_ax_gdb (void);
2492 _initialize_ax_gdb (void)
2494 add_cmd ("agent", class_maintenance
, agent_command
,
2495 _("Translate an expression into remote agent bytecode for tracing."),
2498 add_cmd ("agent-eval", class_maintenance
, agent_eval_command
,
2499 _("Translate an expression into remote agent bytecode for evaluation."),
This page took 0.079365 seconds and 4 git commands to generate.