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"
43 /* To make sense of this file, you should read doc/agentexpr.texi.
44 Then look at the types and enums in ax-gdb.h. For the code itself,
45 look at gen_expr, towards the bottom; that's the main function that
46 looks at the GDB expressions and calls everything else to generate
49 I'm beginning to wonder whether it wouldn't be nicer to internally
50 generate trees, with types, and then spit out the bytecode in
51 linear form afterwards; we could generate fewer `swap', `ext', and
52 `zero_ext' bytecodes that way; it would make good constant folding
53 easier, too. But at the moment, I think we should be willing to
54 pay for the simplicity of this code with less-than-optimal bytecode
57 Remember, "GBD" stands for "Great Britain, Dammit!" So be careful. */
61 /* Prototypes for local functions. */
63 /* There's a standard order to the arguments of these functions:
64 union exp_element ** --- pointer into expression
65 struct agent_expr * --- agent expression buffer to generate code into
66 struct axs_value * --- describes value left on top of stack */
68 static struct value
*const_var_ref (struct symbol
*var
);
69 static struct value
*const_expr (union exp_element
**pc
);
70 static struct value
*maybe_const_expr (union exp_element
**pc
);
72 static void gen_traced_pop (struct agent_expr
*, struct axs_value
*);
74 static void gen_sign_extend (struct agent_expr
*, struct type
*);
75 static void gen_extend (struct agent_expr
*, struct type
*);
76 static void gen_fetch (struct agent_expr
*, struct type
*);
77 static void gen_left_shift (struct agent_expr
*, int);
80 static void gen_frame_args_address (struct gdbarch
*, struct agent_expr
*);
81 static void gen_frame_locals_address (struct gdbarch
*, struct agent_expr
*);
82 static void gen_offset (struct agent_expr
*ax
, int offset
);
83 static void gen_sym_offset (struct agent_expr
*, struct symbol
*);
84 static void gen_var_ref (struct gdbarch
*, struct agent_expr
*ax
,
85 struct axs_value
*value
, struct symbol
*var
);
88 static void gen_int_literal (struct agent_expr
*ax
,
89 struct axs_value
*value
,
90 LONGEST k
, struct type
*type
);
93 static void require_rvalue (struct agent_expr
*ax
, struct axs_value
*value
);
94 static void gen_usual_unary (struct expression
*exp
, struct agent_expr
*ax
,
95 struct axs_value
*value
);
96 static int type_wider_than (struct type
*type1
, struct type
*type2
);
97 static struct type
*max_type (struct type
*type1
, struct type
*type2
);
98 static void gen_conversion (struct agent_expr
*ax
,
99 struct type
*from
, struct type
*to
);
100 static int is_nontrivial_conversion (struct type
*from
, struct type
*to
);
101 static void gen_usual_arithmetic (struct expression
*exp
,
102 struct agent_expr
*ax
,
103 struct axs_value
*value1
,
104 struct axs_value
*value2
);
105 static void gen_integral_promotions (struct expression
*exp
,
106 struct agent_expr
*ax
,
107 struct axs_value
*value
);
108 static void gen_cast (struct agent_expr
*ax
,
109 struct axs_value
*value
, struct type
*type
);
110 static void gen_scale (struct agent_expr
*ax
,
111 enum agent_op op
, struct type
*type
);
112 static void gen_ptradd (struct agent_expr
*ax
, struct axs_value
*value
,
113 struct axs_value
*value1
, struct axs_value
*value2
);
114 static void gen_ptrsub (struct agent_expr
*ax
, struct axs_value
*value
,
115 struct axs_value
*value1
, struct axs_value
*value2
);
116 static void gen_ptrdiff (struct agent_expr
*ax
, struct axs_value
*value
,
117 struct axs_value
*value1
, struct axs_value
*value2
,
118 struct type
*result_type
);
119 static void gen_binop (struct agent_expr
*ax
,
120 struct axs_value
*value
,
121 struct axs_value
*value1
,
122 struct axs_value
*value2
,
124 enum agent_op op_unsigned
, int may_carry
, char *name
);
125 static void gen_logical_not (struct agent_expr
*ax
, struct axs_value
*value
,
126 struct type
*result_type
);
127 static void gen_complement (struct agent_expr
*ax
, struct axs_value
*value
);
128 static void gen_deref (struct agent_expr
*, struct axs_value
*);
129 static void gen_address_of (struct agent_expr
*, struct axs_value
*);
130 static int find_field (struct type
*type
, char *name
);
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_struct_ref (struct expression
*exp
, struct agent_expr
*ax
,
135 struct axs_value
*value
,
137 char *operator_name
, char *operand_name
);
138 static void gen_repeat (struct expression
*exp
, union exp_element
**pc
,
139 struct agent_expr
*ax
, struct axs_value
*value
);
140 static void gen_sizeof (struct expression
*exp
, union exp_element
**pc
,
141 struct agent_expr
*ax
, struct axs_value
*value
,
142 struct type
*size_type
);
143 static void gen_expr (struct expression
*exp
, union exp_element
**pc
,
144 struct agent_expr
*ax
, struct axs_value
*value
);
145 static void gen_expr_binop_rest (struct expression
*exp
,
146 enum exp_opcode op
, union exp_element
**pc
,
147 struct agent_expr
*ax
,
148 struct axs_value
*value
,
149 struct axs_value
*value1
,
150 struct axs_value
*value2
);
152 static void agent_command (char *exp
, int from_tty
);
155 /* Detecting constant expressions. */
157 /* If the variable reference at *PC is a constant, return its value.
158 Otherwise, return zero.
160 Hey, Wally! How can a variable reference be a constant?
162 Well, Beav, this function really handles the OP_VAR_VALUE operator,
163 not specifically variable references. GDB uses OP_VAR_VALUE to
164 refer to any kind of symbolic reference: function names, enum
165 elements, and goto labels are all handled through the OP_VAR_VALUE
166 operator, even though they're constants. It makes sense given the
169 Gee, Wally, don'cha wonder sometimes if data representations that
170 subvert commonly accepted definitions of terms in favor of heavily
171 context-specific interpretations are really just a tool of the
172 programming hegemony to preserve their power and exclude the
175 static struct value
*
176 const_var_ref (struct symbol
*var
)
178 struct type
*type
= SYMBOL_TYPE (var
);
180 switch (SYMBOL_CLASS (var
))
183 return value_from_longest (type
, (LONGEST
) SYMBOL_VALUE (var
));
186 return value_from_pointer (type
, (CORE_ADDR
) SYMBOL_VALUE_ADDRESS (var
));
194 /* If the expression starting at *PC has a constant value, return it.
195 Otherwise, return zero. If we return a value, then *PC will be
196 advanced to the end of it. If we return zero, *PC could be
198 static struct value
*
199 const_expr (union exp_element
**pc
)
201 enum exp_opcode op
= (*pc
)->opcode
;
208 struct type
*type
= (*pc
)[1].type
;
209 LONGEST k
= (*pc
)[2].longconst
;
211 return value_from_longest (type
, k
);
216 struct value
*v
= const_var_ref ((*pc
)[2].symbol
);
221 /* We could add more operators in here. */
225 v1
= const_expr (pc
);
227 return value_neg (v1
);
237 /* Like const_expr, but guarantee also that *PC is undisturbed if the
238 expression is not constant. */
239 static struct value
*
240 maybe_const_expr (union exp_element
**pc
)
242 union exp_element
*tentative_pc
= *pc
;
243 struct value
*v
= const_expr (&tentative_pc
);
245 /* If we got a value, then update the real PC. */
253 /* Generating bytecode from GDB expressions: general assumptions */
255 /* Here are a few general assumptions made throughout the code; if you
256 want to make a change that contradicts one of these, then you'd
257 better scan things pretty thoroughly.
259 - We assume that all values occupy one stack element. For example,
260 sometimes we'll swap to get at the left argument to a binary
261 operator. If we decide that void values should occupy no stack
262 elements, or that synthetic arrays (whose size is determined at
263 run time, created by the `@' operator) should occupy two stack
264 elements (address and length), then this will cause trouble.
266 - We assume the stack elements are infinitely wide, and that we
267 don't have to worry what happens if the user requests an
268 operation that is wider than the actual interpreter's stack.
269 That is, it's up to the interpreter to handle directly all the
270 integer widths the user has access to. (Woe betide the language
273 - We don't support side effects. Thus, we don't have to worry about
274 GCC's generalized lvalues, function calls, etc.
276 - We don't support floating point. Many places where we switch on
277 some type don't bother to include cases for floating point; there
278 may be even more subtle ways this assumption exists. For
279 example, the arguments to % must be integers.
281 - We assume all subexpressions have a static, unchanging type. If
282 we tried to support convenience variables, this would be a
285 - All values on the stack should always be fully zero- or
288 (I wasn't sure whether to choose this or its opposite --- that
289 only addresses are assumed extended --- but it turns out that
290 neither convention completely eliminates spurious extend
291 operations (if everything is always extended, then you have to
292 extend after add, because it could overflow; if nothing is
293 extended, then you end up producing extends whenever you change
294 sizes), and this is simpler.) */
297 /* Generating bytecode from GDB expressions: the `trace' kludge */
299 /* The compiler in this file is a general-purpose mechanism for
300 translating GDB expressions into bytecode. One ought to be able to
301 find a million and one uses for it.
303 However, at the moment it is HOPELESSLY BRAIN-DAMAGED for the sake
304 of expediency. Let he who is without sin cast the first stone.
306 For the data tracing facility, we need to insert `trace' bytecodes
307 before each data fetch; this records all the memory that the
308 expression touches in the course of evaluation, so that memory will
309 be available when the user later tries to evaluate the expression
312 This should be done (I think) in a post-processing pass, that walks
313 an arbitrary agent expression and inserts `trace' operations at the
314 appropriate points. But it's much faster to just hack them
315 directly into the code. And since we're in a crunch, that's what
318 Setting the flag trace_kludge to non-zero enables the code that
319 emits the trace bytecodes at the appropriate points. */
320 static int trace_kludge
;
322 /* Trace the lvalue on the stack, if it needs it. In either case, pop
323 the value. Useful on the left side of a comma, and at the end of
324 an expression being used for tracing. */
326 gen_traced_pop (struct agent_expr
*ax
, struct axs_value
*value
)
332 /* We don't trace rvalues, just the lvalues necessary to
333 produce them. So just dispose of this value. */
334 ax_simple (ax
, aop_pop
);
337 case axs_lvalue_memory
:
339 int length
= TYPE_LENGTH (check_typedef (value
->type
));
341 /* There's no point in trying to use a trace_quick bytecode
342 here, since "trace_quick SIZE pop" is three bytes, whereas
343 "const8 SIZE trace" is also three bytes, does the same
344 thing, and the simplest code which generates that will also
345 work correctly for objects with large sizes. */
346 ax_const_l (ax
, length
);
347 ax_simple (ax
, aop_trace
);
351 case axs_lvalue_register
:
352 /* We need to mention the register somewhere in the bytecode,
353 so ax_reqs will pick it up and add it to the mask of
355 ax_reg (ax
, value
->u
.reg
);
356 ax_simple (ax
, aop_pop
);
360 /* If we're not tracing, just pop the value. */
361 ax_simple (ax
, aop_pop
);
366 /* Generating bytecode from GDB expressions: helper functions */
368 /* Assume that the lower bits of the top of the stack is a value of
369 type TYPE, and the upper bits are zero. Sign-extend if necessary. */
371 gen_sign_extend (struct agent_expr
*ax
, struct type
*type
)
373 /* Do we need to sign-extend this? */
374 if (!TYPE_UNSIGNED (type
))
375 ax_ext (ax
, TYPE_LENGTH (type
) * TARGET_CHAR_BIT
);
379 /* Assume the lower bits of the top of the stack hold a value of type
380 TYPE, and the upper bits are garbage. Sign-extend or truncate as
383 gen_extend (struct agent_expr
*ax
, struct type
*type
)
385 int bits
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
387 ((TYPE_UNSIGNED (type
) ? ax_zero_ext
: ax_ext
) (ax
, bits
));
391 /* Assume that the top of the stack contains a value of type "pointer
392 to TYPE"; generate code to fetch its value. Note that TYPE is the
393 target type, not the pointer type. */
395 gen_fetch (struct agent_expr
*ax
, struct type
*type
)
399 /* Record the area of memory we're about to fetch. */
400 ax_trace_quick (ax
, TYPE_LENGTH (type
));
403 switch (TYPE_CODE (type
))
410 /* It's a scalar value, so we know how to dereference it. How
411 many bytes long is it? */
412 switch (TYPE_LENGTH (type
))
414 case 8 / TARGET_CHAR_BIT
:
415 ax_simple (ax
, aop_ref8
);
417 case 16 / TARGET_CHAR_BIT
:
418 ax_simple (ax
, aop_ref16
);
420 case 32 / TARGET_CHAR_BIT
:
421 ax_simple (ax
, aop_ref32
);
423 case 64 / TARGET_CHAR_BIT
:
424 ax_simple (ax
, aop_ref64
);
427 /* Either our caller shouldn't have asked us to dereference
428 that pointer (other code's fault), or we're not
429 implementing something we should be (this code's fault).
430 In any case, it's a bug the user shouldn't see. */
432 internal_error (__FILE__
, __LINE__
,
433 _("gen_fetch: strange size"));
436 gen_sign_extend (ax
, type
);
440 /* Either our caller shouldn't have asked us to dereference that
441 pointer (other code's fault), or we're not implementing
442 something we should be (this code's fault). In any case,
443 it's a bug the user shouldn't see. */
444 internal_error (__FILE__
, __LINE__
,
445 _("gen_fetch: bad type code"));
450 /* Generate code to left shift the top of the stack by DISTANCE bits, or
451 right shift it by -DISTANCE bits if DISTANCE < 0. This generates
452 unsigned (logical) right shifts. */
454 gen_left_shift (struct agent_expr
*ax
, int distance
)
458 ax_const_l (ax
, distance
);
459 ax_simple (ax
, aop_lsh
);
461 else if (distance
< 0)
463 ax_const_l (ax
, -distance
);
464 ax_simple (ax
, aop_rsh_unsigned
);
470 /* Generating bytecode from GDB expressions: symbol references */
472 /* Generate code to push the base address of the argument portion of
473 the top stack frame. */
475 gen_frame_args_address (struct gdbarch
*gdbarch
, struct agent_expr
*ax
)
478 LONGEST frame_offset
;
480 gdbarch_virtual_frame_pointer (gdbarch
,
481 ax
->scope
, &frame_reg
, &frame_offset
);
482 ax_reg (ax
, frame_reg
);
483 gen_offset (ax
, frame_offset
);
487 /* Generate code to push the base address of the locals portion of the
490 gen_frame_locals_address (struct gdbarch
*gdbarch
, struct agent_expr
*ax
)
493 LONGEST frame_offset
;
495 gdbarch_virtual_frame_pointer (gdbarch
,
496 ax
->scope
, &frame_reg
, &frame_offset
);
497 ax_reg (ax
, frame_reg
);
498 gen_offset (ax
, frame_offset
);
502 /* Generate code to add OFFSET to the top of the stack. Try to
503 generate short and readable code. We use this for getting to
504 variables on the stack, and structure members. If we were
505 programming in ML, it would be clearer why these are the same
508 gen_offset (struct agent_expr
*ax
, int offset
)
510 /* It would suffice to simply push the offset and add it, but this
511 makes it easier to read positive and negative offsets in the
515 ax_const_l (ax
, offset
);
516 ax_simple (ax
, aop_add
);
520 ax_const_l (ax
, -offset
);
521 ax_simple (ax
, aop_sub
);
526 /* In many cases, a symbol's value is the offset from some other
527 address (stack frame, base register, etc.) Generate code to add
528 VAR's value to the top of the stack. */
530 gen_sym_offset (struct agent_expr
*ax
, struct symbol
*var
)
532 gen_offset (ax
, SYMBOL_VALUE (var
));
536 /* Generate code for a variable reference to AX. The variable is the
537 symbol VAR. Set VALUE to describe the result. */
540 gen_var_ref (struct gdbarch
*gdbarch
, struct agent_expr
*ax
,
541 struct axs_value
*value
, struct symbol
*var
)
543 /* Dereference any typedefs. */
544 value
->type
= check_typedef (SYMBOL_TYPE (var
));
546 /* I'm imitating the code in read_var_value. */
547 switch (SYMBOL_CLASS (var
))
549 case LOC_CONST
: /* A constant, like an enum value. */
550 ax_const_l (ax
, (LONGEST
) SYMBOL_VALUE (var
));
551 value
->kind
= axs_rvalue
;
554 case LOC_LABEL
: /* A goto label, being used as a value. */
555 ax_const_l (ax
, (LONGEST
) SYMBOL_VALUE_ADDRESS (var
));
556 value
->kind
= axs_rvalue
;
559 case LOC_CONST_BYTES
:
560 internal_error (__FILE__
, __LINE__
,
561 _("gen_var_ref: LOC_CONST_BYTES symbols are not supported"));
563 /* Variable at a fixed location in memory. Easy. */
565 /* Push the address of the variable. */
566 ax_const_l (ax
, SYMBOL_VALUE_ADDRESS (var
));
567 value
->kind
= axs_lvalue_memory
;
570 case LOC_ARG
: /* var lives in argument area of frame */
571 gen_frame_args_address (gdbarch
, ax
);
572 gen_sym_offset (ax
, var
);
573 value
->kind
= axs_lvalue_memory
;
576 case LOC_REF_ARG
: /* As above, but the frame slot really
577 holds the address of the variable. */
578 gen_frame_args_address (gdbarch
, ax
);
579 gen_sym_offset (ax
, var
);
580 /* Don't assume any particular pointer size. */
581 gen_fetch (ax
, builtin_type (gdbarch
)->builtin_data_ptr
);
582 value
->kind
= axs_lvalue_memory
;
585 case LOC_LOCAL
: /* var lives in locals area of frame */
586 gen_frame_locals_address (gdbarch
, ax
);
587 gen_sym_offset (ax
, var
);
588 value
->kind
= axs_lvalue_memory
;
592 error (_("Cannot compute value of typedef `%s'."),
593 SYMBOL_PRINT_NAME (var
));
597 ax_const_l (ax
, BLOCK_START (SYMBOL_BLOCK_VALUE (var
)));
598 value
->kind
= axs_rvalue
;
602 /* Don't generate any code at all; in the process of treating
603 this as an lvalue or rvalue, the caller will generate the
605 value
->kind
= axs_lvalue_register
;
606 value
->u
.reg
= SYMBOL_REGISTER_OPS (var
)->register_number (var
, gdbarch
);
609 /* A lot like LOC_REF_ARG, but the pointer lives directly in a
610 register, not on the stack. Simpler than LOC_REGISTER
611 because it's just like any other case where the thing
612 has a real address. */
613 case LOC_REGPARM_ADDR
:
614 ax_reg (ax
, SYMBOL_REGISTER_OPS (var
)->register_number (var
, gdbarch
));
615 value
->kind
= axs_lvalue_memory
;
620 struct minimal_symbol
*msym
621 = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var
), NULL
, NULL
);
623 error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var
));
625 /* Push the address of the variable. */
626 ax_const_l (ax
, SYMBOL_VALUE_ADDRESS (msym
));
627 value
->kind
= axs_lvalue_memory
;
632 /* FIXME: cagney/2004-01-26: It should be possible to
633 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
634 Unfortunately DWARF 2 stores the frame-base (instead of the
635 function) location in a function's symbol. Oops! For the
636 moment enable this when/where applicable. */
637 SYMBOL_COMPUTED_OPS (var
)->tracepoint_var_ref (var
, gdbarch
, ax
, value
);
640 case LOC_OPTIMIZED_OUT
:
641 error (_("The variable `%s' has been optimized out."),
642 SYMBOL_PRINT_NAME (var
));
646 error (_("Cannot find value of botched symbol `%s'."),
647 SYMBOL_PRINT_NAME (var
));
654 /* Generating bytecode from GDB expressions: literals */
657 gen_int_literal (struct agent_expr
*ax
, struct axs_value
*value
, LONGEST k
,
661 value
->kind
= axs_rvalue
;
662 value
->type
= check_typedef (type
);
667 /* Generating bytecode from GDB expressions: unary conversions, casts */
669 /* Take what's on the top of the stack (as described by VALUE), and
670 try to make an rvalue out of it. Signal an error if we can't do
673 require_rvalue (struct agent_expr
*ax
, struct axs_value
*value
)
678 /* It's already an rvalue. */
681 case axs_lvalue_memory
:
682 /* The top of stack is the address of the object. Dereference. */
683 gen_fetch (ax
, value
->type
);
686 case axs_lvalue_register
:
687 /* There's nothing on the stack, but value->u.reg is the
688 register number containing the value.
690 When we add floating-point support, this is going to have to
691 change. What about SPARC register pairs, for example? */
692 ax_reg (ax
, value
->u
.reg
);
693 gen_extend (ax
, value
->type
);
697 value
->kind
= axs_rvalue
;
701 /* Assume the top of the stack is described by VALUE, and perform the
702 usual unary conversions. This is motivated by ANSI 6.2.2, but of
703 course GDB expressions are not ANSI; they're the mishmash union of
704 a bunch of languages. Rah.
706 NOTE! This function promises to produce an rvalue only when the
707 incoming value is of an appropriate type. In other words, the
708 consumer of the value this function produces may assume the value
709 is an rvalue only after checking its type.
711 The immediate issue is that if the user tries to use a structure or
712 union as an operand of, say, the `+' operator, we don't want to try
713 to convert that structure to an rvalue; require_rvalue will bomb on
714 structs and unions. Rather, we want to simply pass the struct
715 lvalue through unchanged, and let `+' raise an error. */
718 gen_usual_unary (struct expression
*exp
, struct agent_expr
*ax
,
719 struct axs_value
*value
)
721 /* We don't have to generate any code for the usual integral
722 conversions, since values are always represented as full-width on
723 the stack. Should we tweak the type? */
725 /* Some types require special handling. */
726 switch (TYPE_CODE (value
->type
))
728 /* Functions get converted to a pointer to the function. */
730 value
->type
= lookup_pointer_type (value
->type
);
731 value
->kind
= axs_rvalue
; /* Should always be true, but just in case. */
734 /* Arrays get converted to a pointer to their first element, and
735 are no longer an lvalue. */
736 case TYPE_CODE_ARRAY
:
738 struct type
*elements
= TYPE_TARGET_TYPE (value
->type
);
739 value
->type
= lookup_pointer_type (elements
);
740 value
->kind
= axs_rvalue
;
741 /* We don't need to generate any code; the address of the array
742 is also the address of its first element. */
746 /* Don't try to convert structures and unions to rvalues. Let the
747 consumer signal an error. */
748 case TYPE_CODE_STRUCT
:
749 case TYPE_CODE_UNION
:
752 /* If the value is an enum, call it an integer. */
754 value
->type
= builtin_type (exp
->gdbarch
)->builtin_int
;
758 /* If the value is an lvalue, dereference it. */
759 require_rvalue (ax
, value
);
763 /* Return non-zero iff the type TYPE1 is considered "wider" than the
764 type TYPE2, according to the rules described in gen_usual_arithmetic. */
766 type_wider_than (struct type
*type1
, struct type
*type2
)
768 return (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
)
769 || (TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
770 && TYPE_UNSIGNED (type1
)
771 && !TYPE_UNSIGNED (type2
)));
775 /* Return the "wider" of the two types TYPE1 and TYPE2. */
777 max_type (struct type
*type1
, struct type
*type2
)
779 return type_wider_than (type1
, type2
) ? type1
: type2
;
783 /* Generate code to convert a scalar value of type FROM to type TO. */
785 gen_conversion (struct agent_expr
*ax
, struct type
*from
, struct type
*to
)
787 /* Perhaps there is a more graceful way to state these rules. */
789 /* If we're converting to a narrower type, then we need to clear out
791 if (TYPE_LENGTH (to
) < TYPE_LENGTH (from
))
792 gen_extend (ax
, from
);
794 /* If the two values have equal width, but different signednesses,
795 then we need to extend. */
796 else if (TYPE_LENGTH (to
) == TYPE_LENGTH (from
))
798 if (TYPE_UNSIGNED (from
) != TYPE_UNSIGNED (to
))
802 /* If we're converting to a wider type, and becoming unsigned, then
803 we need to zero out any possible sign bits. */
804 else if (TYPE_LENGTH (to
) > TYPE_LENGTH (from
))
806 if (TYPE_UNSIGNED (to
))
812 /* Return non-zero iff the type FROM will require any bytecodes to be
813 emitted to be converted to the type TO. */
815 is_nontrivial_conversion (struct type
*from
, struct type
*to
)
817 struct agent_expr
*ax
= new_agent_expr (0);
820 /* Actually generate the code, and see if anything came out. At the
821 moment, it would be trivial to replicate the code in
822 gen_conversion here, but in the future, when we're supporting
823 floating point and the like, it may not be. Doing things this
824 way allows this function to be independent of the logic in
826 gen_conversion (ax
, from
, to
);
827 nontrivial
= ax
->len
> 0;
828 free_agent_expr (ax
);
833 /* Generate code to perform the "usual arithmetic conversions" (ANSI C
834 6.2.1.5) for the two operands of an arithmetic operator. This
835 effectively finds a "least upper bound" type for the two arguments,
836 and promotes each argument to that type. *VALUE1 and *VALUE2
837 describe the values as they are passed in, and as they are left. */
839 gen_usual_arithmetic (struct expression
*exp
, struct agent_expr
*ax
,
840 struct axs_value
*value1
, struct axs_value
*value2
)
842 /* Do the usual binary conversions. */
843 if (TYPE_CODE (value1
->type
) == TYPE_CODE_INT
844 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
846 /* The ANSI integral promotions seem to work this way: Order the
847 integer types by size, and then by signedness: an n-bit
848 unsigned type is considered "wider" than an n-bit signed
849 type. Promote to the "wider" of the two types, and always
850 promote at least to int. */
851 struct type
*target
= max_type (builtin_type (exp
->gdbarch
)->builtin_int
,
852 max_type (value1
->type
, value2
->type
));
854 /* Deal with value2, on the top of the stack. */
855 gen_conversion (ax
, value2
->type
, target
);
857 /* Deal with value1, not on the top of the stack. Don't
858 generate the `swap' instructions if we're not actually going
860 if (is_nontrivial_conversion (value1
->type
, target
))
862 ax_simple (ax
, aop_swap
);
863 gen_conversion (ax
, value1
->type
, target
);
864 ax_simple (ax
, aop_swap
);
867 value1
->type
= value2
->type
= check_typedef (target
);
872 /* Generate code to perform the integral promotions (ANSI 6.2.1.1) on
873 the value on the top of the stack, as described by VALUE. Assume
874 the value has integral type. */
876 gen_integral_promotions (struct expression
*exp
, struct agent_expr
*ax
,
877 struct axs_value
*value
)
879 const struct builtin_type
*builtin
= builtin_type (exp
->gdbarch
);
881 if (!type_wider_than (value
->type
, builtin
->builtin_int
))
883 gen_conversion (ax
, value
->type
, builtin
->builtin_int
);
884 value
->type
= builtin
->builtin_int
;
886 else if (!type_wider_than (value
->type
, builtin
->builtin_unsigned_int
))
888 gen_conversion (ax
, value
->type
, builtin
->builtin_unsigned_int
);
889 value
->type
= builtin
->builtin_unsigned_int
;
894 /* Generate code for a cast to TYPE. */
896 gen_cast (struct agent_expr
*ax
, struct axs_value
*value
, struct type
*type
)
898 /* GCC does allow casts to yield lvalues, so this should be fixed
899 before merging these changes into the trunk. */
900 require_rvalue (ax
, value
);
901 /* Dereference typedefs. */
902 type
= check_typedef (type
);
904 switch (TYPE_CODE (type
))
908 /* It's implementation-defined, and I'll bet this is what GCC
912 case TYPE_CODE_ARRAY
:
913 case TYPE_CODE_STRUCT
:
914 case TYPE_CODE_UNION
:
916 error (_("Invalid type cast: intended type must be scalar."));
919 /* We don't have to worry about the size of the value, because
920 all our integral values are fully sign-extended, and when
921 casting pointers we can do anything we like. Is there any
922 way for us to know what GCC actually does with a cast like
927 gen_conversion (ax
, value
->type
, type
);
931 /* We could pop the value, and rely on everyone else to check
932 the type and notice that this value doesn't occupy a stack
933 slot. But for now, leave the value on the stack, and
934 preserve the "value == stack element" assumption. */
938 error (_("Casts to requested type are not yet implemented."));
946 /* Generating bytecode from GDB expressions: arithmetic */
948 /* Scale the integer on the top of the stack by the size of the target
949 of the pointer type TYPE. */
951 gen_scale (struct agent_expr
*ax
, enum agent_op op
, struct type
*type
)
953 struct type
*element
= TYPE_TARGET_TYPE (type
);
955 if (TYPE_LENGTH (element
) != 1)
957 ax_const_l (ax
, TYPE_LENGTH (element
));
963 /* Generate code for pointer arithmetic PTR + INT. */
965 gen_ptradd (struct agent_expr
*ax
, struct axs_value
*value
,
966 struct axs_value
*value1
, struct axs_value
*value2
)
968 gdb_assert (pointer_type (value1
->type
));
969 gdb_assert (TYPE_CODE (value2
->type
) == TYPE_CODE_INT
);
971 gen_scale (ax
, aop_mul
, value1
->type
);
972 ax_simple (ax
, aop_add
);
973 gen_extend (ax
, value1
->type
); /* Catch overflow. */
974 value
->type
= value1
->type
;
975 value
->kind
= axs_rvalue
;
979 /* Generate code for pointer arithmetic PTR - INT. */
981 gen_ptrsub (struct agent_expr
*ax
, struct axs_value
*value
,
982 struct axs_value
*value1
, struct axs_value
*value2
)
984 gdb_assert (pointer_type (value1
->type
));
985 gdb_assert (TYPE_CODE (value2
->type
) == TYPE_CODE_INT
);
987 gen_scale (ax
, aop_mul
, value1
->type
);
988 ax_simple (ax
, aop_sub
);
989 gen_extend (ax
, value1
->type
); /* Catch overflow. */
990 value
->type
= value1
->type
;
991 value
->kind
= axs_rvalue
;
995 /* Generate code for pointer arithmetic PTR - PTR. */
997 gen_ptrdiff (struct agent_expr
*ax
, struct axs_value
*value
,
998 struct axs_value
*value1
, struct axs_value
*value2
,
999 struct type
*result_type
)
1001 gdb_assert (pointer_type (value1
->type
));
1002 gdb_assert (pointer_type (value2
->type
));
1004 if (TYPE_LENGTH (TYPE_TARGET_TYPE (value1
->type
))
1005 != TYPE_LENGTH (TYPE_TARGET_TYPE (value2
->type
)))
1007 First argument of `-' is a pointer, but second argument is neither\n\
1008 an integer nor a pointer of the same type."));
1010 ax_simple (ax
, aop_sub
);
1011 gen_scale (ax
, aop_div_unsigned
, value1
->type
);
1012 value
->type
= result_type
;
1013 value
->kind
= axs_rvalue
;
1017 /* Generate code for a binary operator that doesn't do pointer magic.
1018 We set VALUE to describe the result value; we assume VALUE1 and
1019 VALUE2 describe the two operands, and that they've undergone the
1020 usual binary conversions. MAY_CARRY should be non-zero iff the
1021 result needs to be extended. NAME is the English name of the
1022 operator, used in error messages */
1024 gen_binop (struct agent_expr
*ax
, struct axs_value
*value
,
1025 struct axs_value
*value1
, struct axs_value
*value2
, enum agent_op op
,
1026 enum agent_op op_unsigned
, int may_carry
, char *name
)
1028 /* We only handle INT op INT. */
1029 if ((TYPE_CODE (value1
->type
) != TYPE_CODE_INT
)
1030 || (TYPE_CODE (value2
->type
) != TYPE_CODE_INT
))
1031 error (_("Invalid combination of types in %s."), name
);
1034 TYPE_UNSIGNED (value1
->type
) ? op_unsigned
: op
);
1036 gen_extend (ax
, value1
->type
); /* catch overflow */
1037 value
->type
= value1
->type
;
1038 value
->kind
= axs_rvalue
;
1043 gen_logical_not (struct agent_expr
*ax
, struct axs_value
*value
,
1044 struct type
*result_type
)
1046 if (TYPE_CODE (value
->type
) != TYPE_CODE_INT
1047 && TYPE_CODE (value
->type
) != TYPE_CODE_PTR
)
1048 error (_("Invalid type of operand to `!'."));
1050 ax_simple (ax
, aop_log_not
);
1051 value
->type
= result_type
;
1056 gen_complement (struct agent_expr
*ax
, struct axs_value
*value
)
1058 if (TYPE_CODE (value
->type
) != TYPE_CODE_INT
)
1059 error (_("Invalid type of operand to `~'."));
1061 ax_simple (ax
, aop_bit_not
);
1062 gen_extend (ax
, value
->type
);
1067 /* Generating bytecode from GDB expressions: * & . -> @ sizeof */
1069 /* Dereference the value on the top of the stack. */
1071 gen_deref (struct agent_expr
*ax
, struct axs_value
*value
)
1073 /* The caller should check the type, because several operators use
1074 this, and we don't know what error message to generate. */
1075 if (!pointer_type (value
->type
))
1076 internal_error (__FILE__
, __LINE__
,
1077 _("gen_deref: expected a pointer"));
1079 /* We've got an rvalue now, which is a pointer. We want to yield an
1080 lvalue, whose address is exactly that pointer. So we don't
1081 actually emit any code; we just change the type from "Pointer to
1082 T" to "T", and mark the value as an lvalue in memory. Leave it
1083 to the consumer to actually dereference it. */
1084 value
->type
= check_typedef (TYPE_TARGET_TYPE (value
->type
));
1085 if (TYPE_CODE (value
->type
) == TYPE_CODE_VOID
)
1086 error (_("Attempt to dereference a generic pointer."));
1087 value
->kind
= ((TYPE_CODE (value
->type
) == TYPE_CODE_FUNC
)
1088 ? axs_rvalue
: axs_lvalue_memory
);
1092 /* Produce the address of the lvalue on the top of the stack. */
1094 gen_address_of (struct agent_expr
*ax
, struct axs_value
*value
)
1096 /* Special case for taking the address of a function. The ANSI
1097 standard describes this as a special case, too, so this
1098 arrangement is not without motivation. */
1099 if (TYPE_CODE (value
->type
) == TYPE_CODE_FUNC
)
1100 /* The value's already an rvalue on the stack, so we just need to
1102 value
->type
= lookup_pointer_type (value
->type
);
1104 switch (value
->kind
)
1107 error (_("Operand of `&' is an rvalue, which has no address."));
1109 case axs_lvalue_register
:
1110 error (_("Operand of `&' is in a register, and has no address."));
1112 case axs_lvalue_memory
:
1113 value
->kind
= axs_rvalue
;
1114 value
->type
= lookup_pointer_type (value
->type
);
1120 /* A lot of this stuff will have to change to support C++. But we're
1121 not going to deal with that at the moment. */
1123 /* Find the field in the structure type TYPE named NAME, and return
1124 its index in TYPE's field array. */
1126 find_field (struct type
*type
, char *name
)
1130 CHECK_TYPEDEF (type
);
1132 /* Make sure this isn't C++. */
1133 if (TYPE_N_BASECLASSES (type
) != 0)
1134 internal_error (__FILE__
, __LINE__
,
1135 _("find_field: derived classes supported"));
1137 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1139 char *this_name
= TYPE_FIELD_NAME (type
, i
);
1143 if (strcmp (name
, this_name
) == 0)
1146 if (this_name
[0] == '\0')
1147 internal_error (__FILE__
, __LINE__
,
1148 _("find_field: anonymous unions not supported"));
1152 error (_("Couldn't find member named `%s' in struct/union `%s'"),
1153 name
, TYPE_TAG_NAME (type
));
1159 /* Generate code to push the value of a bitfield of a structure whose
1160 address is on the top of the stack. START and END give the
1161 starting and one-past-ending *bit* numbers of the field within the
1164 gen_bitfield_ref (struct expression
*exp
, struct agent_expr
*ax
,
1165 struct axs_value
*value
, struct type
*type
,
1168 /* Note that ops[i] fetches 8 << i bits. */
1169 static enum agent_op ops
[]
1171 {aop_ref8
, aop_ref16
, aop_ref32
, aop_ref64
};
1172 static int num_ops
= (sizeof (ops
) / sizeof (ops
[0]));
1174 /* We don't want to touch any byte that the bitfield doesn't
1175 actually occupy; we shouldn't make any accesses we're not
1176 explicitly permitted to. We rely here on the fact that the
1177 bytecode `ref' operators work on unaligned addresses.
1179 It takes some fancy footwork to get the stack to work the way
1180 we'd like. Say we're retrieving a bitfield that requires three
1181 fetches. Initially, the stack just contains the address:
1183 For the first fetch, we duplicate the address
1185 then add the byte offset, do the fetch, and shift and mask as
1186 needed, yielding a fragment of the value, properly aligned for
1187 the final bitwise or:
1189 then we swap, and repeat the process:
1190 frag1 addr --- address on top
1191 frag1 addr addr --- duplicate it
1192 frag1 addr frag2 --- get second fragment
1193 frag1 frag2 addr --- swap again
1194 frag1 frag2 frag3 --- get third fragment
1195 Notice that, since the third fragment is the last one, we don't
1196 bother duplicating the address this time. Now we have all the
1197 fragments on the stack, and we can simply `or' them together,
1198 yielding the final value of the bitfield. */
1200 /* The first and one-after-last bits in the field, but rounded down
1201 and up to byte boundaries. */
1202 int bound_start
= (start
/ TARGET_CHAR_BIT
) * TARGET_CHAR_BIT
;
1203 int bound_end
= (((end
+ TARGET_CHAR_BIT
- 1)
1207 /* current bit offset within the structure */
1210 /* The index in ops of the opcode we're considering. */
1213 /* The number of fragments we generated in the process. Probably
1214 equal to the number of `one' bits in bytesize, but who cares? */
1217 /* Dereference any typedefs. */
1218 type
= check_typedef (type
);
1220 /* Can we fetch the number of bits requested at all? */
1221 if ((end
- start
) > ((1 << num_ops
) * 8))
1222 internal_error (__FILE__
, __LINE__
,
1223 _("gen_bitfield_ref: bitfield too wide"));
1225 /* Note that we know here that we only need to try each opcode once.
1226 That may not be true on machines with weird byte sizes. */
1227 offset
= bound_start
;
1229 for (op
= num_ops
- 1; op
>= 0; op
--)
1231 /* number of bits that ops[op] would fetch */
1232 int op_size
= 8 << op
;
1234 /* The stack at this point, from bottom to top, contains zero or
1235 more fragments, then the address. */
1237 /* Does this fetch fit within the bitfield? */
1238 if (offset
+ op_size
<= bound_end
)
1240 /* Is this the last fragment? */
1241 int last_frag
= (offset
+ op_size
== bound_end
);
1244 ax_simple (ax
, aop_dup
); /* keep a copy of the address */
1246 /* Add the offset. */
1247 gen_offset (ax
, offset
/ TARGET_CHAR_BIT
);
1251 /* Record the area of memory we're about to fetch. */
1252 ax_trace_quick (ax
, op_size
/ TARGET_CHAR_BIT
);
1255 /* Perform the fetch. */
1256 ax_simple (ax
, ops
[op
]);
1258 /* Shift the bits we have to their proper position.
1259 gen_left_shift will generate right shifts when the operand
1262 A big-endian field diagram to ponder:
1263 byte 0 byte 1 byte 2 byte 3 byte 4 byte 5 byte 6 byte 7
1264 +------++------++------++------++------++------++------++------+
1265 xxxxAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCxxxxxxxxxxx
1267 bit number 16 32 48 53
1268 These are bit numbers as supplied by GDB. Note that the
1269 bit numbers run from right to left once you've fetched the
1272 A little-endian field diagram to ponder:
1273 byte 7 byte 6 byte 5 byte 4 byte 3 byte 2 byte 1 byte 0
1274 +------++------++------++------++------++------++------++------+
1275 xxxxxxxxxxxAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCxxxx
1277 bit number 48 32 16 4 0
1279 In both cases, the most significant end is on the left
1280 (i.e. normal numeric writing order), which means that you
1281 don't go crazy thinking about `left' and `right' shifts.
1283 We don't have to worry about masking yet:
1284 - If they contain garbage off the least significant end, then we
1285 must be looking at the low end of the field, and the right
1286 shift will wipe them out.
1287 - If they contain garbage off the most significant end, then we
1288 must be looking at the most significant end of the word, and
1289 the sign/zero extension will wipe them out.
1290 - If we're in the interior of the word, then there is no garbage
1291 on either end, because the ref operators zero-extend. */
1292 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
1293 gen_left_shift (ax
, end
- (offset
+ op_size
));
1295 gen_left_shift (ax
, offset
- start
);
1298 /* Bring the copy of the address up to the top. */
1299 ax_simple (ax
, aop_swap
);
1306 /* Generate enough bitwise `or' operations to combine all the
1307 fragments we left on the stack. */
1308 while (fragment_count
-- > 1)
1309 ax_simple (ax
, aop_bit_or
);
1311 /* Sign- or zero-extend the value as appropriate. */
1312 ((TYPE_UNSIGNED (type
) ? ax_zero_ext
: ax_ext
) (ax
, end
- start
));
1314 /* This is *not* an lvalue. Ugh. */
1315 value
->kind
= axs_rvalue
;
1320 /* Generate code to reference the member named FIELD of a structure or
1321 union. The top of the stack, as described by VALUE, should have
1322 type (pointer to a)* struct/union. OPERATOR_NAME is the name of
1323 the operator being compiled, and OPERAND_NAME is the kind of thing
1324 it operates on; we use them in error messages. */
1326 gen_struct_ref (struct expression
*exp
, struct agent_expr
*ax
,
1327 struct axs_value
*value
, char *field
,
1328 char *operator_name
, char *operand_name
)
1333 /* Follow pointers until we reach a non-pointer. These aren't the C
1334 semantics, but they're what the normal GDB evaluator does, so we
1335 should at least be consistent. */
1336 while (pointer_type (value
->type
))
1338 require_rvalue (ax
, value
);
1339 gen_deref (ax
, value
);
1341 type
= check_typedef (value
->type
);
1343 /* This must yield a structure or a union. */
1344 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1345 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1346 error (_("The left operand of `%s' is not a %s."),
1347 operator_name
, operand_name
);
1349 /* And it must be in memory; we don't deal with structure rvalues,
1350 or structures living in registers. */
1351 if (value
->kind
!= axs_lvalue_memory
)
1352 error (_("Structure does not live in memory."));
1354 i
= find_field (type
, field
);
1356 /* Is this a bitfield? */
1357 if (TYPE_FIELD_PACKED (type
, i
))
1358 gen_bitfield_ref (exp
, ax
, value
, TYPE_FIELD_TYPE (type
, i
),
1359 TYPE_FIELD_BITPOS (type
, i
),
1360 (TYPE_FIELD_BITPOS (type
, i
)
1361 + TYPE_FIELD_BITSIZE (type
, i
)));
1364 gen_offset (ax
, TYPE_FIELD_BITPOS (type
, i
) / TARGET_CHAR_BIT
);
1365 value
->kind
= axs_lvalue_memory
;
1366 value
->type
= TYPE_FIELD_TYPE (type
, i
);
1371 /* Generate code for GDB's magical `repeat' operator.
1372 LVALUE @ INT creates an array INT elements long, and whose elements
1373 have the same type as LVALUE, located in memory so that LVALUE is
1374 its first element. For example, argv[0]@argc gives you the array
1375 of command-line arguments.
1377 Unfortunately, because we have to know the types before we actually
1378 have a value for the expression, we can't implement this perfectly
1379 without changing the type system, having values that occupy two
1380 stack slots, doing weird things with sizeof, etc. So we require
1381 the right operand to be a constant expression. */
1383 gen_repeat (struct expression
*exp
, union exp_element
**pc
,
1384 struct agent_expr
*ax
, struct axs_value
*value
)
1386 struct axs_value value1
;
1387 /* We don't want to turn this into an rvalue, so no conversions
1389 gen_expr (exp
, pc
, ax
, &value1
);
1390 if (value1
.kind
!= axs_lvalue_memory
)
1391 error (_("Left operand of `@' must be an object in memory."));
1393 /* Evaluate the length; it had better be a constant. */
1395 struct value
*v
= const_expr (pc
);
1399 error (_("Right operand of `@' must be a constant, in agent expressions."));
1400 if (TYPE_CODE (value_type (v
)) != TYPE_CODE_INT
)
1401 error (_("Right operand of `@' must be an integer."));
1402 length
= value_as_long (v
);
1404 error (_("Right operand of `@' must be positive."));
1406 /* The top of the stack is already the address of the object, so
1407 all we need to do is frob the type of the lvalue. */
1409 /* FIXME-type-allocation: need a way to free this type when we are
1412 = lookup_array_range_type (value1
.type
, 0, length
- 1);
1414 value
->kind
= axs_lvalue_memory
;
1415 value
->type
= array
;
1421 /* Emit code for the `sizeof' operator.
1422 *PC should point at the start of the operand expression; we advance it
1423 to the first instruction after the operand. */
1425 gen_sizeof (struct expression
*exp
, union exp_element
**pc
,
1426 struct agent_expr
*ax
, struct axs_value
*value
,
1427 struct type
*size_type
)
1429 /* We don't care about the value of the operand expression; we only
1430 care about its type. However, in the current arrangement, the
1431 only way to find an expression's type is to generate code for it.
1432 So we generate code for the operand, and then throw it away,
1433 replacing it with code that simply pushes its size. */
1434 int start
= ax
->len
;
1435 gen_expr (exp
, pc
, ax
, value
);
1437 /* Throw away the code we just generated. */
1440 ax_const_l (ax
, TYPE_LENGTH (value
->type
));
1441 value
->kind
= axs_rvalue
;
1442 value
->type
= size_type
;
1446 /* Generating bytecode from GDB expressions: general recursive thingy */
1449 /* A gen_expr function written by a Gen-X'er guy.
1450 Append code for the subexpression of EXPR starting at *POS_P to AX. */
1452 gen_expr (struct expression
*exp
, union exp_element
**pc
,
1453 struct agent_expr
*ax
, struct axs_value
*value
)
1455 /* Used to hold the descriptions of operand expressions. */
1456 struct axs_value value1
, value2
, value3
;
1457 enum exp_opcode op
= (*pc
)[0].opcode
, op2
;
1458 int if1
, go1
, if2
, go2
, end
;
1460 /* If we're looking at a constant expression, just push its value. */
1462 struct value
*v
= maybe_const_expr (pc
);
1466 ax_const_l (ax
, value_as_long (v
));
1467 value
->kind
= axs_rvalue
;
1468 value
->type
= check_typedef (value_type (v
));
1473 /* Otherwise, go ahead and generate code for it. */
1476 /* Binary arithmetic operators. */
1482 case BINOP_SUBSCRIPT
:
1483 case BINOP_BITWISE_AND
:
1484 case BINOP_BITWISE_IOR
:
1485 case BINOP_BITWISE_XOR
:
1487 case BINOP_NOTEQUAL
:
1493 gen_expr (exp
, pc
, ax
, &value1
);
1494 gen_usual_unary (exp
, ax
, &value1
);
1495 gen_expr_binop_rest (exp
, op
, pc
, ax
, value
, &value1
, &value2
);
1498 case BINOP_LOGICAL_AND
:
1500 /* Generate the obvious sequence of tests and jumps. */
1501 gen_expr (exp
, pc
, ax
, &value1
);
1502 gen_usual_unary (exp
, ax
, &value1
);
1503 if1
= ax_goto (ax
, aop_if_goto
);
1504 go1
= ax_goto (ax
, aop_goto
);
1505 ax_label (ax
, if1
, ax
->len
);
1506 gen_expr (exp
, pc
, ax
, &value2
);
1507 gen_usual_unary (exp
, ax
, &value2
);
1508 if2
= ax_goto (ax
, aop_if_goto
);
1509 go2
= ax_goto (ax
, aop_goto
);
1510 ax_label (ax
, if2
, ax
->len
);
1512 end
= ax_goto (ax
, aop_goto
);
1513 ax_label (ax
, go1
, ax
->len
);
1514 ax_label (ax
, go2
, ax
->len
);
1516 ax_label (ax
, end
, ax
->len
);
1517 value
->kind
= axs_rvalue
;
1518 value
->type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1521 case BINOP_LOGICAL_OR
:
1523 /* Generate the obvious sequence of tests and jumps. */
1524 gen_expr (exp
, pc
, ax
, &value1
);
1525 gen_usual_unary (exp
, ax
, &value1
);
1526 if1
= ax_goto (ax
, aop_if_goto
);
1527 gen_expr (exp
, pc
, ax
, &value2
);
1528 gen_usual_unary (exp
, ax
, &value2
);
1529 if2
= ax_goto (ax
, aop_if_goto
);
1531 end
= ax_goto (ax
, aop_goto
);
1532 ax_label (ax
, if1
, ax
->len
);
1533 ax_label (ax
, if2
, ax
->len
);
1535 ax_label (ax
, end
, ax
->len
);
1536 value
->kind
= axs_rvalue
;
1537 value
->type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1542 gen_expr (exp
, pc
, ax
, &value1
);
1543 gen_usual_unary (exp
, ax
, &value1
);
1544 /* For (A ? B : C), it's easiest to generate subexpression
1545 bytecodes in order, but if_goto jumps on true, so we invert
1546 the sense of A. Then we can do B by dropping through, and
1548 gen_logical_not (ax
, &value1
,
1549 language_bool_type (exp
->language_defn
, exp
->gdbarch
));
1550 if1
= ax_goto (ax
, aop_if_goto
);
1551 gen_expr (exp
, pc
, ax
, &value2
);
1552 gen_usual_unary (exp
, ax
, &value2
);
1553 end
= ax_goto (ax
, aop_goto
);
1554 ax_label (ax
, if1
, ax
->len
);
1555 gen_expr (exp
, pc
, ax
, &value3
);
1556 gen_usual_unary (exp
, ax
, &value3
);
1557 ax_label (ax
, end
, ax
->len
);
1558 /* This is arbitary - what if B and C are incompatible types? */
1559 value
->type
= value2
.type
;
1560 value
->kind
= value2
.kind
;
1565 if ((*pc
)[0].opcode
== OP_INTERNALVAR
)
1567 char *name
= internalvar_name ((*pc
)[1].internalvar
);
1568 struct trace_state_variable
*tsv
;
1570 gen_expr (exp
, pc
, ax
, value
);
1571 tsv
= find_trace_state_variable (name
);
1574 ax_tsv (ax
, aop_setv
, tsv
->number
);
1576 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1579 error (_("$%s is not a trace state variable, may not assign to it"), name
);
1582 error (_("May only assign to trace state variables"));
1585 case BINOP_ASSIGN_MODIFY
:
1587 op2
= (*pc
)[0].opcode
;
1590 if ((*pc
)[0].opcode
== OP_INTERNALVAR
)
1592 char *name
= internalvar_name ((*pc
)[1].internalvar
);
1593 struct trace_state_variable
*tsv
;
1595 tsv
= find_trace_state_variable (name
);
1598 /* The tsv will be the left half of the binary operation. */
1599 ax_tsv (ax
, aop_getv
, tsv
->number
);
1601 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1602 /* Trace state variables are always 64-bit integers. */
1603 value1
.kind
= axs_rvalue
;
1604 value1
.type
= builtin_type (exp
->gdbarch
)->builtin_long_long
;
1605 /* Now do right half of expression. */
1606 gen_expr_binop_rest (exp
, op2
, pc
, ax
, value
, &value1
, &value2
);
1607 /* We have a result of the binary op, set the tsv. */
1608 ax_tsv (ax
, aop_setv
, tsv
->number
);
1610 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1613 error (_("$%s is not a trace state variable, may not assign to it"), name
);
1616 error (_("May only assign to trace state variables"));
1619 /* Note that we need to be a little subtle about generating code
1620 for comma. In C, we can do some optimizations here because
1621 we know the left operand is only being evaluated for effect.
1622 However, if the tracing kludge is in effect, then we always
1623 need to evaluate the left hand side fully, so that all the
1624 variables it mentions get traced. */
1627 gen_expr (exp
, pc
, ax
, &value1
);
1628 /* Don't just dispose of the left operand. We might be tracing,
1629 in which case we want to emit code to trace it if it's an
1631 gen_traced_pop (ax
, &value1
);
1632 gen_expr (exp
, pc
, ax
, value
);
1633 /* It's the consumer's responsibility to trace the right operand. */
1636 case OP_LONG
: /* some integer constant */
1638 struct type
*type
= (*pc
)[1].type
;
1639 LONGEST k
= (*pc
)[2].longconst
;
1641 gen_int_literal (ax
, value
, k
, type
);
1646 gen_var_ref (exp
->gdbarch
, ax
, value
, (*pc
)[2].symbol
);
1652 const char *name
= &(*pc
)[2].string
;
1654 (*pc
) += 4 + BYTES_TO_EXP_ELEM ((*pc
)[1].longconst
+ 1);
1655 reg
= user_reg_map_name_to_regnum (exp
->gdbarch
, name
, strlen (name
));
1657 internal_error (__FILE__
, __LINE__
,
1658 _("Register $%s not available"), name
);
1659 if (reg
>= gdbarch_num_regs (exp
->gdbarch
))
1660 error (_("'%s' is a pseudo-register; "
1661 "GDB cannot yet trace pseudoregister contents."),
1663 value
->kind
= axs_lvalue_register
;
1665 value
->type
= register_type (exp
->gdbarch
, reg
);
1669 case OP_INTERNALVAR
:
1671 const char *name
= internalvar_name ((*pc
)[1].internalvar
);
1672 struct trace_state_variable
*tsv
;
1674 tsv
= find_trace_state_variable (name
);
1677 ax_tsv (ax
, aop_getv
, tsv
->number
);
1679 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1680 /* Trace state variables are always 64-bit integers. */
1681 value
->kind
= axs_rvalue
;
1682 value
->type
= builtin_type (exp
->gdbarch
)->builtin_long_long
;
1685 error (_("$%s is not a trace state variable; GDB agent expressions cannot use convenience variables."), name
);
1689 /* Weirdo operator: see comments for gen_repeat for details. */
1691 /* Note that gen_repeat handles its own argument evaluation. */
1693 gen_repeat (exp
, pc
, ax
, value
);
1698 struct type
*type
= (*pc
)[1].type
;
1700 gen_expr (exp
, pc
, ax
, value
);
1701 gen_cast (ax
, value
, type
);
1707 struct type
*type
= check_typedef ((*pc
)[1].type
);
1709 gen_expr (exp
, pc
, ax
, value
);
1710 /* I'm not sure I understand UNOP_MEMVAL entirely. I think
1711 it's just a hack for dealing with minsyms; you take some
1712 integer constant, pretend it's the address of an lvalue of
1713 the given type, and dereference it. */
1714 if (value
->kind
!= axs_rvalue
)
1715 /* This would be weird. */
1716 internal_error (__FILE__
, __LINE__
,
1717 _("gen_expr: OP_MEMVAL operand isn't an rvalue???"));
1719 value
->kind
= axs_lvalue_memory
;
1725 /* + FOO is equivalent to 0 + FOO, which can be optimized. */
1726 gen_expr (exp
, pc
, ax
, value
);
1727 gen_usual_unary (exp
, ax
, value
);
1732 /* -FOO is equivalent to 0 - FOO. */
1733 gen_int_literal (ax
, &value1
, 0,
1734 builtin_type (exp
->gdbarch
)->builtin_int
);
1735 gen_usual_unary (exp
, ax
, &value1
); /* shouldn't do much */
1736 gen_expr (exp
, pc
, ax
, &value2
);
1737 gen_usual_unary (exp
, ax
, &value2
);
1738 gen_usual_arithmetic (exp
, ax
, &value1
, &value2
);
1739 gen_binop (ax
, value
, &value1
, &value2
, aop_sub
, aop_sub
, 1, "negation");
1742 case UNOP_LOGICAL_NOT
:
1744 gen_expr (exp
, pc
, ax
, value
);
1745 gen_usual_unary (exp
, ax
, value
);
1746 gen_logical_not (ax
, value
,
1747 language_bool_type (exp
->language_defn
, exp
->gdbarch
));
1750 case UNOP_COMPLEMENT
:
1752 gen_expr (exp
, pc
, ax
, value
);
1753 gen_usual_unary (exp
, ax
, value
);
1754 gen_integral_promotions (exp
, ax
, value
);
1755 gen_complement (ax
, value
);
1760 gen_expr (exp
, pc
, ax
, value
);
1761 gen_usual_unary (exp
, ax
, value
);
1762 if (!pointer_type (value
->type
))
1763 error (_("Argument of unary `*' is not a pointer."));
1764 gen_deref (ax
, value
);
1769 gen_expr (exp
, pc
, ax
, value
);
1770 gen_address_of (ax
, value
);
1775 /* Notice that gen_sizeof handles its own operand, unlike most
1776 of the other unary operator functions. This is because we
1777 have to throw away the code we generate. */
1778 gen_sizeof (exp
, pc
, ax
, value
,
1779 builtin_type (exp
->gdbarch
)->builtin_int
);
1782 case STRUCTOP_STRUCT
:
1785 int length
= (*pc
)[1].longconst
;
1786 char *name
= &(*pc
)[2].string
;
1788 (*pc
) += 4 + BYTES_TO_EXP_ELEM (length
+ 1);
1789 gen_expr (exp
, pc
, ax
, value
);
1790 if (op
== STRUCTOP_STRUCT
)
1791 gen_struct_ref (exp
, ax
, value
, name
, ".", "structure or union");
1792 else if (op
== STRUCTOP_PTR
)
1793 gen_struct_ref (exp
, ax
, value
, name
, "->",
1794 "pointer to a structure or union");
1796 /* If this `if' chain doesn't handle it, then the case list
1797 shouldn't mention it, and we shouldn't be here. */
1798 internal_error (__FILE__
, __LINE__
,
1799 _("gen_expr: unhandled struct case"));
1806 struct symbol
*func
, *sym
;
1809 func
= block_linkage_function (block_for_pc (ax
->scope
));
1810 this_name
= language_def (SYMBOL_LANGUAGE (func
))->la_name_of_this
;
1811 b
= SYMBOL_BLOCK_VALUE (func
);
1813 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
1814 symbol instead of the LOC_ARG one (if both exist). */
1815 sym
= lookup_block_symbol (b
, this_name
, VAR_DOMAIN
);
1817 error (_("no `%s' found"), this_name
);
1819 gen_var_ref (exp
->gdbarch
, ax
, value
, sym
);
1825 error (_("Attempt to use a type name as an expression."));
1828 error (_("Unsupported operator in expression."));
1832 /* This handles the middle-to-right-side of code generation for binary
1833 expressions, which is shared between regular binary operations and
1834 assign-modify (+= and friends) expressions. */
1837 gen_expr_binop_rest (struct expression
*exp
,
1838 enum exp_opcode op
, union exp_element
**pc
,
1839 struct agent_expr
*ax
, struct axs_value
*value
,
1840 struct axs_value
*value1
, struct axs_value
*value2
)
1842 gen_expr (exp
, pc
, ax
, value2
);
1843 gen_usual_unary (exp
, ax
, value2
);
1844 gen_usual_arithmetic (exp
, ax
, value1
, value2
);
1848 if (TYPE_CODE (value1
->type
) == TYPE_CODE_INT
1849 && pointer_type (value2
->type
))
1851 /* Swap the values and proceed normally. */
1852 ax_simple (ax
, aop_swap
);
1853 gen_ptradd (ax
, value
, value2
, value1
);
1855 else if (pointer_type (value1
->type
)
1856 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
1857 gen_ptradd (ax
, value
, value1
, value2
);
1859 gen_binop (ax
, value
, value1
, value2
,
1860 aop_add
, aop_add
, 1, "addition");
1863 if (pointer_type (value1
->type
)
1864 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
1865 gen_ptrsub (ax
,value
, value1
, value2
);
1866 else if (pointer_type (value1
->type
)
1867 && pointer_type (value2
->type
))
1868 /* FIXME --- result type should be ptrdiff_t */
1869 gen_ptrdiff (ax
, value
, value1
, value2
,
1870 builtin_type (exp
->gdbarch
)->builtin_long
);
1872 gen_binop (ax
, value
, value1
, value2
,
1873 aop_sub
, aop_sub
, 1, "subtraction");
1876 gen_binop (ax
, value
, value1
, value2
,
1877 aop_mul
, aop_mul
, 1, "multiplication");
1880 gen_binop (ax
, value
, value1
, value2
,
1881 aop_div_signed
, aop_div_unsigned
, 1, "division");
1884 gen_binop (ax
, value
, value1
, value2
,
1885 aop_rem_signed
, aop_rem_unsigned
, 1, "remainder");
1887 case BINOP_SUBSCRIPT
:
1891 if (binop_types_user_defined_p (op
, value1
->type
, value2
->type
))
1894 cannot subscript requested type: cannot call user defined functions"));
1898 /* If the user attempts to subscript something that is not
1899 an array or pointer type (like a plain int variable for
1900 example), then report this as an error. */
1901 type
= check_typedef (value1
->type
);
1902 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
1903 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1905 if (TYPE_NAME (type
))
1906 error (_("cannot subscript something of type `%s'"),
1909 error (_("cannot subscript requested type"));
1913 if (!is_integral_type (value2
->type
))
1914 error (_("Argument to arithmetic operation not a number or boolean."));
1916 gen_ptradd (ax
, value
, value1
, value2
);
1917 gen_deref (ax
, value
);
1920 case BINOP_BITWISE_AND
:
1921 gen_binop (ax
, value
, value1
, value2
,
1922 aop_bit_and
, aop_bit_and
, 0, "bitwise and");
1925 case BINOP_BITWISE_IOR
:
1926 gen_binop (ax
, value
, value1
, value2
,
1927 aop_bit_or
, aop_bit_or
, 0, "bitwise or");
1930 case BINOP_BITWISE_XOR
:
1931 gen_binop (ax
, value
, value1
, value2
,
1932 aop_bit_xor
, aop_bit_xor
, 0, "bitwise exclusive-or");
1936 gen_binop (ax
, value
, value1
, value2
,
1937 aop_equal
, aop_equal
, 0, "equal");
1940 case BINOP_NOTEQUAL
:
1941 gen_binop (ax
, value
, value1
, value2
,
1942 aop_equal
, aop_equal
, 0, "equal");
1943 gen_logical_not (ax
, value
,
1944 language_bool_type (exp
->language_defn
,
1949 gen_binop (ax
, value
, value1
, value2
,
1950 aop_less_signed
, aop_less_unsigned
, 0, "less than");
1954 ax_simple (ax
, aop_swap
);
1955 gen_binop (ax
, value
, value1
, value2
,
1956 aop_less_signed
, aop_less_unsigned
, 0, "less than");
1960 ax_simple (ax
, aop_swap
);
1961 gen_binop (ax
, value
, value1
, value2
,
1962 aop_less_signed
, aop_less_unsigned
, 0, "less than");
1963 gen_logical_not (ax
, value
,
1964 language_bool_type (exp
->language_defn
,
1969 gen_binop (ax
, value
, value1
, value2
,
1970 aop_less_signed
, aop_less_unsigned
, 0, "less than");
1971 gen_logical_not (ax
, value
,
1972 language_bool_type (exp
->language_defn
,
1977 /* We should only list operators in the outer case statement
1978 that we actually handle in the inner case statement. */
1979 internal_error (__FILE__
, __LINE__
,
1980 _("gen_expr: op case sets don't match"));
1985 /* Given a single variable and a scope, generate bytecodes to trace
1986 its value. This is for use in situations where we have only a
1987 variable's name, and no parsed expression; for instance, when the
1988 name comes from a list of local variables of a function. */
1991 gen_trace_for_var (CORE_ADDR scope
, struct symbol
*var
)
1993 struct cleanup
*old_chain
= 0;
1994 struct agent_expr
*ax
= new_agent_expr (scope
);
1995 struct axs_value value
;
1997 old_chain
= make_cleanup_free_agent_expr (ax
);
2000 gen_var_ref (NULL
, ax
, &value
, var
);
2002 /* Make sure we record the final object, and get rid of it. */
2003 gen_traced_pop (ax
, &value
);
2005 /* Oh, and terminate. */
2006 ax_simple (ax
, aop_end
);
2008 /* We have successfully built the agent expr, so cancel the cleanup
2009 request. If we add more cleanups that we always want done, this
2010 will have to get more complicated. */
2011 discard_cleanups (old_chain
);
2015 /* Generating bytecode from GDB expressions: driver */
2017 /* Given a GDB expression EXPR, return bytecode to trace its value.
2018 The result will use the `trace' and `trace_quick' bytecodes to
2019 record the value of all memory touched by the expression. The
2020 caller can then use the ax_reqs function to discover which
2021 registers it relies upon. */
2023 gen_trace_for_expr (CORE_ADDR scope
, struct expression
*expr
)
2025 struct cleanup
*old_chain
= 0;
2026 struct agent_expr
*ax
= new_agent_expr (scope
);
2027 union exp_element
*pc
;
2028 struct axs_value value
;
2030 old_chain
= make_cleanup_free_agent_expr (ax
);
2034 gen_expr (expr
, &pc
, ax
, &value
);
2036 /* Make sure we record the final object, and get rid of it. */
2037 gen_traced_pop (ax
, &value
);
2039 /* Oh, and terminate. */
2040 ax_simple (ax
, aop_end
);
2042 /* We have successfully built the agent expr, so cancel the cleanup
2043 request. If we add more cleanups that we always want done, this
2044 will have to get more complicated. */
2045 discard_cleanups (old_chain
);
2049 /* Given a GDB expression EXPR, return a bytecode sequence that will
2050 evaluate and return a result. The bytecodes will do a direct
2051 evaluation, using the current data on the target, rather than
2052 recording blocks of memory and registers for later use, as
2053 gen_trace_for_expr does. The generated bytecode sequence leaves
2054 the result of expression evaluation on the top of the stack. */
2057 gen_eval_for_expr (CORE_ADDR scope
, struct expression
*expr
)
2059 struct cleanup
*old_chain
= 0;
2060 struct agent_expr
*ax
= new_agent_expr (scope
);
2061 union exp_element
*pc
;
2062 struct axs_value value
;
2064 old_chain
= make_cleanup_free_agent_expr (ax
);
2068 gen_expr (expr
, &pc
, ax
, &value
);
2070 /* Oh, and terminate. */
2071 ax_simple (ax
, aop_end
);
2073 /* We have successfully built the agent expr, so cancel the cleanup
2074 request. If we add more cleanups that we always want done, this
2075 will have to get more complicated. */
2076 discard_cleanups (old_chain
);
2081 agent_command (char *exp
, int from_tty
)
2083 struct cleanup
*old_chain
= 0;
2084 struct expression
*expr
;
2085 struct agent_expr
*agent
;
2086 struct frame_info
*fi
= get_current_frame (); /* need current scope */
2088 /* We don't deal with overlay debugging at the moment. We need to
2089 think more carefully about this. If you copy this code into
2090 another command, change the error message; the user shouldn't
2091 have to know anything about agent expressions. */
2092 if (overlay_debugging
)
2093 error (_("GDB can't do agent expression translation with overlays."));
2096 error_no_arg (_("expression to translate"));
2098 expr
= parse_expression (exp
);
2099 old_chain
= make_cleanup (free_current_contents
, &expr
);
2100 agent
= gen_trace_for_expr (get_frame_pc (fi
), expr
);
2101 make_cleanup_free_agent_expr (agent
);
2102 ax_print (gdb_stdout
, agent
);
2104 /* It would be nice to call ax_reqs here to gather some general info
2105 about the expression, and then print out the result. */
2107 do_cleanups (old_chain
);
2111 /* Parse the given expression, compile it into an agent expression
2112 that does direct evaluation, and display the resulting
2116 agent_eval_command (char *exp
, int from_tty
)
2118 struct cleanup
*old_chain
= 0;
2119 struct expression
*expr
;
2120 struct agent_expr
*agent
;
2121 struct frame_info
*fi
= get_current_frame (); /* need current scope */
2123 /* We don't deal with overlay debugging at the moment. We need to
2124 think more carefully about this. If you copy this code into
2125 another command, change the error message; the user shouldn't
2126 have to know anything about agent expressions. */
2127 if (overlay_debugging
)
2128 error (_("GDB can't do agent expression translation with overlays."));
2131 error_no_arg (_("expression to translate"));
2133 expr
= parse_expression (exp
);
2134 old_chain
= make_cleanup (free_current_contents
, &expr
);
2135 agent
= gen_eval_for_expr (get_frame_pc (fi
), expr
);
2136 make_cleanup_free_agent_expr (agent
);
2137 ax_print (gdb_stdout
, agent
);
2139 /* It would be nice to call ax_reqs here to gather some general info
2140 about the expression, and then print out the result. */
2142 do_cleanups (old_chain
);
2147 /* Initialization code. */
2149 void _initialize_ax_gdb (void);
2151 _initialize_ax_gdb (void)
2153 add_cmd ("agent", class_maintenance
, agent_command
,
2154 _("Translate an expression into remote agent bytecode for tracing."),
2157 add_cmd ("agent-eval", class_maintenance
, agent_eval_command
,
2158 _("Translate an expression into remote agent bytecode for evaluation."),
This page took 0.07857 seconds and 4 git commands to generate.