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 value
->kind
= ((TYPE_CODE (value
->type
) == TYPE_CODE_FUNC
)
1086 ? axs_rvalue
: axs_lvalue_memory
);
1090 /* Produce the address of the lvalue on the top of the stack. */
1092 gen_address_of (struct agent_expr
*ax
, struct axs_value
*value
)
1094 /* Special case for taking the address of a function. The ANSI
1095 standard describes this as a special case, too, so this
1096 arrangement is not without motivation. */
1097 if (TYPE_CODE (value
->type
) == TYPE_CODE_FUNC
)
1098 /* The value's already an rvalue on the stack, so we just need to
1100 value
->type
= lookup_pointer_type (value
->type
);
1102 switch (value
->kind
)
1105 error (_("Operand of `&' is an rvalue, which has no address."));
1107 case axs_lvalue_register
:
1108 error (_("Operand of `&' is in a register, and has no address."));
1110 case axs_lvalue_memory
:
1111 value
->kind
= axs_rvalue
;
1112 value
->type
= lookup_pointer_type (value
->type
);
1118 /* A lot of this stuff will have to change to support C++. But we're
1119 not going to deal with that at the moment. */
1121 /* Find the field in the structure type TYPE named NAME, and return
1122 its index in TYPE's field array. */
1124 find_field (struct type
*type
, char *name
)
1128 CHECK_TYPEDEF (type
);
1130 /* Make sure this isn't C++. */
1131 if (TYPE_N_BASECLASSES (type
) != 0)
1132 internal_error (__FILE__
, __LINE__
,
1133 _("find_field: derived classes supported"));
1135 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1137 char *this_name
= TYPE_FIELD_NAME (type
, i
);
1141 if (strcmp (name
, this_name
) == 0)
1144 if (this_name
[0] == '\0')
1145 internal_error (__FILE__
, __LINE__
,
1146 _("find_field: anonymous unions not supported"));
1150 error (_("Couldn't find member named `%s' in struct/union `%s'"),
1151 name
, TYPE_TAG_NAME (type
));
1157 /* Generate code to push the value of a bitfield of a structure whose
1158 address is on the top of the stack. START and END give the
1159 starting and one-past-ending *bit* numbers of the field within the
1162 gen_bitfield_ref (struct expression
*exp
, struct agent_expr
*ax
,
1163 struct axs_value
*value
, struct type
*type
,
1166 /* Note that ops[i] fetches 8 << i bits. */
1167 static enum agent_op ops
[]
1169 {aop_ref8
, aop_ref16
, aop_ref32
, aop_ref64
};
1170 static int num_ops
= (sizeof (ops
) / sizeof (ops
[0]));
1172 /* We don't want to touch any byte that the bitfield doesn't
1173 actually occupy; we shouldn't make any accesses we're not
1174 explicitly permitted to. We rely here on the fact that the
1175 bytecode `ref' operators work on unaligned addresses.
1177 It takes some fancy footwork to get the stack to work the way
1178 we'd like. Say we're retrieving a bitfield that requires three
1179 fetches. Initially, the stack just contains the address:
1181 For the first fetch, we duplicate the address
1183 then add the byte offset, do the fetch, and shift and mask as
1184 needed, yielding a fragment of the value, properly aligned for
1185 the final bitwise or:
1187 then we swap, and repeat the process:
1188 frag1 addr --- address on top
1189 frag1 addr addr --- duplicate it
1190 frag1 addr frag2 --- get second fragment
1191 frag1 frag2 addr --- swap again
1192 frag1 frag2 frag3 --- get third fragment
1193 Notice that, since the third fragment is the last one, we don't
1194 bother duplicating the address this time. Now we have all the
1195 fragments on the stack, and we can simply `or' them together,
1196 yielding the final value of the bitfield. */
1198 /* The first and one-after-last bits in the field, but rounded down
1199 and up to byte boundaries. */
1200 int bound_start
= (start
/ TARGET_CHAR_BIT
) * TARGET_CHAR_BIT
;
1201 int bound_end
= (((end
+ TARGET_CHAR_BIT
- 1)
1205 /* current bit offset within the structure */
1208 /* The index in ops of the opcode we're considering. */
1211 /* The number of fragments we generated in the process. Probably
1212 equal to the number of `one' bits in bytesize, but who cares? */
1215 /* Dereference any typedefs. */
1216 type
= check_typedef (type
);
1218 /* Can we fetch the number of bits requested at all? */
1219 if ((end
- start
) > ((1 << num_ops
) * 8))
1220 internal_error (__FILE__
, __LINE__
,
1221 _("gen_bitfield_ref: bitfield too wide"));
1223 /* Note that we know here that we only need to try each opcode once.
1224 That may not be true on machines with weird byte sizes. */
1225 offset
= bound_start
;
1227 for (op
= num_ops
- 1; op
>= 0; op
--)
1229 /* number of bits that ops[op] would fetch */
1230 int op_size
= 8 << op
;
1232 /* The stack at this point, from bottom to top, contains zero or
1233 more fragments, then the address. */
1235 /* Does this fetch fit within the bitfield? */
1236 if (offset
+ op_size
<= bound_end
)
1238 /* Is this the last fragment? */
1239 int last_frag
= (offset
+ op_size
== bound_end
);
1242 ax_simple (ax
, aop_dup
); /* keep a copy of the address */
1244 /* Add the offset. */
1245 gen_offset (ax
, offset
/ TARGET_CHAR_BIT
);
1249 /* Record the area of memory we're about to fetch. */
1250 ax_trace_quick (ax
, op_size
/ TARGET_CHAR_BIT
);
1253 /* Perform the fetch. */
1254 ax_simple (ax
, ops
[op
]);
1256 /* Shift the bits we have to their proper position.
1257 gen_left_shift will generate right shifts when the operand
1260 A big-endian field diagram to ponder:
1261 byte 0 byte 1 byte 2 byte 3 byte 4 byte 5 byte 6 byte 7
1262 +------++------++------++------++------++------++------++------+
1263 xxxxAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCxxxxxxxxxxx
1265 bit number 16 32 48 53
1266 These are bit numbers as supplied by GDB. Note that the
1267 bit numbers run from right to left once you've fetched the
1270 A little-endian field diagram to ponder:
1271 byte 7 byte 6 byte 5 byte 4 byte 3 byte 2 byte 1 byte 0
1272 +------++------++------++------++------++------++------++------+
1273 xxxxxxxxxxxAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCxxxx
1275 bit number 48 32 16 4 0
1277 In both cases, the most significant end is on the left
1278 (i.e. normal numeric writing order), which means that you
1279 don't go crazy thinking about `left' and `right' shifts.
1281 We don't have to worry about masking yet:
1282 - If they contain garbage off the least significant end, then we
1283 must be looking at the low end of the field, and the right
1284 shift will wipe them out.
1285 - If they contain garbage off the most significant end, then we
1286 must be looking at the most significant end of the word, and
1287 the sign/zero extension will wipe them out.
1288 - If we're in the interior of the word, then there is no garbage
1289 on either end, because the ref operators zero-extend. */
1290 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
1291 gen_left_shift (ax
, end
- (offset
+ op_size
));
1293 gen_left_shift (ax
, offset
- start
);
1296 /* Bring the copy of the address up to the top. */
1297 ax_simple (ax
, aop_swap
);
1304 /* Generate enough bitwise `or' operations to combine all the
1305 fragments we left on the stack. */
1306 while (fragment_count
-- > 1)
1307 ax_simple (ax
, aop_bit_or
);
1309 /* Sign- or zero-extend the value as appropriate. */
1310 ((TYPE_UNSIGNED (type
) ? ax_zero_ext
: ax_ext
) (ax
, end
- start
));
1312 /* This is *not* an lvalue. Ugh. */
1313 value
->kind
= axs_rvalue
;
1318 /* Generate code to reference the member named FIELD of a structure or
1319 union. The top of the stack, as described by VALUE, should have
1320 type (pointer to a)* struct/union. OPERATOR_NAME is the name of
1321 the operator being compiled, and OPERAND_NAME is the kind of thing
1322 it operates on; we use them in error messages. */
1324 gen_struct_ref (struct expression
*exp
, struct agent_expr
*ax
,
1325 struct axs_value
*value
, char *field
,
1326 char *operator_name
, char *operand_name
)
1331 /* Follow pointers until we reach a non-pointer. These aren't the C
1332 semantics, but they're what the normal GDB evaluator does, so we
1333 should at least be consistent. */
1334 while (pointer_type (value
->type
))
1336 require_rvalue (ax
, value
);
1337 gen_deref (ax
, value
);
1339 type
= check_typedef (value
->type
);
1341 /* This must yield a structure or a union. */
1342 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1343 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1344 error (_("The left operand of `%s' is not a %s."),
1345 operator_name
, operand_name
);
1347 /* And it must be in memory; we don't deal with structure rvalues,
1348 or structures living in registers. */
1349 if (value
->kind
!= axs_lvalue_memory
)
1350 error (_("Structure does not live in memory."));
1352 i
= find_field (type
, field
);
1354 /* Is this a bitfield? */
1355 if (TYPE_FIELD_PACKED (type
, i
))
1356 gen_bitfield_ref (exp
, ax
, value
, TYPE_FIELD_TYPE (type
, i
),
1357 TYPE_FIELD_BITPOS (type
, i
),
1358 (TYPE_FIELD_BITPOS (type
, i
)
1359 + TYPE_FIELD_BITSIZE (type
, i
)));
1362 gen_offset (ax
, TYPE_FIELD_BITPOS (type
, i
) / TARGET_CHAR_BIT
);
1363 value
->kind
= axs_lvalue_memory
;
1364 value
->type
= TYPE_FIELD_TYPE (type
, i
);
1369 /* Generate code for GDB's magical `repeat' operator.
1370 LVALUE @ INT creates an array INT elements long, and whose elements
1371 have the same type as LVALUE, located in memory so that LVALUE is
1372 its first element. For example, argv[0]@argc gives you the array
1373 of command-line arguments.
1375 Unfortunately, because we have to know the types before we actually
1376 have a value for the expression, we can't implement this perfectly
1377 without changing the type system, having values that occupy two
1378 stack slots, doing weird things with sizeof, etc. So we require
1379 the right operand to be a constant expression. */
1381 gen_repeat (struct expression
*exp
, union exp_element
**pc
,
1382 struct agent_expr
*ax
, struct axs_value
*value
)
1384 struct axs_value value1
;
1385 /* We don't want to turn this into an rvalue, so no conversions
1387 gen_expr (exp
, pc
, ax
, &value1
);
1388 if (value1
.kind
!= axs_lvalue_memory
)
1389 error (_("Left operand of `@' must be an object in memory."));
1391 /* Evaluate the length; it had better be a constant. */
1393 struct value
*v
= const_expr (pc
);
1397 error (_("Right operand of `@' must be a constant, in agent expressions."));
1398 if (TYPE_CODE (value_type (v
)) != TYPE_CODE_INT
)
1399 error (_("Right operand of `@' must be an integer."));
1400 length
= value_as_long (v
);
1402 error (_("Right operand of `@' must be positive."));
1404 /* The top of the stack is already the address of the object, so
1405 all we need to do is frob the type of the lvalue. */
1407 /* FIXME-type-allocation: need a way to free this type when we are
1410 = lookup_array_range_type (value1
.type
, 0, length
- 1);
1412 value
->kind
= axs_lvalue_memory
;
1413 value
->type
= array
;
1419 /* Emit code for the `sizeof' operator.
1420 *PC should point at the start of the operand expression; we advance it
1421 to the first instruction after the operand. */
1423 gen_sizeof (struct expression
*exp
, union exp_element
**pc
,
1424 struct agent_expr
*ax
, struct axs_value
*value
,
1425 struct type
*size_type
)
1427 /* We don't care about the value of the operand expression; we only
1428 care about its type. However, in the current arrangement, the
1429 only way to find an expression's type is to generate code for it.
1430 So we generate code for the operand, and then throw it away,
1431 replacing it with code that simply pushes its size. */
1432 int start
= ax
->len
;
1433 gen_expr (exp
, pc
, ax
, value
);
1435 /* Throw away the code we just generated. */
1438 ax_const_l (ax
, TYPE_LENGTH (value
->type
));
1439 value
->kind
= axs_rvalue
;
1440 value
->type
= size_type
;
1444 /* Generating bytecode from GDB expressions: general recursive thingy */
1447 /* A gen_expr function written by a Gen-X'er guy.
1448 Append code for the subexpression of EXPR starting at *POS_P to AX. */
1450 gen_expr (struct expression
*exp
, union exp_element
**pc
,
1451 struct agent_expr
*ax
, struct axs_value
*value
)
1453 /* Used to hold the descriptions of operand expressions. */
1454 struct axs_value value1
, value2
, value3
;
1455 enum exp_opcode op
= (*pc
)[0].opcode
, op2
;
1456 int if1
, go1
, if2
, go2
, end
;
1458 /* If we're looking at a constant expression, just push its value. */
1460 struct value
*v
= maybe_const_expr (pc
);
1464 ax_const_l (ax
, value_as_long (v
));
1465 value
->kind
= axs_rvalue
;
1466 value
->type
= check_typedef (value_type (v
));
1471 /* Otherwise, go ahead and generate code for it. */
1474 /* Binary arithmetic operators. */
1480 case BINOP_SUBSCRIPT
:
1481 case BINOP_BITWISE_AND
:
1482 case BINOP_BITWISE_IOR
:
1483 case BINOP_BITWISE_XOR
:
1485 case BINOP_NOTEQUAL
:
1491 gen_expr (exp
, pc
, ax
, &value1
);
1492 gen_usual_unary (exp
, ax
, &value1
);
1493 gen_expr_binop_rest (exp
, op
, pc
, ax
, value
, &value1
, &value2
);
1496 case BINOP_LOGICAL_AND
:
1498 /* Generate the obvious sequence of tests and jumps. */
1499 gen_expr (exp
, pc
, ax
, &value1
);
1500 gen_usual_unary (exp
, ax
, &value1
);
1501 if1
= ax_goto (ax
, aop_if_goto
);
1502 go1
= ax_goto (ax
, aop_goto
);
1503 ax_label (ax
, if1
, ax
->len
);
1504 gen_expr (exp
, pc
, ax
, &value2
);
1505 gen_usual_unary (exp
, ax
, &value2
);
1506 if2
= ax_goto (ax
, aop_if_goto
);
1507 go2
= ax_goto (ax
, aop_goto
);
1508 ax_label (ax
, if2
, ax
->len
);
1510 end
= ax_goto (ax
, aop_goto
);
1511 ax_label (ax
, go1
, ax
->len
);
1512 ax_label (ax
, go2
, ax
->len
);
1514 ax_label (ax
, end
, ax
->len
);
1515 value
->kind
= axs_rvalue
;
1516 value
->type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1519 case BINOP_LOGICAL_OR
:
1521 /* Generate the obvious sequence of tests and jumps. */
1522 gen_expr (exp
, pc
, ax
, &value1
);
1523 gen_usual_unary (exp
, ax
, &value1
);
1524 if1
= ax_goto (ax
, aop_if_goto
);
1525 gen_expr (exp
, pc
, ax
, &value2
);
1526 gen_usual_unary (exp
, ax
, &value2
);
1527 if2
= ax_goto (ax
, aop_if_goto
);
1529 end
= ax_goto (ax
, aop_goto
);
1530 ax_label (ax
, if1
, ax
->len
);
1531 ax_label (ax
, if2
, ax
->len
);
1533 ax_label (ax
, end
, ax
->len
);
1534 value
->kind
= axs_rvalue
;
1535 value
->type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1540 gen_expr (exp
, pc
, ax
, &value1
);
1541 gen_usual_unary (exp
, ax
, &value1
);
1542 /* For (A ? B : C), it's easiest to generate subexpression
1543 bytecodes in order, but if_goto jumps on true, so we invert
1544 the sense of A. Then we can do B by dropping through, and
1546 gen_logical_not (ax
, &value1
,
1547 language_bool_type (exp
->language_defn
, exp
->gdbarch
));
1548 if1
= ax_goto (ax
, aop_if_goto
);
1549 gen_expr (exp
, pc
, ax
, &value2
);
1550 gen_usual_unary (exp
, ax
, &value2
);
1551 end
= ax_goto (ax
, aop_goto
);
1552 ax_label (ax
, if1
, ax
->len
);
1553 gen_expr (exp
, pc
, ax
, &value3
);
1554 gen_usual_unary (exp
, ax
, &value3
);
1555 ax_label (ax
, end
, ax
->len
);
1556 /* This is arbitary - what if B and C are incompatible types? */
1557 value
->type
= value2
.type
;
1558 value
->kind
= value2
.kind
;
1563 if ((*pc
)[0].opcode
== OP_INTERNALVAR
)
1565 char *name
= internalvar_name ((*pc
)[1].internalvar
);
1566 struct trace_state_variable
*tsv
;
1568 gen_expr (exp
, pc
, ax
, value
);
1569 tsv
= find_trace_state_variable (name
);
1572 ax_tsv (ax
, aop_setv
, tsv
->number
);
1574 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1577 error (_("$%s is not a trace state variable, may not assign to it"), name
);
1580 error (_("May only assign to trace state variables"));
1583 case BINOP_ASSIGN_MODIFY
:
1585 op2
= (*pc
)[0].opcode
;
1588 if ((*pc
)[0].opcode
== OP_INTERNALVAR
)
1590 char *name
= internalvar_name ((*pc
)[1].internalvar
);
1591 struct trace_state_variable
*tsv
;
1593 tsv
= find_trace_state_variable (name
);
1596 /* The tsv will be the left half of the binary operation. */
1597 ax_tsv (ax
, aop_getv
, tsv
->number
);
1599 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1600 /* Trace state variables are always 64-bit integers. */
1601 value1
.kind
= axs_rvalue
;
1602 value1
.type
= builtin_type (exp
->gdbarch
)->builtin_long_long
;
1603 /* Now do right half of expression. */
1604 gen_expr_binop_rest (exp
, op2
, pc
, ax
, value
, &value1
, &value2
);
1605 /* We have a result of the binary op, set the tsv. */
1606 ax_tsv (ax
, aop_setv
, tsv
->number
);
1608 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1611 error (_("$%s is not a trace state variable, may not assign to it"), name
);
1614 error (_("May only assign to trace state variables"));
1617 /* Note that we need to be a little subtle about generating code
1618 for comma. In C, we can do some optimizations here because
1619 we know the left operand is only being evaluated for effect.
1620 However, if the tracing kludge is in effect, then we always
1621 need to evaluate the left hand side fully, so that all the
1622 variables it mentions get traced. */
1625 gen_expr (exp
, pc
, ax
, &value1
);
1626 /* Don't just dispose of the left operand. We might be tracing,
1627 in which case we want to emit code to trace it if it's an
1629 gen_traced_pop (ax
, &value1
);
1630 gen_expr (exp
, pc
, ax
, value
);
1631 /* It's the consumer's responsibility to trace the right operand. */
1634 case OP_LONG
: /* some integer constant */
1636 struct type
*type
= (*pc
)[1].type
;
1637 LONGEST k
= (*pc
)[2].longconst
;
1639 gen_int_literal (ax
, value
, k
, type
);
1644 gen_var_ref (exp
->gdbarch
, ax
, value
, (*pc
)[2].symbol
);
1650 const char *name
= &(*pc
)[2].string
;
1652 (*pc
) += 4 + BYTES_TO_EXP_ELEM ((*pc
)[1].longconst
+ 1);
1653 reg
= user_reg_map_name_to_regnum (exp
->gdbarch
, name
, strlen (name
));
1655 internal_error (__FILE__
, __LINE__
,
1656 _("Register $%s not available"), name
);
1657 if (reg
>= gdbarch_num_regs (exp
->gdbarch
))
1658 error (_("'%s' is a pseudo-register; "
1659 "GDB cannot yet trace pseudoregister contents."),
1661 value
->kind
= axs_lvalue_register
;
1663 value
->type
= register_type (exp
->gdbarch
, reg
);
1667 case OP_INTERNALVAR
:
1669 const char *name
= internalvar_name ((*pc
)[1].internalvar
);
1670 struct trace_state_variable
*tsv
;
1672 tsv
= find_trace_state_variable (name
);
1675 ax_tsv (ax
, aop_getv
, tsv
->number
);
1677 ax_tsv (ax
, aop_tracev
, tsv
->number
);
1678 /* Trace state variables are always 64-bit integers. */
1679 value
->kind
= axs_rvalue
;
1680 value
->type
= builtin_type (exp
->gdbarch
)->builtin_long_long
;
1683 error (_("$%s is not a trace state variable; GDB agent expressions cannot use convenience variables."), name
);
1687 /* Weirdo operator: see comments for gen_repeat for details. */
1689 /* Note that gen_repeat handles its own argument evaluation. */
1691 gen_repeat (exp
, pc
, ax
, value
);
1696 struct type
*type
= (*pc
)[1].type
;
1698 gen_expr (exp
, pc
, ax
, value
);
1699 gen_cast (ax
, value
, type
);
1705 struct type
*type
= check_typedef ((*pc
)[1].type
);
1707 gen_expr (exp
, pc
, ax
, value
);
1708 /* I'm not sure I understand UNOP_MEMVAL entirely. I think
1709 it's just a hack for dealing with minsyms; you take some
1710 integer constant, pretend it's the address of an lvalue of
1711 the given type, and dereference it. */
1712 if (value
->kind
!= axs_rvalue
)
1713 /* This would be weird. */
1714 internal_error (__FILE__
, __LINE__
,
1715 _("gen_expr: OP_MEMVAL operand isn't an rvalue???"));
1717 value
->kind
= axs_lvalue_memory
;
1723 /* + FOO is equivalent to 0 + FOO, which can be optimized. */
1724 gen_expr (exp
, pc
, ax
, value
);
1725 gen_usual_unary (exp
, ax
, value
);
1730 /* -FOO is equivalent to 0 - FOO. */
1731 gen_int_literal (ax
, &value1
, 0,
1732 builtin_type (exp
->gdbarch
)->builtin_int
);
1733 gen_usual_unary (exp
, ax
, &value1
); /* shouldn't do much */
1734 gen_expr (exp
, pc
, ax
, &value2
);
1735 gen_usual_unary (exp
, ax
, &value2
);
1736 gen_usual_arithmetic (exp
, ax
, &value1
, &value2
);
1737 gen_binop (ax
, value
, &value1
, &value2
, aop_sub
, aop_sub
, 1, "negation");
1740 case UNOP_LOGICAL_NOT
:
1742 gen_expr (exp
, pc
, ax
, value
);
1743 gen_usual_unary (exp
, ax
, value
);
1744 gen_logical_not (ax
, value
,
1745 language_bool_type (exp
->language_defn
, exp
->gdbarch
));
1748 case UNOP_COMPLEMENT
:
1750 gen_expr (exp
, pc
, ax
, value
);
1751 gen_usual_unary (exp
, ax
, value
);
1752 gen_integral_promotions (exp
, ax
, value
);
1753 gen_complement (ax
, value
);
1758 gen_expr (exp
, pc
, ax
, value
);
1759 gen_usual_unary (exp
, ax
, value
);
1760 if (!pointer_type (value
->type
))
1761 error (_("Argument of unary `*' is not a pointer."));
1762 gen_deref (ax
, value
);
1767 gen_expr (exp
, pc
, ax
, value
);
1768 gen_address_of (ax
, value
);
1773 /* Notice that gen_sizeof handles its own operand, unlike most
1774 of the other unary operator functions. This is because we
1775 have to throw away the code we generate. */
1776 gen_sizeof (exp
, pc
, ax
, value
,
1777 builtin_type (exp
->gdbarch
)->builtin_int
);
1780 case STRUCTOP_STRUCT
:
1783 int length
= (*pc
)[1].longconst
;
1784 char *name
= &(*pc
)[2].string
;
1786 (*pc
) += 4 + BYTES_TO_EXP_ELEM (length
+ 1);
1787 gen_expr (exp
, pc
, ax
, value
);
1788 if (op
== STRUCTOP_STRUCT
)
1789 gen_struct_ref (exp
, ax
, value
, name
, ".", "structure or union");
1790 else if (op
== STRUCTOP_PTR
)
1791 gen_struct_ref (exp
, ax
, value
, name
, "->",
1792 "pointer to a structure or union");
1794 /* If this `if' chain doesn't handle it, then the case list
1795 shouldn't mention it, and we shouldn't be here. */
1796 internal_error (__FILE__
, __LINE__
,
1797 _("gen_expr: unhandled struct case"));
1804 struct symbol
*func
, *sym
;
1807 func
= block_linkage_function (block_for_pc (ax
->scope
));
1808 this_name
= language_def (SYMBOL_LANGUAGE (func
))->la_name_of_this
;
1809 b
= SYMBOL_BLOCK_VALUE (func
);
1811 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
1812 symbol instead of the LOC_ARG one (if both exist). */
1813 sym
= lookup_block_symbol (b
, this_name
, NULL
, VAR_DOMAIN
);
1815 error (_("no `%s' found"), this_name
);
1817 gen_var_ref (exp
->gdbarch
, ax
, value
, sym
);
1823 error (_("Attempt to use a type name as an expression."));
1826 error (_("Unsupported operator in expression."));
1830 /* This handles the middle-to-right-side of code generation for binary
1831 expressions, which is shared between regular binary operations and
1832 assign-modify (+= and friends) expressions. */
1835 gen_expr_binop_rest (struct expression
*exp
,
1836 enum exp_opcode op
, union exp_element
**pc
,
1837 struct agent_expr
*ax
, struct axs_value
*value
,
1838 struct axs_value
*value1
, struct axs_value
*value2
)
1840 gen_expr (exp
, pc
, ax
, value2
);
1841 gen_usual_unary (exp
, ax
, value2
);
1842 gen_usual_arithmetic (exp
, ax
, value1
, value2
);
1846 if (TYPE_CODE (value1
->type
) == TYPE_CODE_INT
1847 && pointer_type (value2
->type
))
1849 /* Swap the values and proceed normally. */
1850 ax_simple (ax
, aop_swap
);
1851 gen_ptradd (ax
, value
, value2
, value1
);
1853 else if (pointer_type (value1
->type
)
1854 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
1855 gen_ptradd (ax
, value
, value1
, value2
);
1857 gen_binop (ax
, value
, value1
, value2
,
1858 aop_add
, aop_add
, 1, "addition");
1861 if (pointer_type (value1
->type
)
1862 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
1863 gen_ptrsub (ax
,value
, value1
, value2
);
1864 else if (pointer_type (value1
->type
)
1865 && pointer_type (value2
->type
))
1866 /* FIXME --- result type should be ptrdiff_t */
1867 gen_ptrdiff (ax
, value
, value1
, value2
,
1868 builtin_type (exp
->gdbarch
)->builtin_long
);
1870 gen_binop (ax
, value
, value1
, value2
,
1871 aop_sub
, aop_sub
, 1, "subtraction");
1874 gen_binop (ax
, value
, value1
, value2
,
1875 aop_mul
, aop_mul
, 1, "multiplication");
1878 gen_binop (ax
, value
, value1
, value2
,
1879 aop_div_signed
, aop_div_unsigned
, 1, "division");
1882 gen_binop (ax
, value
, value1
, value2
,
1883 aop_rem_signed
, aop_rem_unsigned
, 1, "remainder");
1885 case BINOP_SUBSCRIPT
:
1886 gen_ptradd (ax
, value
, value1
, value2
);
1887 if (!pointer_type (value
->type
))
1888 error (_("Invalid combination of types in array subscripting."));
1889 gen_deref (ax
, value
);
1891 case BINOP_BITWISE_AND
:
1892 gen_binop (ax
, value
, value1
, value2
,
1893 aop_bit_and
, aop_bit_and
, 0, "bitwise and");
1896 case BINOP_BITWISE_IOR
:
1897 gen_binop (ax
, value
, value1
, value2
,
1898 aop_bit_or
, aop_bit_or
, 0, "bitwise or");
1901 case BINOP_BITWISE_XOR
:
1902 gen_binop (ax
, value
, value1
, value2
,
1903 aop_bit_xor
, aop_bit_xor
, 0, "bitwise exclusive-or");
1907 gen_binop (ax
, value
, value1
, value2
,
1908 aop_equal
, aop_equal
, 0, "equal");
1911 case BINOP_NOTEQUAL
:
1912 gen_binop (ax
, value
, value1
, value2
,
1913 aop_equal
, aop_equal
, 0, "equal");
1914 gen_logical_not (ax
, value
,
1915 language_bool_type (exp
->language_defn
,
1920 gen_binop (ax
, value
, value1
, value2
,
1921 aop_less_signed
, aop_less_unsigned
, 0, "less than");
1925 ax_simple (ax
, aop_swap
);
1926 gen_binop (ax
, value
, value1
, value2
,
1927 aop_less_signed
, aop_less_unsigned
, 0, "less than");
1931 ax_simple (ax
, aop_swap
);
1932 gen_binop (ax
, value
, value1
, value2
,
1933 aop_less_signed
, aop_less_unsigned
, 0, "less than");
1934 gen_logical_not (ax
, value
,
1935 language_bool_type (exp
->language_defn
,
1940 gen_binop (ax
, value
, value1
, value2
,
1941 aop_less_signed
, aop_less_unsigned
, 0, "less than");
1942 gen_logical_not (ax
, value
,
1943 language_bool_type (exp
->language_defn
,
1948 /* We should only list operators in the outer case statement
1949 that we actually handle in the inner case statement. */
1950 internal_error (__FILE__
, __LINE__
,
1951 _("gen_expr: op case sets don't match"));
1956 /* Given a single variable and a scope, generate bytecodes to trace
1957 its value. This is for use in situations where we have only a
1958 variable's name, and no parsed expression; for instance, when the
1959 name comes from a list of local variables of a function. */
1962 gen_trace_for_var (CORE_ADDR scope
, struct symbol
*var
)
1964 struct cleanup
*old_chain
= 0;
1965 struct agent_expr
*ax
= new_agent_expr (scope
);
1966 struct axs_value value
;
1968 old_chain
= make_cleanup_free_agent_expr (ax
);
1971 gen_var_ref (NULL
, ax
, &value
, var
);
1973 /* Make sure we record the final object, and get rid of it. */
1974 gen_traced_pop (ax
, &value
);
1976 /* Oh, and terminate. */
1977 ax_simple (ax
, aop_end
);
1979 /* We have successfully built the agent expr, so cancel the cleanup
1980 request. If we add more cleanups that we always want done, this
1981 will have to get more complicated. */
1982 discard_cleanups (old_chain
);
1986 /* Generating bytecode from GDB expressions: driver */
1988 /* Given a GDB expression EXPR, return bytecode to trace its value.
1989 The result will use the `trace' and `trace_quick' bytecodes to
1990 record the value of all memory touched by the expression. The
1991 caller can then use the ax_reqs function to discover which
1992 registers it relies upon. */
1994 gen_trace_for_expr (CORE_ADDR scope
, struct expression
*expr
)
1996 struct cleanup
*old_chain
= 0;
1997 struct agent_expr
*ax
= new_agent_expr (scope
);
1998 union exp_element
*pc
;
1999 struct axs_value value
;
2001 old_chain
= make_cleanup_free_agent_expr (ax
);
2005 gen_expr (expr
, &pc
, ax
, &value
);
2007 /* Make sure we record the final object, and get rid of it. */
2008 gen_traced_pop (ax
, &value
);
2010 /* Oh, and terminate. */
2011 ax_simple (ax
, aop_end
);
2013 /* We have successfully built the agent expr, so cancel the cleanup
2014 request. If we add more cleanups that we always want done, this
2015 will have to get more complicated. */
2016 discard_cleanups (old_chain
);
2020 /* Given a GDB expression EXPR, return a bytecode sequence that will
2021 evaluate and return a result. The bytecodes will do a direct
2022 evaluation, using the current data on the target, rather than
2023 recording blocks of memory and registers for later use, as
2024 gen_trace_for_expr does. The generated bytecode sequence leaves
2025 the result of expression evaluation on the top of the stack. */
2028 gen_eval_for_expr (CORE_ADDR scope
, struct expression
*expr
)
2030 struct cleanup
*old_chain
= 0;
2031 struct agent_expr
*ax
= new_agent_expr (scope
);
2032 union exp_element
*pc
;
2033 struct axs_value value
;
2035 old_chain
= make_cleanup_free_agent_expr (ax
);
2039 gen_expr (expr
, &pc
, ax
, &value
);
2041 /* Oh, and terminate. */
2042 ax_simple (ax
, aop_end
);
2044 /* We have successfully built the agent expr, so cancel the cleanup
2045 request. If we add more cleanups that we always want done, this
2046 will have to get more complicated. */
2047 discard_cleanups (old_chain
);
2052 agent_command (char *exp
, int from_tty
)
2054 struct cleanup
*old_chain
= 0;
2055 struct expression
*expr
;
2056 struct agent_expr
*agent
;
2057 struct frame_info
*fi
= get_current_frame (); /* need current scope */
2059 /* We don't deal with overlay debugging at the moment. We need to
2060 think more carefully about this. If you copy this code into
2061 another command, change the error message; the user shouldn't
2062 have to know anything about agent expressions. */
2063 if (overlay_debugging
)
2064 error (_("GDB can't do agent expression translation with overlays."));
2067 error_no_arg (_("expression to translate"));
2069 expr
= parse_expression (exp
);
2070 old_chain
= make_cleanup (free_current_contents
, &expr
);
2071 agent
= gen_trace_for_expr (get_frame_pc (fi
), expr
);
2072 make_cleanup_free_agent_expr (agent
);
2073 ax_print (gdb_stdout
, agent
);
2075 /* It would be nice to call ax_reqs here to gather some general info
2076 about the expression, and then print out the result. */
2078 do_cleanups (old_chain
);
2082 /* Parse the given expression, compile it into an agent expression
2083 that does direct evaluation, and display the resulting
2087 agent_eval_command (char *exp
, int from_tty
)
2089 struct cleanup
*old_chain
= 0;
2090 struct expression
*expr
;
2091 struct agent_expr
*agent
;
2092 struct frame_info
*fi
= get_current_frame (); /* need current scope */
2094 /* We don't deal with overlay debugging at the moment. We need to
2095 think more carefully about this. If you copy this code into
2096 another command, change the error message; the user shouldn't
2097 have to know anything about agent expressions. */
2098 if (overlay_debugging
)
2099 error (_("GDB can't do agent expression translation with overlays."));
2102 error_no_arg (_("expression to translate"));
2104 expr
= parse_expression (exp
);
2105 old_chain
= make_cleanup (free_current_contents
, &expr
);
2106 agent
= gen_eval_for_expr (get_frame_pc (fi
), expr
);
2107 make_cleanup_free_agent_expr (agent
);
2108 ax_print (gdb_stdout
, agent
);
2110 /* It would be nice to call ax_reqs here to gather some general info
2111 about the expression, and then print out the result. */
2113 do_cleanups (old_chain
);
2118 /* Initialization code. */
2120 void _initialize_ax_gdb (void);
2122 _initialize_ax_gdb (void)
2124 add_cmd ("agent", class_maintenance
, agent_command
,
2125 _("Translate an expression into remote agent bytecode for tracing."),
2128 add_cmd ("agent-eval", class_maintenance
, agent_eval_command
,
2129 _("Translate an expression into remote agent bytecode for evaluation."),
This page took 0.071887 seconds and 4 git commands to generate.