1 /* GDB-specific functions for operating on agent expressions.
3 Copyright 1998, 1999, 2000, 2001, 2003 Free Software Foundation,
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 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, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
28 #include "expression.h"
35 #include "gdb_string.h"
39 /* To make sense of this file, you should read doc/agentexpr.texi.
40 Then look at the types and enums in ax-gdb.h. For the code itself,
41 look at gen_expr, towards the bottom; that's the main function that
42 looks at the GDB expressions and calls everything else to generate
45 I'm beginning to wonder whether it wouldn't be nicer to internally
46 generate trees, with types, and then spit out the bytecode in
47 linear form afterwards; we could generate fewer `swap', `ext', and
48 `zero_ext' bytecodes that way; it would make good constant folding
49 easier, too. But at the moment, I think we should be willing to
50 pay for the simplicity of this code with less-than-optimal bytecode
53 Remember, "GBD" stands for "Great Britain, Dammit!" So be careful. */
57 /* Prototypes for local functions. */
59 /* There's a standard order to the arguments of these functions:
60 union exp_element ** --- pointer into expression
61 struct agent_expr * --- agent expression buffer to generate code into
62 struct axs_value * --- describes value left on top of stack */
64 static struct value
*const_var_ref (struct symbol
*var
);
65 static struct value
*const_expr (union exp_element
**pc
);
66 static struct value
*maybe_const_expr (union exp_element
**pc
);
68 static void gen_traced_pop (struct agent_expr
*, struct axs_value
*);
70 static void gen_sign_extend (struct agent_expr
*, struct type
*);
71 static void gen_extend (struct agent_expr
*, struct type
*);
72 static void gen_fetch (struct agent_expr
*, struct type
*);
73 static void gen_left_shift (struct agent_expr
*, int);
76 static void gen_frame_args_address (struct agent_expr
*);
77 static void gen_frame_locals_address (struct agent_expr
*);
78 static void gen_offset (struct agent_expr
*ax
, int offset
);
79 static void gen_sym_offset (struct agent_expr
*, struct symbol
*);
80 static void gen_var_ref (struct agent_expr
*ax
,
81 struct axs_value
*value
, struct symbol
*var
);
84 static void gen_int_literal (struct agent_expr
*ax
,
85 struct axs_value
*value
,
86 LONGEST k
, struct type
*type
);
89 static void require_rvalue (struct agent_expr
*ax
, struct axs_value
*value
);
90 static void gen_usual_unary (struct agent_expr
*ax
, struct axs_value
*value
);
91 static int type_wider_than (struct type
*type1
, struct type
*type2
);
92 static struct type
*max_type (struct type
*type1
, struct type
*type2
);
93 static void gen_conversion (struct agent_expr
*ax
,
94 struct type
*from
, struct type
*to
);
95 static int is_nontrivial_conversion (struct type
*from
, struct type
*to
);
96 static void gen_usual_arithmetic (struct agent_expr
*ax
,
97 struct axs_value
*value1
,
98 struct axs_value
*value2
);
99 static void gen_integral_promotions (struct agent_expr
*ax
,
100 struct axs_value
*value
);
101 static void gen_cast (struct agent_expr
*ax
,
102 struct axs_value
*value
, struct type
*type
);
103 static void gen_scale (struct agent_expr
*ax
,
104 enum agent_op op
, struct type
*type
);
105 static void gen_add (struct agent_expr
*ax
,
106 struct axs_value
*value
,
107 struct axs_value
*value1
,
108 struct axs_value
*value2
, char *name
);
109 static void gen_sub (struct agent_expr
*ax
,
110 struct axs_value
*value
,
111 struct axs_value
*value1
, struct axs_value
*value2
);
112 static void gen_binop (struct agent_expr
*ax
,
113 struct axs_value
*value
,
114 struct axs_value
*value1
,
115 struct axs_value
*value2
,
117 enum agent_op op_unsigned
, int may_carry
, char *name
);
118 static void gen_logical_not (struct agent_expr
*ax
, struct axs_value
*value
);
119 static void gen_complement (struct agent_expr
*ax
, struct axs_value
*value
);
120 static void gen_deref (struct agent_expr
*, struct axs_value
*);
121 static void gen_address_of (struct agent_expr
*, struct axs_value
*);
122 static int find_field (struct type
*type
, char *name
);
123 static void gen_bitfield_ref (struct agent_expr
*ax
,
124 struct axs_value
*value
,
125 struct type
*type
, int start
, int end
);
126 static void gen_struct_ref (struct agent_expr
*ax
,
127 struct axs_value
*value
,
129 char *operator_name
, char *operand_name
);
130 static void gen_repeat (union exp_element
**pc
,
131 struct agent_expr
*ax
, struct axs_value
*value
);
132 static void gen_sizeof (union exp_element
**pc
,
133 struct agent_expr
*ax
, struct axs_value
*value
);
134 static void gen_expr (union exp_element
**pc
,
135 struct agent_expr
*ax
, struct axs_value
*value
);
137 static void agent_command (char *exp
, int from_tty
);
140 /* Detecting constant expressions. */
142 /* If the variable reference at *PC is a constant, return its value.
143 Otherwise, return zero.
145 Hey, Wally! How can a variable reference be a constant?
147 Well, Beav, this function really handles the OP_VAR_VALUE operator,
148 not specifically variable references. GDB uses OP_VAR_VALUE to
149 refer to any kind of symbolic reference: function names, enum
150 elements, and goto labels are all handled through the OP_VAR_VALUE
151 operator, even though they're constants. It makes sense given the
154 Gee, Wally, don'cha wonder sometimes if data representations that
155 subvert commonly accepted definitions of terms in favor of heavily
156 context-specific interpretations are really just a tool of the
157 programming hegemony to preserve their power and exclude the
160 static struct value
*
161 const_var_ref (struct symbol
*var
)
163 struct type
*type
= SYMBOL_TYPE (var
);
165 switch (SYMBOL_CLASS (var
))
168 return value_from_longest (type
, (LONGEST
) SYMBOL_VALUE (var
));
171 return value_from_pointer (type
, (CORE_ADDR
) SYMBOL_VALUE_ADDRESS (var
));
179 /* If the expression starting at *PC has a constant value, return it.
180 Otherwise, return zero. If we return a value, then *PC will be
181 advanced to the end of it. If we return zero, *PC could be
183 static struct value
*
184 const_expr (union exp_element
**pc
)
186 enum exp_opcode op
= (*pc
)->opcode
;
193 struct type
*type
= (*pc
)[1].type
;
194 LONGEST k
= (*pc
)[2].longconst
;
196 return value_from_longest (type
, k
);
201 struct value
*v
= const_var_ref ((*pc
)[2].symbol
);
206 /* We could add more operators in here. */
210 v1
= const_expr (pc
);
212 return value_neg (v1
);
222 /* Like const_expr, but guarantee also that *PC is undisturbed if the
223 expression is not constant. */
224 static struct value
*
225 maybe_const_expr (union exp_element
**pc
)
227 union exp_element
*tentative_pc
= *pc
;
228 struct value
*v
= const_expr (&tentative_pc
);
230 /* If we got a value, then update the real PC. */
238 /* Generating bytecode from GDB expressions: general assumptions */
240 /* Here are a few general assumptions made throughout the code; if you
241 want to make a change that contradicts one of these, then you'd
242 better scan things pretty thoroughly.
244 - We assume that all values occupy one stack element. For example,
245 sometimes we'll swap to get at the left argument to a binary
246 operator. If we decide that void values should occupy no stack
247 elements, or that synthetic arrays (whose size is determined at
248 run time, created by the `@' operator) should occupy two stack
249 elements (address and length), then this will cause trouble.
251 - We assume the stack elements are infinitely wide, and that we
252 don't have to worry what happens if the user requests an
253 operation that is wider than the actual interpreter's stack.
254 That is, it's up to the interpreter to handle directly all the
255 integer widths the user has access to. (Woe betide the language
258 - We don't support side effects. Thus, we don't have to worry about
259 GCC's generalized lvalues, function calls, etc.
261 - We don't support floating point. Many places where we switch on
262 some type don't bother to include cases for floating point; there
263 may be even more subtle ways this assumption exists. For
264 example, the arguments to % must be integers.
266 - We assume all subexpressions have a static, unchanging type. If
267 we tried to support convenience variables, this would be a
270 - All values on the stack should always be fully zero- or
273 (I wasn't sure whether to choose this or its opposite --- that
274 only addresses are assumed extended --- but it turns out that
275 neither convention completely eliminates spurious extend
276 operations (if everything is always extended, then you have to
277 extend after add, because it could overflow; if nothing is
278 extended, then you end up producing extends whenever you change
279 sizes), and this is simpler.) */
282 /* Generating bytecode from GDB expressions: the `trace' kludge */
284 /* The compiler in this file is a general-purpose mechanism for
285 translating GDB expressions into bytecode. One ought to be able to
286 find a million and one uses for it.
288 However, at the moment it is HOPELESSLY BRAIN-DAMAGED for the sake
289 of expediency. Let he who is without sin cast the first stone.
291 For the data tracing facility, we need to insert `trace' bytecodes
292 before each data fetch; this records all the memory that the
293 expression touches in the course of evaluation, so that memory will
294 be available when the user later tries to evaluate the expression
297 This should be done (I think) in a post-processing pass, that walks
298 an arbitrary agent expression and inserts `trace' operations at the
299 appropriate points. But it's much faster to just hack them
300 directly into the code. And since we're in a crunch, that's what
303 Setting the flag trace_kludge to non-zero enables the code that
304 emits the trace bytecodes at the appropriate points. */
305 static int trace_kludge
;
307 /* Trace the lvalue on the stack, if it needs it. In either case, pop
308 the value. Useful on the left side of a comma, and at the end of
309 an expression being used for tracing. */
311 gen_traced_pop (struct agent_expr
*ax
, struct axs_value
*value
)
317 /* We don't trace rvalues, just the lvalues necessary to
318 produce them. So just dispose of this value. */
319 ax_simple (ax
, aop_pop
);
322 case axs_lvalue_memory
:
324 int length
= TYPE_LENGTH (value
->type
);
326 /* There's no point in trying to use a trace_quick bytecode
327 here, since "trace_quick SIZE pop" is three bytes, whereas
328 "const8 SIZE trace" is also three bytes, does the same
329 thing, and the simplest code which generates that will also
330 work correctly for objects with large sizes. */
331 ax_const_l (ax
, length
);
332 ax_simple (ax
, aop_trace
);
336 case axs_lvalue_register
:
337 /* We need to mention the register somewhere in the bytecode,
338 so ax_reqs will pick it up and add it to the mask of
340 ax_reg (ax
, value
->u
.reg
);
341 ax_simple (ax
, aop_pop
);
345 /* If we're not tracing, just pop the value. */
346 ax_simple (ax
, aop_pop
);
351 /* Generating bytecode from GDB expressions: helper functions */
353 /* Assume that the lower bits of the top of the stack is a value of
354 type TYPE, and the upper bits are zero. Sign-extend if necessary. */
356 gen_sign_extend (struct agent_expr
*ax
, struct type
*type
)
358 /* Do we need to sign-extend this? */
359 if (!TYPE_UNSIGNED (type
))
360 ax_ext (ax
, TYPE_LENGTH (type
) * TARGET_CHAR_BIT
);
364 /* Assume the lower bits of the top of the stack hold a value of type
365 TYPE, and the upper bits are garbage. Sign-extend or truncate as
368 gen_extend (struct agent_expr
*ax
, struct type
*type
)
370 int bits
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
372 ((TYPE_UNSIGNED (type
) ? ax_zero_ext
: ax_ext
) (ax
, bits
));
376 /* Assume that the top of the stack contains a value of type "pointer
377 to TYPE"; generate code to fetch its value. Note that TYPE is the
378 target type, not the pointer type. */
380 gen_fetch (struct agent_expr
*ax
, struct type
*type
)
384 /* Record the area of memory we're about to fetch. */
385 ax_trace_quick (ax
, TYPE_LENGTH (type
));
388 switch (TYPE_CODE (type
))
394 /* It's a scalar value, so we know how to dereference it. How
395 many bytes long is it? */
396 switch (TYPE_LENGTH (type
))
398 case 8 / TARGET_CHAR_BIT
:
399 ax_simple (ax
, aop_ref8
);
401 case 16 / TARGET_CHAR_BIT
:
402 ax_simple (ax
, aop_ref16
);
404 case 32 / TARGET_CHAR_BIT
:
405 ax_simple (ax
, aop_ref32
);
407 case 64 / TARGET_CHAR_BIT
:
408 ax_simple (ax
, aop_ref64
);
411 /* Either our caller shouldn't have asked us to dereference
412 that pointer (other code's fault), or we're not
413 implementing something we should be (this code's fault).
414 In any case, it's a bug the user shouldn't see. */
416 internal_error (__FILE__
, __LINE__
,
417 _("gen_fetch: strange size"));
420 gen_sign_extend (ax
, type
);
424 /* Either our caller shouldn't have asked us to dereference that
425 pointer (other code's fault), or we're not implementing
426 something we should be (this code's fault). In any case,
427 it's a bug the user shouldn't see. */
428 internal_error (__FILE__
, __LINE__
,
429 _("gen_fetch: bad type code"));
434 /* Generate code to left shift the top of the stack by DISTANCE bits, or
435 right shift it by -DISTANCE bits if DISTANCE < 0. This generates
436 unsigned (logical) right shifts. */
438 gen_left_shift (struct agent_expr
*ax
, int distance
)
442 ax_const_l (ax
, distance
);
443 ax_simple (ax
, aop_lsh
);
445 else if (distance
< 0)
447 ax_const_l (ax
, -distance
);
448 ax_simple (ax
, aop_rsh_unsigned
);
454 /* Generating bytecode from GDB expressions: symbol references */
456 /* Generate code to push the base address of the argument portion of
457 the top stack frame. */
459 gen_frame_args_address (struct agent_expr
*ax
)
462 LONGEST frame_offset
;
464 TARGET_VIRTUAL_FRAME_POINTER (ax
->scope
, &frame_reg
, &frame_offset
);
465 ax_reg (ax
, frame_reg
);
466 gen_offset (ax
, frame_offset
);
470 /* Generate code to push the base address of the locals portion of the
473 gen_frame_locals_address (struct agent_expr
*ax
)
476 LONGEST frame_offset
;
478 TARGET_VIRTUAL_FRAME_POINTER (ax
->scope
, &frame_reg
, &frame_offset
);
479 ax_reg (ax
, frame_reg
);
480 gen_offset (ax
, frame_offset
);
484 /* Generate code to add OFFSET to the top of the stack. Try to
485 generate short and readable code. We use this for getting to
486 variables on the stack, and structure members. If we were
487 programming in ML, it would be clearer why these are the same
490 gen_offset (struct agent_expr
*ax
, int offset
)
492 /* It would suffice to simply push the offset and add it, but this
493 makes it easier to read positive and negative offsets in the
497 ax_const_l (ax
, offset
);
498 ax_simple (ax
, aop_add
);
502 ax_const_l (ax
, -offset
);
503 ax_simple (ax
, aop_sub
);
508 /* In many cases, a symbol's value is the offset from some other
509 address (stack frame, base register, etc.) Generate code to add
510 VAR's value to the top of the stack. */
512 gen_sym_offset (struct agent_expr
*ax
, struct symbol
*var
)
514 gen_offset (ax
, SYMBOL_VALUE (var
));
518 /* Generate code for a variable reference to AX. The variable is the
519 symbol VAR. Set VALUE to describe the result. */
522 gen_var_ref (struct agent_expr
*ax
, struct axs_value
*value
, struct symbol
*var
)
524 /* Dereference any typedefs. */
525 value
->type
= check_typedef (SYMBOL_TYPE (var
));
527 /* I'm imitating the code in read_var_value. */
528 switch (SYMBOL_CLASS (var
))
530 case LOC_CONST
: /* A constant, like an enum value. */
531 ax_const_l (ax
, (LONGEST
) SYMBOL_VALUE (var
));
532 value
->kind
= axs_rvalue
;
535 case LOC_LABEL
: /* A goto label, being used as a value. */
536 ax_const_l (ax
, (LONGEST
) SYMBOL_VALUE_ADDRESS (var
));
537 value
->kind
= axs_rvalue
;
540 case LOC_CONST_BYTES
:
541 internal_error (__FILE__
, __LINE__
,
542 _("gen_var_ref: LOC_CONST_BYTES symbols are not supported"));
544 /* Variable at a fixed location in memory. Easy. */
546 /* Push the address of the variable. */
547 ax_const_l (ax
, SYMBOL_VALUE_ADDRESS (var
));
548 value
->kind
= axs_lvalue_memory
;
551 case LOC_ARG
: /* var lives in argument area of frame */
552 gen_frame_args_address (ax
);
553 gen_sym_offset (ax
, var
);
554 value
->kind
= axs_lvalue_memory
;
557 case LOC_REF_ARG
: /* As above, but the frame slot really
558 holds the address of the variable. */
559 gen_frame_args_address (ax
);
560 gen_sym_offset (ax
, var
);
561 /* Don't assume any particular pointer size. */
562 gen_fetch (ax
, lookup_pointer_type (builtin_type_void
));
563 value
->kind
= axs_lvalue_memory
;
566 case LOC_LOCAL
: /* var lives in locals area of frame */
568 gen_frame_locals_address (ax
);
569 gen_sym_offset (ax
, var
);
570 value
->kind
= axs_lvalue_memory
;
573 case LOC_BASEREG
: /* relative to some base register */
574 case LOC_BASEREG_ARG
:
575 ax_reg (ax
, SYMBOL_BASEREG (var
));
576 gen_sym_offset (ax
, var
);
577 value
->kind
= axs_lvalue_memory
;
581 error (_("Cannot compute value of typedef `%s'."),
582 SYMBOL_PRINT_NAME (var
));
586 ax_const_l (ax
, BLOCK_START (SYMBOL_BLOCK_VALUE (var
)));
587 value
->kind
= axs_rvalue
;
592 /* Don't generate any code at all; in the process of treating
593 this as an lvalue or rvalue, the caller will generate the
595 value
->kind
= axs_lvalue_register
;
596 value
->u
.reg
= SYMBOL_VALUE (var
);
599 /* A lot like LOC_REF_ARG, but the pointer lives directly in a
600 register, not on the stack. Simpler than LOC_REGISTER and
601 LOC_REGPARM, because it's just like any other case where the
602 thing has a real address. */
603 case LOC_REGPARM_ADDR
:
604 ax_reg (ax
, SYMBOL_VALUE (var
));
605 value
->kind
= axs_lvalue_memory
;
610 struct minimal_symbol
*msym
611 = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var
), NULL
, NULL
);
613 error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var
));
615 /* Push the address of the variable. */
616 ax_const_l (ax
, SYMBOL_VALUE_ADDRESS (msym
));
617 value
->kind
= axs_lvalue_memory
;
622 case LOC_COMPUTED_ARG
:
623 /* FIXME: cagney/2004-01-26: It should be possible to
624 unconditionally call the SYMBOL_OPS method when available.
625 Unfortunately DWARF 2 stores the frame-base (instead of the
626 function) location in a function's symbol. Oops! For the
627 moment enable this when/where applicable. */
628 SYMBOL_OPS (var
)->tracepoint_var_ref (var
, ax
, value
);
631 case LOC_OPTIMIZED_OUT
:
632 error (_("The variable `%s' has been optimized out."),
633 SYMBOL_PRINT_NAME (var
));
637 error (_("Cannot find value of botched symbol `%s'."),
638 SYMBOL_PRINT_NAME (var
));
645 /* Generating bytecode from GDB expressions: literals */
648 gen_int_literal (struct agent_expr
*ax
, struct axs_value
*value
, LONGEST k
,
652 value
->kind
= axs_rvalue
;
658 /* Generating bytecode from GDB expressions: unary conversions, casts */
660 /* Take what's on the top of the stack (as described by VALUE), and
661 try to make an rvalue out of it. Signal an error if we can't do
664 require_rvalue (struct agent_expr
*ax
, struct axs_value
*value
)
669 /* It's already an rvalue. */
672 case axs_lvalue_memory
:
673 /* The top of stack is the address of the object. Dereference. */
674 gen_fetch (ax
, value
->type
);
677 case axs_lvalue_register
:
678 /* There's nothing on the stack, but value->u.reg is the
679 register number containing the value.
681 When we add floating-point support, this is going to have to
682 change. What about SPARC register pairs, for example? */
683 ax_reg (ax
, value
->u
.reg
);
684 gen_extend (ax
, value
->type
);
688 value
->kind
= axs_rvalue
;
692 /* Assume the top of the stack is described by VALUE, and perform the
693 usual unary conversions. This is motivated by ANSI 6.2.2, but of
694 course GDB expressions are not ANSI; they're the mishmash union of
695 a bunch of languages. Rah.
697 NOTE! This function promises to produce an rvalue only when the
698 incoming value is of an appropriate type. In other words, the
699 consumer of the value this function produces may assume the value
700 is an rvalue only after checking its type.
702 The immediate issue is that if the user tries to use a structure or
703 union as an operand of, say, the `+' operator, we don't want to try
704 to convert that structure to an rvalue; require_rvalue will bomb on
705 structs and unions. Rather, we want to simply pass the struct
706 lvalue through unchanged, and let `+' raise an error. */
709 gen_usual_unary (struct agent_expr
*ax
, struct axs_value
*value
)
711 /* We don't have to generate any code for the usual integral
712 conversions, since values are always represented as full-width on
713 the stack. Should we tweak the type? */
715 /* Some types require special handling. */
716 switch (TYPE_CODE (value
->type
))
718 /* Functions get converted to a pointer to the function. */
720 value
->type
= lookup_pointer_type (value
->type
);
721 value
->kind
= axs_rvalue
; /* Should always be true, but just in case. */
724 /* Arrays get converted to a pointer to their first element, and
725 are no longer an lvalue. */
726 case TYPE_CODE_ARRAY
:
728 struct type
*elements
= TYPE_TARGET_TYPE (value
->type
);
729 value
->type
= lookup_pointer_type (elements
);
730 value
->kind
= axs_rvalue
;
731 /* We don't need to generate any code; the address of the array
732 is also the address of its first element. */
736 /* Don't try to convert structures and unions to rvalues. Let the
737 consumer signal an error. */
738 case TYPE_CODE_STRUCT
:
739 case TYPE_CODE_UNION
:
742 /* If the value is an enum, call it an integer. */
744 value
->type
= builtin_type_int
;
748 /* If the value is an lvalue, dereference it. */
749 require_rvalue (ax
, value
);
753 /* Return non-zero iff the type TYPE1 is considered "wider" than the
754 type TYPE2, according to the rules described in gen_usual_arithmetic. */
756 type_wider_than (struct type
*type1
, struct type
*type2
)
758 return (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
)
759 || (TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
760 && TYPE_UNSIGNED (type1
)
761 && !TYPE_UNSIGNED (type2
)));
765 /* Return the "wider" of the two types TYPE1 and TYPE2. */
767 max_type (struct type
*type1
, struct type
*type2
)
769 return type_wider_than (type1
, type2
) ? type1
: type2
;
773 /* Generate code to convert a scalar value of type FROM to type TO. */
775 gen_conversion (struct agent_expr
*ax
, struct type
*from
, struct type
*to
)
777 /* Perhaps there is a more graceful way to state these rules. */
779 /* If we're converting to a narrower type, then we need to clear out
781 if (TYPE_LENGTH (to
) < TYPE_LENGTH (from
))
782 gen_extend (ax
, from
);
784 /* If the two values have equal width, but different signednesses,
785 then we need to extend. */
786 else if (TYPE_LENGTH (to
) == TYPE_LENGTH (from
))
788 if (TYPE_UNSIGNED (from
) != TYPE_UNSIGNED (to
))
792 /* If we're converting to a wider type, and becoming unsigned, then
793 we need to zero out any possible sign bits. */
794 else if (TYPE_LENGTH (to
) > TYPE_LENGTH (from
))
796 if (TYPE_UNSIGNED (to
))
802 /* Return non-zero iff the type FROM will require any bytecodes to be
803 emitted to be converted to the type TO. */
805 is_nontrivial_conversion (struct type
*from
, struct type
*to
)
807 struct agent_expr
*ax
= new_agent_expr (0);
810 /* Actually generate the code, and see if anything came out. At the
811 moment, it would be trivial to replicate the code in
812 gen_conversion here, but in the future, when we're supporting
813 floating point and the like, it may not be. Doing things this
814 way allows this function to be independent of the logic in
816 gen_conversion (ax
, from
, to
);
817 nontrivial
= ax
->len
> 0;
818 free_agent_expr (ax
);
823 /* Generate code to perform the "usual arithmetic conversions" (ANSI C
824 6.2.1.5) for the two operands of an arithmetic operator. This
825 effectively finds a "least upper bound" type for the two arguments,
826 and promotes each argument to that type. *VALUE1 and *VALUE2
827 describe the values as they are passed in, and as they are left. */
829 gen_usual_arithmetic (struct agent_expr
*ax
, struct axs_value
*value1
,
830 struct axs_value
*value2
)
832 /* Do the usual binary conversions. */
833 if (TYPE_CODE (value1
->type
) == TYPE_CODE_INT
834 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
836 /* The ANSI integral promotions seem to work this way: Order the
837 integer types by size, and then by signedness: an n-bit
838 unsigned type is considered "wider" than an n-bit signed
839 type. Promote to the "wider" of the two types, and always
840 promote at least to int. */
841 struct type
*target
= max_type (builtin_type_int
,
842 max_type (value1
->type
, value2
->type
));
844 /* Deal with value2, on the top of the stack. */
845 gen_conversion (ax
, value2
->type
, target
);
847 /* Deal with value1, not on the top of the stack. Don't
848 generate the `swap' instructions if we're not actually going
850 if (is_nontrivial_conversion (value1
->type
, target
))
852 ax_simple (ax
, aop_swap
);
853 gen_conversion (ax
, value1
->type
, target
);
854 ax_simple (ax
, aop_swap
);
857 value1
->type
= value2
->type
= target
;
862 /* Generate code to perform the integral promotions (ANSI 6.2.1.1) on
863 the value on the top of the stack, as described by VALUE. Assume
864 the value has integral type. */
866 gen_integral_promotions (struct agent_expr
*ax
, struct axs_value
*value
)
868 if (!type_wider_than (value
->type
, builtin_type_int
))
870 gen_conversion (ax
, value
->type
, builtin_type_int
);
871 value
->type
= builtin_type_int
;
873 else if (!type_wider_than (value
->type
, builtin_type_unsigned_int
))
875 gen_conversion (ax
, value
->type
, builtin_type_unsigned_int
);
876 value
->type
= builtin_type_unsigned_int
;
881 /* Generate code for a cast to TYPE. */
883 gen_cast (struct agent_expr
*ax
, struct axs_value
*value
, struct type
*type
)
885 /* GCC does allow casts to yield lvalues, so this should be fixed
886 before merging these changes into the trunk. */
887 require_rvalue (ax
, value
);
888 /* Dereference typedefs. */
889 type
= check_typedef (type
);
891 switch (TYPE_CODE (type
))
894 /* It's implementation-defined, and I'll bet this is what GCC
898 case TYPE_CODE_ARRAY
:
899 case TYPE_CODE_STRUCT
:
900 case TYPE_CODE_UNION
:
902 error (_("Invalid type cast: intended type must be scalar."));
905 /* We don't have to worry about the size of the value, because
906 all our integral values are fully sign-extended, and when
907 casting pointers we can do anything we like. Is there any
908 way for us to actually know what GCC actually does with a
914 gen_conversion (ax
, value
->type
, type
);
918 /* We could pop the value, and rely on everyone else to check
919 the type and notice that this value doesn't occupy a stack
920 slot. But for now, leave the value on the stack, and
921 preserve the "value == stack element" assumption. */
925 error (_("Casts to requested type are not yet implemented."));
933 /* Generating bytecode from GDB expressions: arithmetic */
935 /* Scale the integer on the top of the stack by the size of the target
936 of the pointer type TYPE. */
938 gen_scale (struct agent_expr
*ax
, enum agent_op op
, struct type
*type
)
940 struct type
*element
= TYPE_TARGET_TYPE (type
);
942 if (TYPE_LENGTH (element
) != 1)
944 ax_const_l (ax
, TYPE_LENGTH (element
));
950 /* Generate code for an addition; non-trivial because we deal with
951 pointer arithmetic. We set VALUE to describe the result value; we
952 assume VALUE1 and VALUE2 describe the two operands, and that
953 they've undergone the usual binary conversions. Used by both
954 BINOP_ADD and BINOP_SUBSCRIPT. NAME is used in error messages. */
956 gen_add (struct agent_expr
*ax
, struct axs_value
*value
,
957 struct axs_value
*value1
, struct axs_value
*value2
, char *name
)
960 if (TYPE_CODE (value1
->type
) == TYPE_CODE_INT
961 && TYPE_CODE (value2
->type
) == TYPE_CODE_PTR
)
963 /* Swap the values and proceed normally. */
964 ax_simple (ax
, aop_swap
);
965 gen_scale (ax
, aop_mul
, value2
->type
);
966 ax_simple (ax
, aop_add
);
967 gen_extend (ax
, value2
->type
); /* Catch overflow. */
968 value
->type
= value2
->type
;
972 else if (TYPE_CODE (value1
->type
) == TYPE_CODE_PTR
973 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
975 gen_scale (ax
, aop_mul
, value1
->type
);
976 ax_simple (ax
, aop_add
);
977 gen_extend (ax
, value1
->type
); /* Catch overflow. */
978 value
->type
= value1
->type
;
981 /* Must be number + number; the usual binary conversions will have
982 brought them both to the same width. */
983 else if (TYPE_CODE (value1
->type
) == TYPE_CODE_INT
984 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
986 ax_simple (ax
, aop_add
);
987 gen_extend (ax
, value1
->type
); /* Catch overflow. */
988 value
->type
= value1
->type
;
992 error (_("Invalid combination of types in %s."), name
);
994 value
->kind
= axs_rvalue
;
998 /* Generate code for an addition; non-trivial because we have to deal
999 with pointer arithmetic. We set VALUE to describe the result
1000 value; we assume VALUE1 and VALUE2 describe the two operands, and
1001 that they've undergone the usual binary conversions. */
1003 gen_sub (struct agent_expr
*ax
, struct axs_value
*value
,
1004 struct axs_value
*value1
, struct axs_value
*value2
)
1006 if (TYPE_CODE (value1
->type
) == TYPE_CODE_PTR
)
1008 /* Is it PTR - INT? */
1009 if (TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
1011 gen_scale (ax
, aop_mul
, value1
->type
);
1012 ax_simple (ax
, aop_sub
);
1013 gen_extend (ax
, value1
->type
); /* Catch overflow. */
1014 value
->type
= value1
->type
;
1017 /* Is it PTR - PTR? Strictly speaking, the types ought to
1018 match, but this is what the normal GDB expression evaluator
1020 else if (TYPE_CODE (value2
->type
) == TYPE_CODE_PTR
1021 && (TYPE_LENGTH (TYPE_TARGET_TYPE (value1
->type
))
1022 == TYPE_LENGTH (TYPE_TARGET_TYPE (value2
->type
))))
1024 ax_simple (ax
, aop_sub
);
1025 gen_scale (ax
, aop_div_unsigned
, value1
->type
);
1026 value
->type
= builtin_type_long
; /* FIXME --- should be ptrdiff_t */
1030 First argument of `-' is a pointer, but second argument is neither\n\
1031 an integer nor a pointer of the same type."));
1034 /* Must be number + number. */
1035 else if (TYPE_CODE (value1
->type
) == TYPE_CODE_INT
1036 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
1038 ax_simple (ax
, aop_sub
);
1039 gen_extend (ax
, value1
->type
); /* Catch overflow. */
1040 value
->type
= value1
->type
;
1044 error (_("Invalid combination of types in subtraction."));
1046 value
->kind
= axs_rvalue
;
1049 /* Generate code for a binary operator that doesn't do pointer magic.
1050 We set VALUE to describe the result value; we assume VALUE1 and
1051 VALUE2 describe the two operands, and that they've undergone the
1052 usual binary conversions. MAY_CARRY should be non-zero iff the
1053 result needs to be extended. NAME is the English name of the
1054 operator, used in error messages */
1056 gen_binop (struct agent_expr
*ax
, struct axs_value
*value
,
1057 struct axs_value
*value1
, struct axs_value
*value2
, enum agent_op op
,
1058 enum agent_op op_unsigned
, int may_carry
, char *name
)
1060 /* We only handle INT op INT. */
1061 if ((TYPE_CODE (value1
->type
) != TYPE_CODE_INT
)
1062 || (TYPE_CODE (value2
->type
) != TYPE_CODE_INT
))
1063 error (_("Invalid combination of types in %s."), name
);
1066 TYPE_UNSIGNED (value1
->type
) ? op_unsigned
: op
);
1068 gen_extend (ax
, value1
->type
); /* catch overflow */
1069 value
->type
= value1
->type
;
1070 value
->kind
= axs_rvalue
;
1075 gen_logical_not (struct agent_expr
*ax
, struct axs_value
*value
)
1077 if (TYPE_CODE (value
->type
) != TYPE_CODE_INT
1078 && TYPE_CODE (value
->type
) != TYPE_CODE_PTR
)
1079 error (_("Invalid type of operand to `!'."));
1081 gen_usual_unary (ax
, value
);
1082 ax_simple (ax
, aop_log_not
);
1083 value
->type
= builtin_type_int
;
1088 gen_complement (struct agent_expr
*ax
, struct axs_value
*value
)
1090 if (TYPE_CODE (value
->type
) != TYPE_CODE_INT
)
1091 error (_("Invalid type of operand to `~'."));
1093 gen_usual_unary (ax
, value
);
1094 gen_integral_promotions (ax
, value
);
1095 ax_simple (ax
, aop_bit_not
);
1096 gen_extend (ax
, value
->type
);
1101 /* Generating bytecode from GDB expressions: * & . -> @ sizeof */
1103 /* Dereference the value on the top of the stack. */
1105 gen_deref (struct agent_expr
*ax
, struct axs_value
*value
)
1107 /* The caller should check the type, because several operators use
1108 this, and we don't know what error message to generate. */
1109 if (TYPE_CODE (value
->type
) != TYPE_CODE_PTR
)
1110 internal_error (__FILE__
, __LINE__
,
1111 _("gen_deref: expected a pointer"));
1113 /* We've got an rvalue now, which is a pointer. We want to yield an
1114 lvalue, whose address is exactly that pointer. So we don't
1115 actually emit any code; we just change the type from "Pointer to
1116 T" to "T", and mark the value as an lvalue in memory. Leave it
1117 to the consumer to actually dereference it. */
1118 value
->type
= check_typedef (TYPE_TARGET_TYPE (value
->type
));
1119 value
->kind
= ((TYPE_CODE (value
->type
) == TYPE_CODE_FUNC
)
1120 ? axs_rvalue
: axs_lvalue_memory
);
1124 /* Produce the address of the lvalue on the top of the stack. */
1126 gen_address_of (struct agent_expr
*ax
, struct axs_value
*value
)
1128 /* Special case for taking the address of a function. The ANSI
1129 standard describes this as a special case, too, so this
1130 arrangement is not without motivation. */
1131 if (TYPE_CODE (value
->type
) == TYPE_CODE_FUNC
)
1132 /* The value's already an rvalue on the stack, so we just need to
1134 value
->type
= lookup_pointer_type (value
->type
);
1136 switch (value
->kind
)
1139 error (_("Operand of `&' is an rvalue, which has no address."));
1141 case axs_lvalue_register
:
1142 error (_("Operand of `&' is in a register, and has no address."));
1144 case axs_lvalue_memory
:
1145 value
->kind
= axs_rvalue
;
1146 value
->type
= lookup_pointer_type (value
->type
);
1152 /* A lot of this stuff will have to change to support C++. But we're
1153 not going to deal with that at the moment. */
1155 /* Find the field in the structure type TYPE named NAME, and return
1156 its index in TYPE's field array. */
1158 find_field (struct type
*type
, char *name
)
1162 CHECK_TYPEDEF (type
);
1164 /* Make sure this isn't C++. */
1165 if (TYPE_N_BASECLASSES (type
) != 0)
1166 internal_error (__FILE__
, __LINE__
,
1167 _("find_field: derived classes supported"));
1169 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1171 char *this_name
= TYPE_FIELD_NAME (type
, i
);
1173 if (this_name
&& strcmp (name
, this_name
) == 0)
1176 if (this_name
[0] == '\0')
1177 internal_error (__FILE__
, __LINE__
,
1178 _("find_field: anonymous unions not supported"));
1181 error (_("Couldn't find member named `%s' in struct/union `%s'"),
1182 name
, TYPE_TAG_NAME (type
));
1188 /* Generate code to push the value of a bitfield of a structure whose
1189 address is on the top of the stack. START and END give the
1190 starting and one-past-ending *bit* numbers of the field within the
1193 gen_bitfield_ref (struct agent_expr
*ax
, struct axs_value
*value
,
1194 struct type
*type
, int start
, int end
)
1196 /* Note that ops[i] fetches 8 << i bits. */
1197 static enum agent_op ops
[]
1199 {aop_ref8
, aop_ref16
, aop_ref32
, aop_ref64
};
1200 static int num_ops
= (sizeof (ops
) / sizeof (ops
[0]));
1202 /* We don't want to touch any byte that the bitfield doesn't
1203 actually occupy; we shouldn't make any accesses we're not
1204 explicitly permitted to. We rely here on the fact that the
1205 bytecode `ref' operators work on unaligned addresses.
1207 It takes some fancy footwork to get the stack to work the way
1208 we'd like. Say we're retrieving a bitfield that requires three
1209 fetches. Initially, the stack just contains the address:
1211 For the first fetch, we duplicate the address
1213 then add the byte offset, do the fetch, and shift and mask as
1214 needed, yielding a fragment of the value, properly aligned for
1215 the final bitwise or:
1217 then we swap, and repeat the process:
1218 frag1 addr --- address on top
1219 frag1 addr addr --- duplicate it
1220 frag1 addr frag2 --- get second fragment
1221 frag1 frag2 addr --- swap again
1222 frag1 frag2 frag3 --- get third fragment
1223 Notice that, since the third fragment is the last one, we don't
1224 bother duplicating the address this time. Now we have all the
1225 fragments on the stack, and we can simply `or' them together,
1226 yielding the final value of the bitfield. */
1228 /* The first and one-after-last bits in the field, but rounded down
1229 and up to byte boundaries. */
1230 int bound_start
= (start
/ TARGET_CHAR_BIT
) * TARGET_CHAR_BIT
;
1231 int bound_end
= (((end
+ TARGET_CHAR_BIT
- 1)
1235 /* current bit offset within the structure */
1238 /* The index in ops of the opcode we're considering. */
1241 /* The number of fragments we generated in the process. Probably
1242 equal to the number of `one' bits in bytesize, but who cares? */
1245 /* Dereference any typedefs. */
1246 type
= check_typedef (type
);
1248 /* Can we fetch the number of bits requested at all? */
1249 if ((end
- start
) > ((1 << num_ops
) * 8))
1250 internal_error (__FILE__
, __LINE__
,
1251 _("gen_bitfield_ref: bitfield too wide"));
1253 /* Note that we know here that we only need to try each opcode once.
1254 That may not be true on machines with weird byte sizes. */
1255 offset
= bound_start
;
1257 for (op
= num_ops
- 1; op
>= 0; op
--)
1259 /* number of bits that ops[op] would fetch */
1260 int op_size
= 8 << op
;
1262 /* The stack at this point, from bottom to top, contains zero or
1263 more fragments, then the address. */
1265 /* Does this fetch fit within the bitfield? */
1266 if (offset
+ op_size
<= bound_end
)
1268 /* Is this the last fragment? */
1269 int last_frag
= (offset
+ op_size
== bound_end
);
1272 ax_simple (ax
, aop_dup
); /* keep a copy of the address */
1274 /* Add the offset. */
1275 gen_offset (ax
, offset
/ TARGET_CHAR_BIT
);
1279 /* Record the area of memory we're about to fetch. */
1280 ax_trace_quick (ax
, op_size
/ TARGET_CHAR_BIT
);
1283 /* Perform the fetch. */
1284 ax_simple (ax
, ops
[op
]);
1286 /* Shift the bits we have to their proper position.
1287 gen_left_shift will generate right shifts when the operand
1290 A big-endian field diagram to ponder:
1291 byte 0 byte 1 byte 2 byte 3 byte 4 byte 5 byte 6 byte 7
1292 +------++------++------++------++------++------++------++------+
1293 xxxxAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCxxxxxxxxxxx
1295 bit number 16 32 48 53
1296 These are bit numbers as supplied by GDB. Note that the
1297 bit numbers run from right to left once you've fetched the
1300 A little-endian field diagram to ponder:
1301 byte 7 byte 6 byte 5 byte 4 byte 3 byte 2 byte 1 byte 0
1302 +------++------++------++------++------++------++------++------+
1303 xxxxxxxxxxxAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCxxxx
1305 bit number 48 32 16 4 0
1307 In both cases, the most significant end is on the left
1308 (i.e. normal numeric writing order), which means that you
1309 don't go crazy thinking about `left' and `right' shifts.
1311 We don't have to worry about masking yet:
1312 - If they contain garbage off the least significant end, then we
1313 must be looking at the low end of the field, and the right
1314 shift will wipe them out.
1315 - If they contain garbage off the most significant end, then we
1316 must be looking at the most significant end of the word, and
1317 the sign/zero extension will wipe them out.
1318 - If we're in the interior of the word, then there is no garbage
1319 on either end, because the ref operators zero-extend. */
1320 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
1321 gen_left_shift (ax
, end
- (offset
+ op_size
));
1323 gen_left_shift (ax
, offset
- start
);
1326 /* Bring the copy of the address up to the top. */
1327 ax_simple (ax
, aop_swap
);
1334 /* Generate enough bitwise `or' operations to combine all the
1335 fragments we left on the stack. */
1336 while (fragment_count
-- > 1)
1337 ax_simple (ax
, aop_bit_or
);
1339 /* Sign- or zero-extend the value as appropriate. */
1340 ((TYPE_UNSIGNED (type
) ? ax_zero_ext
: ax_ext
) (ax
, end
- start
));
1342 /* This is *not* an lvalue. Ugh. */
1343 value
->kind
= axs_rvalue
;
1348 /* Generate code to reference the member named FIELD of a structure or
1349 union. The top of the stack, as described by VALUE, should have
1350 type (pointer to a)* struct/union. OPERATOR_NAME is the name of
1351 the operator being compiled, and OPERAND_NAME is the kind of thing
1352 it operates on; we use them in error messages. */
1354 gen_struct_ref (struct agent_expr
*ax
, struct axs_value
*value
, char *field
,
1355 char *operator_name
, char *operand_name
)
1360 /* Follow pointers until we reach a non-pointer. These aren't the C
1361 semantics, but they're what the normal GDB evaluator does, so we
1362 should at least be consistent. */
1363 while (TYPE_CODE (value
->type
) == TYPE_CODE_PTR
)
1365 gen_usual_unary (ax
, value
);
1366 gen_deref (ax
, value
);
1368 type
= check_typedef (value
->type
);
1370 /* This must yield a structure or a union. */
1371 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1372 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1373 error (_("The left operand of `%s' is not a %s."),
1374 operator_name
, operand_name
);
1376 /* And it must be in memory; we don't deal with structure rvalues,
1377 or structures living in registers. */
1378 if (value
->kind
!= axs_lvalue_memory
)
1379 error (_("Structure does not live in memory."));
1381 i
= find_field (type
, field
);
1383 /* Is this a bitfield? */
1384 if (TYPE_FIELD_PACKED (type
, i
))
1385 gen_bitfield_ref (ax
, value
, TYPE_FIELD_TYPE (type
, i
),
1386 TYPE_FIELD_BITPOS (type
, i
),
1387 (TYPE_FIELD_BITPOS (type
, i
)
1388 + TYPE_FIELD_BITSIZE (type
, i
)));
1391 gen_offset (ax
, TYPE_FIELD_BITPOS (type
, i
) / TARGET_CHAR_BIT
);
1392 value
->kind
= axs_lvalue_memory
;
1393 value
->type
= TYPE_FIELD_TYPE (type
, i
);
1398 /* Generate code for GDB's magical `repeat' operator.
1399 LVALUE @ INT creates an array INT elements long, and whose elements
1400 have the same type as LVALUE, located in memory so that LVALUE is
1401 its first element. For example, argv[0]@argc gives you the array
1402 of command-line arguments.
1404 Unfortunately, because we have to know the types before we actually
1405 have a value for the expression, we can't implement this perfectly
1406 without changing the type system, having values that occupy two
1407 stack slots, doing weird things with sizeof, etc. So we require
1408 the right operand to be a constant expression. */
1410 gen_repeat (union exp_element
**pc
, struct agent_expr
*ax
,
1411 struct axs_value
*value
)
1413 struct axs_value value1
;
1414 /* We don't want to turn this into an rvalue, so no conversions
1416 gen_expr (pc
, ax
, &value1
);
1417 if (value1
.kind
!= axs_lvalue_memory
)
1418 error (_("Left operand of `@' must be an object in memory."));
1420 /* Evaluate the length; it had better be a constant. */
1422 struct value
*v
= const_expr (pc
);
1426 error (_("Right operand of `@' must be a constant, in agent expressions."));
1427 if (TYPE_CODE (value_type (v
)) != TYPE_CODE_INT
)
1428 error (_("Right operand of `@' must be an integer."));
1429 length
= value_as_long (v
);
1431 error (_("Right operand of `@' must be positive."));
1433 /* The top of the stack is already the address of the object, so
1434 all we need to do is frob the type of the lvalue. */
1436 /* FIXME-type-allocation: need a way to free this type when we are
1439 = create_range_type (0, builtin_type_int
, 0, length
- 1);
1440 struct type
*array
= create_array_type (0, value1
.type
, range
);
1442 value
->kind
= axs_lvalue_memory
;
1443 value
->type
= array
;
1449 /* Emit code for the `sizeof' operator.
1450 *PC should point at the start of the operand expression; we advance it
1451 to the first instruction after the operand. */
1453 gen_sizeof (union exp_element
**pc
, struct agent_expr
*ax
,
1454 struct axs_value
*value
)
1456 /* We don't care about the value of the operand expression; we only
1457 care about its type. However, in the current arrangement, the
1458 only way to find an expression's type is to generate code for it.
1459 So we generate code for the operand, and then throw it away,
1460 replacing it with code that simply pushes its size. */
1461 int start
= ax
->len
;
1462 gen_expr (pc
, ax
, value
);
1464 /* Throw away the code we just generated. */
1467 ax_const_l (ax
, TYPE_LENGTH (value
->type
));
1468 value
->kind
= axs_rvalue
;
1469 value
->type
= builtin_type_int
;
1473 /* Generating bytecode from GDB expressions: general recursive thingy */
1476 /* A gen_expr function written by a Gen-X'er guy.
1477 Append code for the subexpression of EXPR starting at *POS_P to AX. */
1479 gen_expr (union exp_element
**pc
, struct agent_expr
*ax
,
1480 struct axs_value
*value
)
1482 /* Used to hold the descriptions of operand expressions. */
1483 struct axs_value value1
, value2
;
1484 enum exp_opcode op
= (*pc
)[0].opcode
;
1486 /* If we're looking at a constant expression, just push its value. */
1488 struct value
*v
= maybe_const_expr (pc
);
1492 ax_const_l (ax
, value_as_long (v
));
1493 value
->kind
= axs_rvalue
;
1494 value
->type
= check_typedef (value_type (v
));
1499 /* Otherwise, go ahead and generate code for it. */
1502 /* Binary arithmetic operators. */
1508 case BINOP_SUBSCRIPT
:
1509 case BINOP_BITWISE_AND
:
1510 case BINOP_BITWISE_IOR
:
1511 case BINOP_BITWISE_XOR
:
1513 gen_expr (pc
, ax
, &value1
);
1514 gen_usual_unary (ax
, &value1
);
1515 gen_expr (pc
, ax
, &value2
);
1516 gen_usual_unary (ax
, &value2
);
1517 gen_usual_arithmetic (ax
, &value1
, &value2
);
1521 gen_add (ax
, value
, &value1
, &value2
, "addition");
1524 gen_sub (ax
, value
, &value1
, &value2
);
1527 gen_binop (ax
, value
, &value1
, &value2
,
1528 aop_mul
, aop_mul
, 1, "multiplication");
1531 gen_binop (ax
, value
, &value1
, &value2
,
1532 aop_div_signed
, aop_div_unsigned
, 1, "division");
1535 gen_binop (ax
, value
, &value1
, &value2
,
1536 aop_rem_signed
, aop_rem_unsigned
, 1, "remainder");
1538 case BINOP_SUBSCRIPT
:
1539 gen_add (ax
, value
, &value1
, &value2
, "array subscripting");
1540 if (TYPE_CODE (value
->type
) != TYPE_CODE_PTR
)
1541 error (_("Invalid combination of types in array subscripting."));
1542 gen_deref (ax
, value
);
1544 case BINOP_BITWISE_AND
:
1545 gen_binop (ax
, value
, &value1
, &value2
,
1546 aop_bit_and
, aop_bit_and
, 0, "bitwise and");
1549 case BINOP_BITWISE_IOR
:
1550 gen_binop (ax
, value
, &value1
, &value2
,
1551 aop_bit_or
, aop_bit_or
, 0, "bitwise or");
1554 case BINOP_BITWISE_XOR
:
1555 gen_binop (ax
, value
, &value1
, &value2
,
1556 aop_bit_xor
, aop_bit_xor
, 0, "bitwise exclusive-or");
1560 /* We should only list operators in the outer case statement
1561 that we actually handle in the inner case statement. */
1562 internal_error (__FILE__
, __LINE__
,
1563 _("gen_expr: op case sets don't match"));
1567 /* Note that we need to be a little subtle about generating code
1568 for comma. In C, we can do some optimizations here because
1569 we know the left operand is only being evaluated for effect.
1570 However, if the tracing kludge is in effect, then we always
1571 need to evaluate the left hand side fully, so that all the
1572 variables it mentions get traced. */
1575 gen_expr (pc
, ax
, &value1
);
1576 /* Don't just dispose of the left operand. We might be tracing,
1577 in which case we want to emit code to trace it if it's an
1579 gen_traced_pop (ax
, &value1
);
1580 gen_expr (pc
, ax
, value
);
1581 /* It's the consumer's responsibility to trace the right operand. */
1584 case OP_LONG
: /* some integer constant */
1586 struct type
*type
= (*pc
)[1].type
;
1587 LONGEST k
= (*pc
)[2].longconst
;
1589 gen_int_literal (ax
, value
, k
, type
);
1594 gen_var_ref (ax
, value
, (*pc
)[2].symbol
);
1600 int reg
= (int) (*pc
)[1].longconst
;
1602 value
->kind
= axs_lvalue_register
;
1604 value
->type
= register_type (current_gdbarch
, reg
);
1608 case OP_INTERNALVAR
:
1609 error (_("GDB agent expressions cannot use convenience variables."));
1611 /* Weirdo operator: see comments for gen_repeat for details. */
1613 /* Note that gen_repeat handles its own argument evaluation. */
1615 gen_repeat (pc
, ax
, value
);
1620 struct type
*type
= (*pc
)[1].type
;
1622 gen_expr (pc
, ax
, value
);
1623 gen_cast (ax
, value
, type
);
1629 struct type
*type
= check_typedef ((*pc
)[1].type
);
1631 gen_expr (pc
, ax
, value
);
1632 /* I'm not sure I understand UNOP_MEMVAL entirely. I think
1633 it's just a hack for dealing with minsyms; you take some
1634 integer constant, pretend it's the address of an lvalue of
1635 the given type, and dereference it. */
1636 if (value
->kind
!= axs_rvalue
)
1637 /* This would be weird. */
1638 internal_error (__FILE__
, __LINE__
,
1639 _("gen_expr: OP_MEMVAL operand isn't an rvalue???"));
1641 value
->kind
= axs_lvalue_memory
;
1647 /* -FOO is equivalent to 0 - FOO. */
1648 gen_int_literal (ax
, &value1
, (LONGEST
) 0, builtin_type_int
);
1649 gen_usual_unary (ax
, &value1
); /* shouldn't do much */
1650 gen_expr (pc
, ax
, &value2
);
1651 gen_usual_unary (ax
, &value2
);
1652 gen_usual_arithmetic (ax
, &value1
, &value2
);
1653 gen_sub (ax
, value
, &value1
, &value2
);
1656 case UNOP_LOGICAL_NOT
:
1658 gen_expr (pc
, ax
, value
);
1659 gen_logical_not (ax
, value
);
1662 case UNOP_COMPLEMENT
:
1664 gen_expr (pc
, ax
, value
);
1665 gen_complement (ax
, value
);
1670 gen_expr (pc
, ax
, value
);
1671 gen_usual_unary (ax
, value
);
1672 if (TYPE_CODE (value
->type
) != TYPE_CODE_PTR
)
1673 error (_("Argument of unary `*' is not a pointer."));
1674 gen_deref (ax
, value
);
1679 gen_expr (pc
, ax
, value
);
1680 gen_address_of (ax
, value
);
1685 /* Notice that gen_sizeof handles its own operand, unlike most
1686 of the other unary operator functions. This is because we
1687 have to throw away the code we generate. */
1688 gen_sizeof (pc
, ax
, value
);
1691 case STRUCTOP_STRUCT
:
1694 int length
= (*pc
)[1].longconst
;
1695 char *name
= &(*pc
)[2].string
;
1697 (*pc
) += 4 + BYTES_TO_EXP_ELEM (length
+ 1);
1698 gen_expr (pc
, ax
, value
);
1699 if (op
== STRUCTOP_STRUCT
)
1700 gen_struct_ref (ax
, value
, name
, ".", "structure or union");
1701 else if (op
== STRUCTOP_PTR
)
1702 gen_struct_ref (ax
, value
, name
, "->",
1703 "pointer to a structure or union");
1705 /* If this `if' chain doesn't handle it, then the case list
1706 shouldn't mention it, and we shouldn't be here. */
1707 internal_error (__FILE__
, __LINE__
,
1708 _("gen_expr: unhandled struct case"));
1713 error (_("Attempt to use a type name as an expression."));
1716 error (_("Unsupported operator in expression."));
1722 /* Generating bytecode from GDB expressions: driver */
1724 /* Given a GDB expression EXPR, produce a string of agent bytecode
1725 which computes its value. Return the agent expression, and set
1726 *VALUE to describe its type, and whether it's an lvalue or rvalue. */
1728 expr_to_agent (struct expression
*expr
, struct axs_value
*value
)
1730 struct cleanup
*old_chain
= 0;
1731 struct agent_expr
*ax
= new_agent_expr (0);
1732 union exp_element
*pc
;
1734 old_chain
= make_cleanup_free_agent_expr (ax
);
1738 gen_expr (&pc
, ax
, value
);
1740 /* We have successfully built the agent expr, so cancel the cleanup
1741 request. If we add more cleanups that we always want done, this
1742 will have to get more complicated. */
1743 discard_cleanups (old_chain
);
1748 #if 0 /* not used */
1749 /* Given a GDB expression EXPR denoting an lvalue in memory, produce a
1750 string of agent bytecode which will leave its address and size on
1751 the top of stack. Return the agent expression.
1753 Not sure this function is useful at all. */
1755 expr_to_address_and_size (struct expression
*expr
)
1757 struct axs_value value
;
1758 struct agent_expr
*ax
= expr_to_agent (expr
, &value
);
1760 /* Complain if the result is not a memory lvalue. */
1761 if (value
.kind
!= axs_lvalue_memory
)
1763 free_agent_expr (ax
);
1764 error (_("Expression does not denote an object in memory."));
1767 /* Push the object's size on the stack. */
1768 ax_const_l (ax
, TYPE_LENGTH (value
.type
));
1774 /* Given a GDB expression EXPR, return bytecode to trace its value.
1775 The result will use the `trace' and `trace_quick' bytecodes to
1776 record the value of all memory touched by the expression. The
1777 caller can then use the ax_reqs function to discover which
1778 registers it relies upon. */
1780 gen_trace_for_expr (CORE_ADDR scope
, struct expression
*expr
)
1782 struct cleanup
*old_chain
= 0;
1783 struct agent_expr
*ax
= new_agent_expr (scope
);
1784 union exp_element
*pc
;
1785 struct axs_value value
;
1787 old_chain
= make_cleanup_free_agent_expr (ax
);
1791 gen_expr (&pc
, ax
, &value
);
1793 /* Make sure we record the final object, and get rid of it. */
1794 gen_traced_pop (ax
, &value
);
1796 /* Oh, and terminate. */
1797 ax_simple (ax
, aop_end
);
1799 /* We have successfully built the agent expr, so cancel the cleanup
1800 request. If we add more cleanups that we always want done, this
1801 will have to get more complicated. */
1802 discard_cleanups (old_chain
);
1807 agent_command (char *exp
, int from_tty
)
1809 struct cleanup
*old_chain
= 0;
1810 struct expression
*expr
;
1811 struct agent_expr
*agent
;
1812 struct frame_info
*fi
= get_current_frame (); /* need current scope */
1814 /* We don't deal with overlay debugging at the moment. We need to
1815 think more carefully about this. If you copy this code into
1816 another command, change the error message; the user shouldn't
1817 have to know anything about agent expressions. */
1818 if (overlay_debugging
)
1819 error (_("GDB can't do agent expression translation with overlays."));
1822 error_no_arg (_("expression to translate"));
1824 expr
= parse_expression (exp
);
1825 old_chain
= make_cleanup (free_current_contents
, &expr
);
1826 agent
= gen_trace_for_expr (get_frame_pc (fi
), expr
);
1827 make_cleanup_free_agent_expr (agent
);
1828 ax_print (gdb_stdout
, agent
);
1830 /* It would be nice to call ax_reqs here to gather some general info
1831 about the expression, and then print out the result. */
1833 do_cleanups (old_chain
);
1838 /* Initialization code. */
1840 void _initialize_ax_gdb (void);
1842 _initialize_ax_gdb (void)
1844 add_cmd ("agent", class_maintenance
, agent_command
,
1845 _("Translate an expression into remote agent bytecode."),