1 /* GDB-specific functions for operating on agent expressions
2 Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
26 #include "expression.h"
34 /* To make sense of this file, you should read doc/agentexpr.texi.
35 Then look at the types and enums in ax-gdb.h. For the code itself,
36 look at gen_expr, towards the bottom; that's the main function that
37 looks at the GDB expressions and calls everything else to generate
40 I'm beginning to wonder whether it wouldn't be nicer to internally
41 generate trees, with types, and then spit out the bytecode in
42 linear form afterwards; we could generate fewer `swap', `ext', and
43 `zero_ext' bytecodes that way; it would make good constant folding
44 easier, too. But at the moment, I think we should be willing to
45 pay for the simplicity of this code with less-than-optimal bytecode
48 Remember, "GBD" stands for "Great Britain, Dammit!" So be careful. */
52 /* Prototypes for local functions. */
54 /* There's a standard order to the arguments of these functions:
55 union exp_element ** --- pointer into expression
56 struct agent_expr * --- agent expression buffer to generate code into
57 struct axs_value * --- describes value left on top of stack */
59 static struct value *const_var_ref (struct symbol *var);
60 static struct value *const_expr (union exp_element **pc);
61 static struct value *maybe_const_expr (union exp_element **pc);
63 static void gen_traced_pop (struct agent_expr *, struct axs_value *);
65 static void gen_sign_extend (struct agent_expr *, struct type *);
66 static void gen_extend (struct agent_expr *, struct type *);
67 static void gen_fetch (struct agent_expr *, struct type *);
68 static void gen_left_shift (struct agent_expr *, int);
71 static void gen_frame_args_address (struct agent_expr *);
72 static void gen_frame_locals_address (struct agent_expr *);
73 static void gen_offset (struct agent_expr *ax, int offset);
74 static void gen_sym_offset (struct agent_expr *, struct symbol *);
75 static void gen_var_ref (struct agent_expr *ax,
76 struct axs_value *value, struct symbol *var);
79 static void gen_int_literal (struct agent_expr *ax,
80 struct axs_value *value,
81 LONGEST k, struct type *type);
84 static void require_rvalue (struct agent_expr *ax, struct axs_value *value);
85 static void gen_usual_unary (struct agent_expr *ax, struct axs_value *value);
86 static int type_wider_than (struct type *type1, struct type *type2);
87 static struct type *max_type (struct type *type1, struct type *type2);
88 static void gen_conversion (struct agent_expr *ax,
89 struct type *from, struct type *to);
90 static int is_nontrivial_conversion (struct type *from, struct type *to);
91 static void gen_usual_arithmetic (struct agent_expr *ax,
92 struct axs_value *value1,
93 struct axs_value *value2);
94 static void gen_integral_promotions (struct agent_expr *ax,
95 struct axs_value *value);
96 static void gen_cast (struct agent_expr *ax,
97 struct axs_value *value, struct type *type);
98 static void gen_scale (struct agent_expr *ax,
99 enum agent_op op, struct type *type);
100 static void gen_add (struct agent_expr *ax,
101 struct axs_value *value,
102 struct axs_value *value1,
103 struct axs_value *value2, char *name);
104 static void gen_sub (struct agent_expr *ax,
105 struct axs_value *value,
106 struct axs_value *value1, struct axs_value *value2);
107 static void gen_binop (struct agent_expr *ax,
108 struct axs_value *value,
109 struct axs_value *value1,
110 struct axs_value *value2,
112 enum agent_op op_unsigned, int may_carry, char *name);
113 static void gen_logical_not (struct agent_expr *ax, struct axs_value *value);
114 static void gen_complement (struct agent_expr *ax, struct axs_value *value);
115 static void gen_deref (struct agent_expr *, struct axs_value *);
116 static void gen_address_of (struct agent_expr *, struct axs_value *);
117 static int find_field (struct type *type, char *name);
118 static void gen_bitfield_ref (struct agent_expr *ax,
119 struct axs_value *value,
120 struct type *type, int start, int end);
121 static void gen_struct_ref (struct agent_expr *ax,
122 struct axs_value *value,
124 char *operator_name, char *operand_name);
125 static void gen_repeat (union exp_element **pc,
126 struct agent_expr *ax, struct axs_value *value);
127 static void gen_sizeof (union exp_element **pc,
128 struct agent_expr *ax, struct axs_value *value);
129 static void gen_expr (union exp_element **pc,
130 struct agent_expr *ax, struct axs_value *value);
132 static void print_axs_value (struct ui_file *f, struct axs_value * value);
133 static void agent_command (char *exp, int from_tty);
136 /* Detecting constant expressions. */
138 /* If the variable reference at *PC is a constant, return its value.
139 Otherwise, return zero.
141 Hey, Wally! How can a variable reference be a constant?
143 Well, Beav, this function really handles the OP_VAR_VALUE operator,
144 not specifically variable references. GDB uses OP_VAR_VALUE to
145 refer to any kind of symbolic reference: function names, enum
146 elements, and goto labels are all handled through the OP_VAR_VALUE
147 operator, even though they're constants. It makes sense given the
150 Gee, Wally, don'cha wonder sometimes if data representations that
151 subvert commonly accepted definitions of terms in favor of heavily
152 context-specific interpretations are really just a tool of the
153 programming hegemony to preserve their power and exclude the
156 static struct value *
157 const_var_ref (struct symbol *var)
159 struct type *type = SYMBOL_TYPE (var);
161 switch (SYMBOL_CLASS (var))
164 return value_from_longest (type, (LONGEST) SYMBOL_VALUE (var));
167 return value_from_pointer (type, (CORE_ADDR) SYMBOL_VALUE_ADDRESS (var));
175 /* If the expression starting at *PC has a constant value, return it.
176 Otherwise, return zero. If we return a value, then *PC will be
177 advanced to the end of it. If we return zero, *PC could be
179 static struct value *
180 const_expr (union exp_element **pc)
182 enum exp_opcode op = (*pc)->opcode;
189 struct type *type = (*pc)[1].type;
190 LONGEST k = (*pc)[2].longconst;
192 return value_from_longest (type, k);
197 struct value *v = const_var_ref ((*pc)[2].symbol);
202 /* We could add more operators in here. */
206 v1 = const_expr (pc);
208 return value_neg (v1);
218 /* Like const_expr, but guarantee also that *PC is undisturbed if the
219 expression is not constant. */
220 static struct value *
221 maybe_const_expr (union exp_element **pc)
223 union exp_element *tentative_pc = *pc;
224 struct value *v = const_expr (&tentative_pc);
226 /* If we got a value, then update the real PC. */
234 /* Generating bytecode from GDB expressions: general assumptions */
236 /* Here are a few general assumptions made throughout the code; if you
237 want to make a change that contradicts one of these, then you'd
238 better scan things pretty thoroughly.
240 - We assume that all values occupy one stack element. For example,
241 sometimes we'll swap to get at the left argument to a binary
242 operator. If we decide that void values should occupy no stack
243 elements, or that synthetic arrays (whose size is determined at
244 run time, created by the `@' operator) should occupy two stack
245 elements (address and length), then this will cause trouble.
247 - We assume the stack elements are infinitely wide, and that we
248 don't have to worry what happens if the user requests an
249 operation that is wider than the actual interpreter's stack.
250 That is, it's up to the interpreter to handle directly all the
251 integer widths the user has access to. (Woe betide the language
254 - We don't support side effects. Thus, we don't have to worry about
255 GCC's generalized lvalues, function calls, etc.
257 - We don't support floating point. Many places where we switch on
258 some type don't bother to include cases for floating point; there
259 may be even more subtle ways this assumption exists. For
260 example, the arguments to % must be integers.
262 - We assume all subexpressions have a static, unchanging type. If
263 we tried to support convenience variables, this would be a
266 - All values on the stack should always be fully zero- or
269 (I wasn't sure whether to choose this or its opposite --- that
270 only addresses are assumed extended --- but it turns out that
271 neither convention completely eliminates spurious extend
272 operations (if everything is always extended, then you have to
273 extend after add, because it could overflow; if nothing is
274 extended, then you end up producing extends whenever you change
275 sizes), and this is simpler.) */
278 /* Generating bytecode from GDB expressions: the `trace' kludge */
280 /* The compiler in this file is a general-purpose mechanism for
281 translating GDB expressions into bytecode. One ought to be able to
282 find a million and one uses for it.
284 However, at the moment it is HOPELESSLY BRAIN-DAMAGED for the sake
285 of expediency. Let he who is without sin cast the first stone.
287 For the data tracing facility, we need to insert `trace' bytecodes
288 before each data fetch; this records all the memory that the
289 expression touches in the course of evaluation, so that memory will
290 be available when the user later tries to evaluate the expression
293 This should be done (I think) in a post-processing pass, that walks
294 an arbitrary agent expression and inserts `trace' operations at the
295 appropriate points. But it's much faster to just hack them
296 directly into the code. And since we're in a crunch, that's what
299 Setting the flag trace_kludge to non-zero enables the code that
300 emits the trace bytecodes at the appropriate points. */
301 static int trace_kludge;
303 /* Trace the lvalue on the stack, if it needs it. In either case, pop
304 the value. Useful on the left side of a comma, and at the end of
305 an expression being used for tracing. */
307 gen_traced_pop (struct agent_expr *ax, struct axs_value *value)
313 /* We don't trace rvalues, just the lvalues necessary to
314 produce them. So just dispose of this value. */
315 ax_simple (ax, aop_pop);
318 case axs_lvalue_memory:
320 int length = TYPE_LENGTH (value->type);
322 /* There's no point in trying to use a trace_quick bytecode
323 here, since "trace_quick SIZE pop" is three bytes, whereas
324 "const8 SIZE trace" is also three bytes, does the same
325 thing, and the simplest code which generates that will also
326 work correctly for objects with large sizes. */
327 ax_const_l (ax, length);
328 ax_simple (ax, aop_trace);
332 case axs_lvalue_register:
333 /* We need to mention the register somewhere in the bytecode,
334 so ax_reqs will pick it up and add it to the mask of
336 ax_reg (ax, value->u.reg);
337 ax_simple (ax, aop_pop);
341 /* If we're not tracing, just pop the value. */
342 ax_simple (ax, aop_pop);
347 /* Generating bytecode from GDB expressions: helper functions */
349 /* Assume that the lower bits of the top of the stack is a value of
350 type TYPE, and the upper bits are zero. Sign-extend if necessary. */
352 gen_sign_extend (struct agent_expr *ax, struct type *type)
354 /* Do we need to sign-extend this? */
355 if (!TYPE_UNSIGNED (type))
356 ax_ext (ax, type->length * TARGET_CHAR_BIT);
360 /* Assume the lower bits of the top of the stack hold a value of type
361 TYPE, and the upper bits are garbage. Sign-extend or truncate as
364 gen_extend (struct agent_expr *ax, struct type *type)
366 int bits = type->length * TARGET_CHAR_BIT;
368 ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, bits));
372 /* Assume that the top of the stack contains a value of type "pointer
373 to TYPE"; generate code to fetch its value. Note that TYPE is the
374 target type, not the pointer type. */
376 gen_fetch (struct agent_expr *ax, struct type *type)
380 /* Record the area of memory we're about to fetch. */
381 ax_trace_quick (ax, TYPE_LENGTH (type));
390 /* It's a scalar value, so we know how to dereference it. How
391 many bytes long is it? */
392 switch (type->length)
394 case 8 / TARGET_CHAR_BIT:
395 ax_simple (ax, aop_ref8);
397 case 16 / TARGET_CHAR_BIT:
398 ax_simple (ax, aop_ref16);
400 case 32 / TARGET_CHAR_BIT:
401 ax_simple (ax, aop_ref32);
403 case 64 / TARGET_CHAR_BIT:
404 ax_simple (ax, aop_ref64);
407 /* Either our caller shouldn't have asked us to dereference
408 that pointer (other code's fault), or we're not
409 implementing something we should be (this code's fault).
410 In any case, it's a bug the user shouldn't see. */
412 internal_error (__FILE__, __LINE__,
413 "gen_fetch: strange size");
416 gen_sign_extend (ax, type);
420 /* Either our caller shouldn't have asked us to dereference that
421 pointer (other code's fault), or we're not implementing
422 something we should be (this code's fault). In any case,
423 it's a bug the user shouldn't see. */
424 internal_error (__FILE__, __LINE__,
425 "gen_fetch: bad type code");
430 /* Generate code to left shift the top of the stack by DISTANCE bits, or
431 right shift it by -DISTANCE bits if DISTANCE < 0. This generates
432 unsigned (logical) right shifts. */
434 gen_left_shift (struct agent_expr *ax, int distance)
438 ax_const_l (ax, distance);
439 ax_simple (ax, aop_lsh);
441 else if (distance < 0)
443 ax_const_l (ax, -distance);
444 ax_simple (ax, aop_rsh_unsigned);
450 /* Generating bytecode from GDB expressions: symbol references */
452 /* Generate code to push the base address of the argument portion of
453 the top stack frame. */
455 gen_frame_args_address (struct agent_expr *ax)
457 long frame_reg, frame_offset;
459 TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset);
460 ax_reg (ax, frame_reg);
461 gen_offset (ax, frame_offset);
465 /* Generate code to push the base address of the locals portion of the
468 gen_frame_locals_address (struct agent_expr *ax)
470 long frame_reg, frame_offset;
472 TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset);
473 ax_reg (ax, frame_reg);
474 gen_offset (ax, frame_offset);
478 /* Generate code to add OFFSET to the top of the stack. Try to
479 generate short and readable code. We use this for getting to
480 variables on the stack, and structure members. If we were
481 programming in ML, it would be clearer why these are the same
484 gen_offset (struct agent_expr *ax, int offset)
486 /* It would suffice to simply push the offset and add it, but this
487 makes it easier to read positive and negative offsets in the
491 ax_const_l (ax, offset);
492 ax_simple (ax, aop_add);
496 ax_const_l (ax, -offset);
497 ax_simple (ax, aop_sub);
502 /* In many cases, a symbol's value is the offset from some other
503 address (stack frame, base register, etc.) Generate code to add
504 VAR's value to the top of the stack. */
506 gen_sym_offset (struct agent_expr *ax, struct symbol *var)
508 gen_offset (ax, SYMBOL_VALUE (var));
512 /* Generate code for a variable reference to AX. The variable is the
513 symbol VAR. Set VALUE to describe the result. */
516 gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var)
518 /* Dereference any typedefs. */
519 value->type = check_typedef (SYMBOL_TYPE (var));
521 /* I'm imitating the code in read_var_value. */
522 switch (SYMBOL_CLASS (var))
524 case LOC_CONST: /* A constant, like an enum value. */
525 ax_const_l (ax, (LONGEST) SYMBOL_VALUE (var));
526 value->kind = axs_rvalue;
529 case LOC_LABEL: /* A goto label, being used as a value. */
530 ax_const_l (ax, (LONGEST) SYMBOL_VALUE_ADDRESS (var));
531 value->kind = axs_rvalue;
534 case LOC_CONST_BYTES:
535 internal_error (__FILE__, __LINE__,
536 "gen_var_ref: LOC_CONST_BYTES symbols are not supported");
538 /* Variable at a fixed location in memory. Easy. */
540 /* Push the address of the variable. */
541 ax_const_l (ax, SYMBOL_VALUE_ADDRESS (var));
542 value->kind = axs_lvalue_memory;
545 case LOC_ARG: /* var lives in argument area of frame */
546 gen_frame_args_address (ax);
547 gen_sym_offset (ax, var);
548 value->kind = axs_lvalue_memory;
551 case LOC_REF_ARG: /* As above, but the frame slot really
552 holds the address of the variable. */
553 gen_frame_args_address (ax);
554 gen_sym_offset (ax, var);
555 /* Don't assume any particular pointer size. */
556 gen_fetch (ax, lookup_pointer_type (builtin_type_void));
557 value->kind = axs_lvalue_memory;
560 case LOC_LOCAL: /* var lives in locals area of frame */
562 gen_frame_locals_address (ax);
563 gen_sym_offset (ax, var);
564 value->kind = axs_lvalue_memory;
567 case LOC_BASEREG: /* relative to some base register */
568 case LOC_BASEREG_ARG:
569 ax_reg (ax, SYMBOL_BASEREG (var));
570 gen_sym_offset (ax, var);
571 value->kind = axs_lvalue_memory;
575 error ("Cannot compute value of typedef `%s'.",
576 SYMBOL_SOURCE_NAME (var));
580 ax_const_l (ax, BLOCK_START (SYMBOL_BLOCK_VALUE (var)));
581 value->kind = axs_rvalue;
586 /* Don't generate any code at all; in the process of treating
587 this as an lvalue or rvalue, the caller will generate the
589 value->kind = axs_lvalue_register;
590 value->u.reg = SYMBOL_VALUE (var);
593 /* A lot like LOC_REF_ARG, but the pointer lives directly in a
594 register, not on the stack. Simpler than LOC_REGISTER and
595 LOC_REGPARM, because it's just like any other case where the
596 thing has a real address. */
597 case LOC_REGPARM_ADDR:
598 ax_reg (ax, SYMBOL_VALUE (var));
599 value->kind = axs_lvalue_memory;
604 struct minimal_symbol *msym
605 = lookup_minimal_symbol (SYMBOL_NAME (var), NULL, NULL);
607 error ("Couldn't resolve symbol `%s'.", SYMBOL_SOURCE_NAME (var));
609 /* Push the address of the variable. */
610 ax_const_l (ax, SYMBOL_VALUE_ADDRESS (msym));
611 value->kind = axs_lvalue_memory;
615 case LOC_OPTIMIZED_OUT:
616 error ("The variable `%s' has been optimized out.",
617 SYMBOL_SOURCE_NAME (var));
621 error ("Cannot find value of botched symbol `%s'.",
622 SYMBOL_SOURCE_NAME (var));
629 /* Generating bytecode from GDB expressions: literals */
632 gen_int_literal (struct agent_expr *ax, struct axs_value *value, LONGEST k,
636 value->kind = axs_rvalue;
642 /* Generating bytecode from GDB expressions: unary conversions, casts */
644 /* Take what's on the top of the stack (as described by VALUE), and
645 try to make an rvalue out of it. Signal an error if we can't do
648 require_rvalue (struct agent_expr *ax, struct axs_value *value)
653 /* It's already an rvalue. */
656 case axs_lvalue_memory:
657 /* The top of stack is the address of the object. Dereference. */
658 gen_fetch (ax, value->type);
661 case axs_lvalue_register:
662 /* There's nothing on the stack, but value->u.reg is the
663 register number containing the value.
665 When we add floating-point support, this is going to have to
666 change. What about SPARC register pairs, for example? */
667 ax_reg (ax, value->u.reg);
668 gen_extend (ax, value->type);
672 value->kind = axs_rvalue;
676 /* Assume the top of the stack is described by VALUE, and perform the
677 usual unary conversions. This is motivated by ANSI 6.2.2, but of
678 course GDB expressions are not ANSI; they're the mishmash union of
679 a bunch of languages. Rah.
681 NOTE! This function promises to produce an rvalue only when the
682 incoming value is of an appropriate type. In other words, the
683 consumer of the value this function produces may assume the value
684 is an rvalue only after checking its type.
686 The immediate issue is that if the user tries to use a structure or
687 union as an operand of, say, the `+' operator, we don't want to try
688 to convert that structure to an rvalue; require_rvalue will bomb on
689 structs and unions. Rather, we want to simply pass the struct
690 lvalue through unchanged, and let `+' raise an error. */
693 gen_usual_unary (struct agent_expr *ax, struct axs_value *value)
695 /* We don't have to generate any code for the usual integral
696 conversions, since values are always represented as full-width on
697 the stack. Should we tweak the type? */
699 /* Some types require special handling. */
700 switch (value->type->code)
702 /* Functions get converted to a pointer to the function. */
704 value->type = lookup_pointer_type (value->type);
705 value->kind = axs_rvalue; /* Should always be true, but just in case. */
708 /* Arrays get converted to a pointer to their first element, and
709 are no longer an lvalue. */
710 case TYPE_CODE_ARRAY:
712 struct type *elements = TYPE_TARGET_TYPE (value->type);
713 value->type = lookup_pointer_type (elements);
714 value->kind = axs_rvalue;
715 /* We don't need to generate any code; the address of the array
716 is also the address of its first element. */
720 /* Don't try to convert structures and unions to rvalues. Let the
721 consumer signal an error. */
722 case TYPE_CODE_STRUCT:
723 case TYPE_CODE_UNION:
726 /* If the value is an enum, call it an integer. */
728 value->type = builtin_type_int;
732 /* If the value is an lvalue, dereference it. */
733 require_rvalue (ax, value);
737 /* Return non-zero iff the type TYPE1 is considered "wider" than the
738 type TYPE2, according to the rules described in gen_usual_arithmetic. */
740 type_wider_than (struct type *type1, struct type *type2)
742 return (TYPE_LENGTH (type1) > TYPE_LENGTH (type2)
743 || (TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
744 && TYPE_UNSIGNED (type1)
745 && !TYPE_UNSIGNED (type2)));
749 /* Return the "wider" of the two types TYPE1 and TYPE2. */
751 max_type (struct type *type1, struct type *type2)
753 return type_wider_than (type1, type2) ? type1 : type2;
757 /* Generate code to convert a scalar value of type FROM to type TO. */
759 gen_conversion (struct agent_expr *ax, struct type *from, struct type *to)
761 /* Perhaps there is a more graceful way to state these rules. */
763 /* If we're converting to a narrower type, then we need to clear out
765 if (TYPE_LENGTH (to) < TYPE_LENGTH (from))
766 gen_extend (ax, from);
768 /* If the two values have equal width, but different signednesses,
769 then we need to extend. */
770 else if (TYPE_LENGTH (to) == TYPE_LENGTH (from))
772 if (TYPE_UNSIGNED (from) != TYPE_UNSIGNED (to))
776 /* If we're converting to a wider type, and becoming unsigned, then
777 we need to zero out any possible sign bits. */
778 else if (TYPE_LENGTH (to) > TYPE_LENGTH (from))
780 if (TYPE_UNSIGNED (to))
786 /* Return non-zero iff the type FROM will require any bytecodes to be
787 emitted to be converted to the type TO. */
789 is_nontrivial_conversion (struct type *from, struct type *to)
791 struct agent_expr *ax = new_agent_expr (0);
794 /* Actually generate the code, and see if anything came out. At the
795 moment, it would be trivial to replicate the code in
796 gen_conversion here, but in the future, when we're supporting
797 floating point and the like, it may not be. Doing things this
798 way allows this function to be independent of the logic in
800 gen_conversion (ax, from, to);
801 nontrivial = ax->len > 0;
802 free_agent_expr (ax);
807 /* Generate code to perform the "usual arithmetic conversions" (ANSI C
808 6.2.1.5) for the two operands of an arithmetic operator. This
809 effectively finds a "least upper bound" type for the two arguments,
810 and promotes each argument to that type. *VALUE1 and *VALUE2
811 describe the values as they are passed in, and as they are left. */
813 gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1,
814 struct axs_value *value2)
816 /* Do the usual binary conversions. */
817 if (TYPE_CODE (value1->type) == TYPE_CODE_INT
818 && TYPE_CODE (value2->type) == TYPE_CODE_INT)
820 /* The ANSI integral promotions seem to work this way: Order the
821 integer types by size, and then by signedness: an n-bit
822 unsigned type is considered "wider" than an n-bit signed
823 type. Promote to the "wider" of the two types, and always
824 promote at least to int. */
825 struct type *target = max_type (builtin_type_int,
826 max_type (value1->type, value2->type));
828 /* Deal with value2, on the top of the stack. */
829 gen_conversion (ax, value2->type, target);
831 /* Deal with value1, not on the top of the stack. Don't
832 generate the `swap' instructions if we're not actually going
834 if (is_nontrivial_conversion (value1->type, target))
836 ax_simple (ax, aop_swap);
837 gen_conversion (ax, value1->type, target);
838 ax_simple (ax, aop_swap);
841 value1->type = value2->type = target;
846 /* Generate code to perform the integral promotions (ANSI 6.2.1.1) on
847 the value on the top of the stack, as described by VALUE. Assume
848 the value has integral type. */
850 gen_integral_promotions (struct agent_expr *ax, struct axs_value *value)
852 if (!type_wider_than (value->type, builtin_type_int))
854 gen_conversion (ax, value->type, builtin_type_int);
855 value->type = builtin_type_int;
857 else if (!type_wider_than (value->type, builtin_type_unsigned_int))
859 gen_conversion (ax, value->type, builtin_type_unsigned_int);
860 value->type = builtin_type_unsigned_int;
865 /* Generate code for a cast to TYPE. */
867 gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type)
869 /* GCC does allow casts to yield lvalues, so this should be fixed
870 before merging these changes into the trunk. */
871 require_rvalue (ax, value);
872 /* Dereference typedefs. */
873 type = check_typedef (type);
878 /* It's implementation-defined, and I'll bet this is what GCC
882 case TYPE_CODE_ARRAY:
883 case TYPE_CODE_STRUCT:
884 case TYPE_CODE_UNION:
886 error ("Illegal type cast: intended type must be scalar.");
889 /* We don't have to worry about the size of the value, because
890 all our integral values are fully sign-extended, and when
891 casting pointers we can do anything we like. Is there any
892 way for us to actually know what GCC actually does with a
898 gen_conversion (ax, value->type, type);
902 /* We could pop the value, and rely on everyone else to check
903 the type and notice that this value doesn't occupy a stack
904 slot. But for now, leave the value on the stack, and
905 preserve the "value == stack element" assumption. */
909 error ("Casts to requested type are not yet implemented.");
917 /* Generating bytecode from GDB expressions: arithmetic */
919 /* Scale the integer on the top of the stack by the size of the target
920 of the pointer type TYPE. */
922 gen_scale (struct agent_expr *ax, enum agent_op op, struct type *type)
924 struct type *element = TYPE_TARGET_TYPE (type);
926 if (element->length != 1)
928 ax_const_l (ax, element->length);
934 /* Generate code for an addition; non-trivial because we deal with
935 pointer arithmetic. We set VALUE to describe the result value; we
936 assume VALUE1 and VALUE2 describe the two operands, and that
937 they've undergone the usual binary conversions. Used by both
938 BINOP_ADD and BINOP_SUBSCRIPT. NAME is used in error messages. */
940 gen_add (struct agent_expr *ax, struct axs_value *value,
941 struct axs_value *value1, struct axs_value *value2, char *name)
944 if (value1->type->code == TYPE_CODE_INT
945 && value2->type->code == TYPE_CODE_PTR)
947 /* Swap the values and proceed normally. */
948 ax_simple (ax, aop_swap);
949 gen_scale (ax, aop_mul, value2->type);
950 ax_simple (ax, aop_add);
951 gen_extend (ax, value2->type); /* Catch overflow. */
952 value->type = value2->type;
956 else if (value1->type->code == TYPE_CODE_PTR
957 && value2->type->code == TYPE_CODE_INT)
959 gen_scale (ax, aop_mul, value1->type);
960 ax_simple (ax, aop_add);
961 gen_extend (ax, value1->type); /* Catch overflow. */
962 value->type = value1->type;
965 /* Must be number + number; the usual binary conversions will have
966 brought them both to the same width. */
967 else if (value1->type->code == TYPE_CODE_INT
968 && value2->type->code == TYPE_CODE_INT)
970 ax_simple (ax, aop_add);
971 gen_extend (ax, value1->type); /* Catch overflow. */
972 value->type = value1->type;
976 error ("Illegal combination of types in %s.", name);
978 value->kind = axs_rvalue;
982 /* Generate code for an addition; non-trivial because we have to deal
983 with pointer arithmetic. We set VALUE to describe the result
984 value; we assume VALUE1 and VALUE2 describe the two operands, and
985 that they've undergone the usual binary conversions. */
987 gen_sub (struct agent_expr *ax, struct axs_value *value,
988 struct axs_value *value1, struct axs_value *value2)
990 if (value1->type->code == TYPE_CODE_PTR)
992 /* Is it PTR - INT? */
993 if (value2->type->code == TYPE_CODE_INT)
995 gen_scale (ax, aop_mul, value1->type);
996 ax_simple (ax, aop_sub);
997 gen_extend (ax, value1->type); /* Catch overflow. */
998 value->type = value1->type;
1001 /* Is it PTR - PTR? Strictly speaking, the types ought to
1002 match, but this is what the normal GDB expression evaluator
1004 else if (value2->type->code == TYPE_CODE_PTR
1005 && (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type))
1006 == TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type))))
1008 ax_simple (ax, aop_sub);
1009 gen_scale (ax, aop_div_unsigned, value1->type);
1010 value->type = builtin_type_long; /* FIXME --- should be ptrdiff_t */
1014 First argument of `-' is a pointer, but second argument is neither\n\
1015 an integer nor a pointer of the same type.");
1018 /* Must be number + number. */
1019 else if (value1->type->code == TYPE_CODE_INT
1020 && value2->type->code == TYPE_CODE_INT)
1022 ax_simple (ax, aop_sub);
1023 gen_extend (ax, value1->type); /* Catch overflow. */
1024 value->type = value1->type;
1028 error ("Illegal combination of types in subtraction.");
1030 value->kind = axs_rvalue;
1033 /* Generate code for a binary operator that doesn't do pointer magic.
1034 We set VALUE to describe the result value; we assume VALUE1 and
1035 VALUE2 describe the two operands, and that they've undergone the
1036 usual binary conversions. MAY_CARRY should be non-zero iff the
1037 result needs to be extended. NAME is the English name of the
1038 operator, used in error messages */
1040 gen_binop (struct agent_expr *ax, struct axs_value *value,
1041 struct axs_value *value1, struct axs_value *value2, enum agent_op op,
1042 enum agent_op op_unsigned, int may_carry, char *name)
1044 /* We only handle INT op INT. */
1045 if ((value1->type->code != TYPE_CODE_INT)
1046 || (value2->type->code != TYPE_CODE_INT))
1047 error ("Illegal combination of types in %s.", name);
1050 TYPE_UNSIGNED (value1->type) ? op_unsigned : op);
1052 gen_extend (ax, value1->type); /* catch overflow */
1053 value->type = value1->type;
1054 value->kind = axs_rvalue;
1059 gen_logical_not (struct agent_expr *ax, struct axs_value *value)
1061 if (TYPE_CODE (value->type) != TYPE_CODE_INT
1062 && TYPE_CODE (value->type) != TYPE_CODE_PTR)
1063 error ("Illegal type of operand to `!'.");
1065 gen_usual_unary (ax, value);
1066 ax_simple (ax, aop_log_not);
1067 value->type = builtin_type_int;
1072 gen_complement (struct agent_expr *ax, struct axs_value *value)
1074 if (TYPE_CODE (value->type) != TYPE_CODE_INT)
1075 error ("Illegal type of operand to `~'.");
1077 gen_usual_unary (ax, value);
1078 gen_integral_promotions (ax, value);
1079 ax_simple (ax, aop_bit_not);
1080 gen_extend (ax, value->type);
1085 /* Generating bytecode from GDB expressions: * & . -> @ sizeof */
1087 /* Dereference the value on the top of the stack. */
1089 gen_deref (struct agent_expr *ax, struct axs_value *value)
1091 /* The caller should check the type, because several operators use
1092 this, and we don't know what error message to generate. */
1093 if (value->type->code != TYPE_CODE_PTR)
1094 internal_error (__FILE__, __LINE__,
1095 "gen_deref: expected a pointer");
1097 /* We've got an rvalue now, which is a pointer. We want to yield an
1098 lvalue, whose address is exactly that pointer. So we don't
1099 actually emit any code; we just change the type from "Pointer to
1100 T" to "T", and mark the value as an lvalue in memory. Leave it
1101 to the consumer to actually dereference it. */
1102 value->type = check_typedef (TYPE_TARGET_TYPE (value->type));
1103 value->kind = ((value->type->code == TYPE_CODE_FUNC)
1104 ? axs_rvalue : axs_lvalue_memory);
1108 /* Produce the address of the lvalue on the top of the stack. */
1110 gen_address_of (struct agent_expr *ax, struct axs_value *value)
1112 /* Special case for taking the address of a function. The ANSI
1113 standard describes this as a special case, too, so this
1114 arrangement is not without motivation. */
1115 if (value->type->code == TYPE_CODE_FUNC)
1116 /* The value's already an rvalue on the stack, so we just need to
1118 value->type = lookup_pointer_type (value->type);
1120 switch (value->kind)
1123 error ("Operand of `&' is an rvalue, which has no address.");
1125 case axs_lvalue_register:
1126 error ("Operand of `&' is in a register, and has no address.");
1128 case axs_lvalue_memory:
1129 value->kind = axs_rvalue;
1130 value->type = lookup_pointer_type (value->type);
1136 /* A lot of this stuff will have to change to support C++. But we're
1137 not going to deal with that at the moment. */
1139 /* Find the field in the structure type TYPE named NAME, and return
1140 its index in TYPE's field array. */
1142 find_field (struct type *type, char *name)
1146 CHECK_TYPEDEF (type);
1148 /* Make sure this isn't C++. */
1149 if (TYPE_N_BASECLASSES (type) != 0)
1150 internal_error (__FILE__, __LINE__,
1151 "find_field: derived classes supported");
1153 for (i = 0; i < TYPE_NFIELDS (type); i++)
1155 char *this_name = TYPE_FIELD_NAME (type, i);
1157 if (this_name && STREQ (name, this_name))
1160 if (this_name[0] == '\0')
1161 internal_error (__FILE__, __LINE__,
1162 "find_field: anonymous unions not supported");
1165 error ("Couldn't find member named `%s' in struct/union `%s'",
1166 name, type->tag_name);
1172 /* Generate code to push the value of a bitfield of a structure whose
1173 address is on the top of the stack. START and END give the
1174 starting and one-past-ending *bit* numbers of the field within the
1177 gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value,
1178 struct type *type, int start, int end)
1180 /* Note that ops[i] fetches 8 << i bits. */
1181 static enum agent_op ops[]
1183 {aop_ref8, aop_ref16, aop_ref32, aop_ref64};
1184 static int num_ops = (sizeof (ops) / sizeof (ops[0]));
1186 /* We don't want to touch any byte that the bitfield doesn't
1187 actually occupy; we shouldn't make any accesses we're not
1188 explicitly permitted to. We rely here on the fact that the
1189 bytecode `ref' operators work on unaligned addresses.
1191 It takes some fancy footwork to get the stack to work the way
1192 we'd like. Say we're retrieving a bitfield that requires three
1193 fetches. Initially, the stack just contains the address:
1195 For the first fetch, we duplicate the address
1197 then add the byte offset, do the fetch, and shift and mask as
1198 needed, yielding a fragment of the value, properly aligned for
1199 the final bitwise or:
1201 then we swap, and repeat the process:
1202 frag1 addr --- address on top
1203 frag1 addr addr --- duplicate it
1204 frag1 addr frag2 --- get second fragment
1205 frag1 frag2 addr --- swap again
1206 frag1 frag2 frag3 --- get third fragment
1207 Notice that, since the third fragment is the last one, we don't
1208 bother duplicating the address this time. Now we have all the
1209 fragments on the stack, and we can simply `or' them together,
1210 yielding the final value of the bitfield. */
1212 /* The first and one-after-last bits in the field, but rounded down
1213 and up to byte boundaries. */
1214 int bound_start = (start / TARGET_CHAR_BIT) * TARGET_CHAR_BIT;
1215 int bound_end = (((end + TARGET_CHAR_BIT - 1)
1219 /* current bit offset within the structure */
1222 /* The index in ops of the opcode we're considering. */
1225 /* The number of fragments we generated in the process. Probably
1226 equal to the number of `one' bits in bytesize, but who cares? */
1229 /* Dereference any typedefs. */
1230 type = check_typedef (type);
1232 /* Can we fetch the number of bits requested at all? */
1233 if ((end - start) > ((1 << num_ops) * 8))
1234 internal_error (__FILE__, __LINE__,
1235 "gen_bitfield_ref: bitfield too wide");
1237 /* Note that we know here that we only need to try each opcode once.
1238 That may not be true on machines with weird byte sizes. */
1239 offset = bound_start;
1241 for (op = num_ops - 1; op >= 0; op--)
1243 /* number of bits that ops[op] would fetch */
1244 int op_size = 8 << op;
1246 /* The stack at this point, from bottom to top, contains zero or
1247 more fragments, then the address. */
1249 /* Does this fetch fit within the bitfield? */
1250 if (offset + op_size <= bound_end)
1252 /* Is this the last fragment? */
1253 int last_frag = (offset + op_size == bound_end);
1256 ax_simple (ax, aop_dup); /* keep a copy of the address */
1258 /* Add the offset. */
1259 gen_offset (ax, offset / TARGET_CHAR_BIT);
1263 /* Record the area of memory we're about to fetch. */
1264 ax_trace_quick (ax, op_size / TARGET_CHAR_BIT);
1267 /* Perform the fetch. */
1268 ax_simple (ax, ops[op]);
1270 /* Shift the bits we have to their proper position.
1271 gen_left_shift will generate right shifts when the operand
1274 A big-endian field diagram to ponder:
1275 byte 0 byte 1 byte 2 byte 3 byte 4 byte 5 byte 6 byte 7
1276 +------++------++------++------++------++------++------++------+
1277 xxxxAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCxxxxxxxxxxx
1279 bit number 16 32 48 53
1280 These are bit numbers as supplied by GDB. Note that the
1281 bit numbers run from right to left once you've fetched the
1284 A little-endian field diagram to ponder:
1285 byte 7 byte 6 byte 5 byte 4 byte 3 byte 2 byte 1 byte 0
1286 +------++------++------++------++------++------++------++------+
1287 xxxxxxxxxxxAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCxxxx
1289 bit number 48 32 16 4 0
1291 In both cases, the most significant end is on the left
1292 (i.e. normal numeric writing order), which means that you
1293 don't go crazy thinking about `left' and `right' shifts.
1295 We don't have to worry about masking yet:
1296 - If they contain garbage off the least significant end, then we
1297 must be looking at the low end of the field, and the right
1298 shift will wipe them out.
1299 - If they contain garbage off the most significant end, then we
1300 must be looking at the most significant end of the word, and
1301 the sign/zero extension will wipe them out.
1302 - If we're in the interior of the word, then there is no garbage
1303 on either end, because the ref operators zero-extend. */
1304 if (TARGET_BYTE_ORDER == BIG_ENDIAN)
1305 gen_left_shift (ax, end - (offset + op_size));
1307 gen_left_shift (ax, offset - start);
1310 /* Bring the copy of the address up to the top. */
1311 ax_simple (ax, aop_swap);
1318 /* Generate enough bitwise `or' operations to combine all the
1319 fragments we left on the stack. */
1320 while (fragment_count-- > 1)
1321 ax_simple (ax, aop_bit_or);
1323 /* Sign- or zero-extend the value as appropriate. */
1324 ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, end - start));
1326 /* This is *not* an lvalue. Ugh. */
1327 value->kind = axs_rvalue;
1332 /* Generate code to reference the member named FIELD of a structure or
1333 union. The top of the stack, as described by VALUE, should have
1334 type (pointer to a)* struct/union. OPERATOR_NAME is the name of
1335 the operator being compiled, and OPERAND_NAME is the kind of thing
1336 it operates on; we use them in error messages. */
1338 gen_struct_ref (struct agent_expr *ax, struct axs_value *value, char *field,
1339 char *operator_name, char *operand_name)
1344 /* Follow pointers until we reach a non-pointer. These aren't the C
1345 semantics, but they're what the normal GDB evaluator does, so we
1346 should at least be consistent. */
1347 while (value->type->code == TYPE_CODE_PTR)
1349 gen_usual_unary (ax, value);
1350 gen_deref (ax, value);
1352 type = check_typedef (value->type);
1354 /* This must yield a structure or a union. */
1355 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1356 && TYPE_CODE (type) != TYPE_CODE_UNION)
1357 error ("The left operand of `%s' is not a %s.",
1358 operator_name, operand_name);
1360 /* And it must be in memory; we don't deal with structure rvalues,
1361 or structures living in registers. */
1362 if (value->kind != axs_lvalue_memory)
1363 error ("Structure does not live in memory.");
1365 i = find_field (type, field);
1367 /* Is this a bitfield? */
1368 if (TYPE_FIELD_PACKED (type, i))
1369 gen_bitfield_ref (ax, value, TYPE_FIELD_TYPE (type, i),
1370 TYPE_FIELD_BITPOS (type, i),
1371 (TYPE_FIELD_BITPOS (type, i)
1372 + TYPE_FIELD_BITSIZE (type, i)));
1375 gen_offset (ax, TYPE_FIELD_BITPOS (type, i) / TARGET_CHAR_BIT);
1376 value->kind = axs_lvalue_memory;
1377 value->type = TYPE_FIELD_TYPE (type, i);
1382 /* Generate code for GDB's magical `repeat' operator.
1383 LVALUE @ INT creates an array INT elements long, and whose elements
1384 have the same type as LVALUE, located in memory so that LVALUE is
1385 its first element. For example, argv[0]@argc gives you the array
1386 of command-line arguments.
1388 Unfortunately, because we have to know the types before we actually
1389 have a value for the expression, we can't implement this perfectly
1390 without changing the type system, having values that occupy two
1391 stack slots, doing weird things with sizeof, etc. So we require
1392 the right operand to be a constant expression. */
1394 gen_repeat (union exp_element **pc, struct agent_expr *ax,
1395 struct axs_value *value)
1397 struct axs_value value1;
1398 /* We don't want to turn this into an rvalue, so no conversions
1400 gen_expr (pc, ax, &value1);
1401 if (value1.kind != axs_lvalue_memory)
1402 error ("Left operand of `@' must be an object in memory.");
1404 /* Evaluate the length; it had better be a constant. */
1406 struct value *v = const_expr (pc);
1410 error ("Right operand of `@' must be a constant, in agent expressions.");
1411 if (v->type->code != TYPE_CODE_INT)
1412 error ("Right operand of `@' must be an integer.");
1413 length = value_as_long (v);
1415 error ("Right operand of `@' must be positive.");
1417 /* The top of the stack is already the address of the object, so
1418 all we need to do is frob the type of the lvalue. */
1420 /* FIXME-type-allocation: need a way to free this type when we are
1423 = create_range_type (0, builtin_type_int, 0, length - 1);
1424 struct type *array = create_array_type (0, value1.type, range);
1426 value->kind = axs_lvalue_memory;
1427 value->type = array;
1433 /* Emit code for the `sizeof' operator.
1434 *PC should point at the start of the operand expression; we advance it
1435 to the first instruction after the operand. */
1437 gen_sizeof (union exp_element **pc, struct agent_expr *ax,
1438 struct axs_value *value)
1440 /* We don't care about the value of the operand expression; we only
1441 care about its type. However, in the current arrangement, the
1442 only way to find an expression's type is to generate code for it.
1443 So we generate code for the operand, and then throw it away,
1444 replacing it with code that simply pushes its size. */
1445 int start = ax->len;
1446 gen_expr (pc, ax, value);
1448 /* Throw away the code we just generated. */
1451 ax_const_l (ax, TYPE_LENGTH (value->type));
1452 value->kind = axs_rvalue;
1453 value->type = builtin_type_int;
1457 /* Generating bytecode from GDB expressions: general recursive thingy */
1459 /* A gen_expr function written by a Gen-X'er guy.
1460 Append code for the subexpression of EXPR starting at *POS_P to AX. */
1462 gen_expr (union exp_element **pc, struct agent_expr *ax,
1463 struct axs_value *value)
1465 /* Used to hold the descriptions of operand expressions. */
1466 struct axs_value value1, value2;
1467 enum exp_opcode op = (*pc)[0].opcode;
1469 /* If we're looking at a constant expression, just push its value. */
1471 struct value *v = maybe_const_expr (pc);
1475 ax_const_l (ax, value_as_long (v));
1476 value->kind = axs_rvalue;
1477 value->type = check_typedef (VALUE_TYPE (v));
1482 /* Otherwise, go ahead and generate code for it. */
1485 /* Binary arithmetic operators. */
1491 case BINOP_SUBSCRIPT:
1492 case BINOP_BITWISE_AND:
1493 case BINOP_BITWISE_IOR:
1494 case BINOP_BITWISE_XOR:
1496 gen_expr (pc, ax, &value1);
1497 gen_usual_unary (ax, &value1);
1498 gen_expr (pc, ax, &value2);
1499 gen_usual_unary (ax, &value2);
1500 gen_usual_arithmetic (ax, &value1, &value2);
1504 gen_add (ax, value, &value1, &value2, "addition");
1507 gen_sub (ax, value, &value1, &value2);
1510 gen_binop (ax, value, &value1, &value2,
1511 aop_mul, aop_mul, 1, "multiplication");
1514 gen_binop (ax, value, &value1, &value2,
1515 aop_div_signed, aop_div_unsigned, 1, "division");
1518 gen_binop (ax, value, &value1, &value2,
1519 aop_rem_signed, aop_rem_unsigned, 1, "remainder");
1521 case BINOP_SUBSCRIPT:
1522 gen_add (ax, value, &value1, &value2, "array subscripting");
1523 if (TYPE_CODE (value->type) != TYPE_CODE_PTR)
1524 error ("Illegal combination of types in array subscripting.");
1525 gen_deref (ax, value);
1527 case BINOP_BITWISE_AND:
1528 gen_binop (ax, value, &value1, &value2,
1529 aop_bit_and, aop_bit_and, 0, "bitwise and");
1532 case BINOP_BITWISE_IOR:
1533 gen_binop (ax, value, &value1, &value2,
1534 aop_bit_or, aop_bit_or, 0, "bitwise or");
1537 case BINOP_BITWISE_XOR:
1538 gen_binop (ax, value, &value1, &value2,
1539 aop_bit_xor, aop_bit_xor, 0, "bitwise exclusive-or");
1543 /* We should only list operators in the outer case statement
1544 that we actually handle in the inner case statement. */
1545 internal_error (__FILE__, __LINE__,
1546 "gen_expr: op case sets don't match");
1550 /* Note that we need to be a little subtle about generating code
1551 for comma. In C, we can do some optimizations here because
1552 we know the left operand is only being evaluated for effect.
1553 However, if the tracing kludge is in effect, then we always
1554 need to evaluate the left hand side fully, so that all the
1555 variables it mentions get traced. */
1558 gen_expr (pc, ax, &value1);
1559 /* Don't just dispose of the left operand. We might be tracing,
1560 in which case we want to emit code to trace it if it's an
1562 gen_traced_pop (ax, &value1);
1563 gen_expr (pc, ax, value);
1564 /* It's the consumer's responsibility to trace the right operand. */
1567 case OP_LONG: /* some integer constant */
1569 struct type *type = (*pc)[1].type;
1570 LONGEST k = (*pc)[2].longconst;
1572 gen_int_literal (ax, value, k, type);
1577 gen_var_ref (ax, value, (*pc)[2].symbol);
1583 int reg = (int) (*pc)[1].longconst;
1585 value->kind = axs_lvalue_register;
1587 value->type = REGISTER_VIRTUAL_TYPE (reg);
1591 case OP_INTERNALVAR:
1592 error ("GDB agent expressions cannot use convenience variables.");
1594 /* Weirdo operator: see comments for gen_repeat for details. */
1596 /* Note that gen_repeat handles its own argument evaluation. */
1598 gen_repeat (pc, ax, value);
1603 struct type *type = (*pc)[1].type;
1605 gen_expr (pc, ax, value);
1606 gen_cast (ax, value, type);
1612 struct type *type = check_typedef ((*pc)[1].type);
1614 gen_expr (pc, ax, value);
1615 /* I'm not sure I understand UNOP_MEMVAL entirely. I think
1616 it's just a hack for dealing with minsyms; you take some
1617 integer constant, pretend it's the address of an lvalue of
1618 the given type, and dereference it. */
1619 if (value->kind != axs_rvalue)
1620 /* This would be weird. */
1621 internal_error (__FILE__, __LINE__,
1622 "gen_expr: OP_MEMVAL operand isn't an rvalue???");
1624 value->kind = axs_lvalue_memory;
1630 /* -FOO is equivalent to 0 - FOO. */
1631 gen_int_literal (ax, &value1, (LONGEST) 0, builtin_type_int);
1632 gen_usual_unary (ax, &value1); /* shouldn't do much */
1633 gen_expr (pc, ax, &value2);
1634 gen_usual_unary (ax, &value2);
1635 gen_usual_arithmetic (ax, &value1, &value2);
1636 gen_sub (ax, value, &value1, &value2);
1639 case UNOP_LOGICAL_NOT:
1641 gen_expr (pc, ax, value);
1642 gen_logical_not (ax, value);
1645 case UNOP_COMPLEMENT:
1647 gen_expr (pc, ax, value);
1648 gen_complement (ax, value);
1653 gen_expr (pc, ax, value);
1654 gen_usual_unary (ax, value);
1655 if (TYPE_CODE (value->type) != TYPE_CODE_PTR)
1656 error ("Argument of unary `*' is not a pointer.");
1657 gen_deref (ax, value);
1662 gen_expr (pc, ax, value);
1663 gen_address_of (ax, value);
1668 /* Notice that gen_sizeof handles its own operand, unlike most
1669 of the other unary operator functions. This is because we
1670 have to throw away the code we generate. */
1671 gen_sizeof (pc, ax, value);
1674 case STRUCTOP_STRUCT:
1677 int length = (*pc)[1].longconst;
1678 char *name = &(*pc)[2].string;
1680 (*pc) += 4 + BYTES_TO_EXP_ELEM (length + 1);
1681 gen_expr (pc, ax, value);
1682 if (op == STRUCTOP_STRUCT)
1683 gen_struct_ref (ax, value, name, ".", "structure or union");
1684 else if (op == STRUCTOP_PTR)
1685 gen_struct_ref (ax, value, name, "->",
1686 "pointer to a structure or union");
1688 /* If this `if' chain doesn't handle it, then the case list
1689 shouldn't mention it, and we shouldn't be here. */
1690 internal_error (__FILE__, __LINE__,
1691 "gen_expr: unhandled struct case");
1696 error ("Attempt to use a type name as an expression.");
1699 error ("Unsupported operator in expression.");
1705 /* Generating bytecode from GDB expressions: driver */
1707 /* Given a GDB expression EXPR, produce a string of agent bytecode
1708 which computes its value. Return the agent expression, and set
1709 *VALUE to describe its type, and whether it's an lvalue or rvalue. */
1711 expr_to_agent (struct expression *expr, struct axs_value *value)
1713 struct cleanup *old_chain = 0;
1714 struct agent_expr *ax = new_agent_expr (0);
1715 union exp_element *pc;
1717 old_chain = make_cleanup_free_agent_expr (ax);
1721 gen_expr (&pc, ax, value);
1723 /* We have successfully built the agent expr, so cancel the cleanup
1724 request. If we add more cleanups that we always want done, this
1725 will have to get more complicated. */
1726 discard_cleanups (old_chain);
1731 #if 0 /* not used */
1732 /* Given a GDB expression EXPR denoting an lvalue in memory, produce a
1733 string of agent bytecode which will leave its address and size on
1734 the top of stack. Return the agent expression.
1736 Not sure this function is useful at all. */
1738 expr_to_address_and_size (struct expression *expr)
1740 struct axs_value value;
1741 struct agent_expr *ax = expr_to_agent (expr, &value);
1743 /* Complain if the result is not a memory lvalue. */
1744 if (value.kind != axs_lvalue_memory)
1746 free_agent_expr (ax);
1747 error ("Expression does not denote an object in memory.");
1750 /* Push the object's size on the stack. */
1751 ax_const_l (ax, TYPE_LENGTH (value.type));
1757 /* Given a GDB expression EXPR, return bytecode to trace its value.
1758 The result will use the `trace' and `trace_quick' bytecodes to
1759 record the value of all memory touched by the expression. The
1760 caller can then use the ax_reqs function to discover which
1761 registers it relies upon. */
1763 gen_trace_for_expr (CORE_ADDR scope, struct expression *expr)
1765 struct cleanup *old_chain = 0;
1766 struct agent_expr *ax = new_agent_expr (scope);
1767 union exp_element *pc;
1768 struct axs_value value;
1770 old_chain = make_cleanup_free_agent_expr (ax);
1774 gen_expr (&pc, ax, &value);
1776 /* Make sure we record the final object, and get rid of it. */
1777 gen_traced_pop (ax, &value);
1779 /* Oh, and terminate. */
1780 ax_simple (ax, aop_end);
1782 /* We have successfully built the agent expr, so cancel the cleanup
1783 request. If we add more cleanups that we always want done, this
1784 will have to get more complicated. */
1785 discard_cleanups (old_chain);
1791 /* The "agent" command, for testing: compile and disassemble an expression. */
1794 print_axs_value (struct ui_file *f, struct axs_value *value)
1796 switch (value->kind)
1799 fputs_filtered ("rvalue", f);
1802 case axs_lvalue_memory:
1803 fputs_filtered ("memory lvalue", f);
1806 case axs_lvalue_register:
1807 fprintf_filtered (f, "register %d lvalue", value->u.reg);
1811 fputs_filtered (" : ", f);
1812 type_print (value->type, "", f, -1);
1817 agent_command (char *exp, int from_tty)
1819 struct cleanup *old_chain = 0;
1820 struct expression *expr;
1821 struct agent_expr *agent;
1822 struct frame_info *fi = get_current_frame (); /* need current scope */
1824 /* We don't deal with overlay debugging at the moment. We need to
1825 think more carefully about this. If you copy this code into
1826 another command, change the error message; the user shouldn't
1827 have to know anything about agent expressions. */
1828 if (overlay_debugging)
1829 error ("GDB can't do agent expression translation with overlays.");
1832 error_no_arg ("expression to translate");
1834 expr = parse_expression (exp);
1835 old_chain = make_cleanup (free_current_contents, &expr);
1836 agent = gen_trace_for_expr (fi->pc, expr);
1837 make_cleanup_free_agent_expr (agent);
1838 ax_print (gdb_stdout, agent);
1840 /* It would be nice to call ax_reqs here to gather some general info
1841 about the expression, and then print out the result. */
1843 do_cleanups (old_chain);
1848 /* Initialization code. */
1850 void _initialize_ax_gdb (void);
1852 _initialize_ax_gdb (void)
1854 add_cmd ("agent", class_maintenance, agent_command,
1855 "Translate an expression into remote agent bytecode.",