1 /* GDB-specific functions for operating on agent expressions.
3 Copyright (C) 1998, 1999, 2000, 2001, 2003, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
33 #include "gdb_string.h"
36 #include "user-regs.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 gdbarch
*, struct agent_expr
*);
77 static void gen_frame_locals_address (struct gdbarch
*, 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 gdbarch
*, 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 expression
*exp
, struct agent_expr
*ax
,
91 struct axs_value
*value
);
92 static int type_wider_than (struct type
*type1
, struct type
*type2
);
93 static struct type
*max_type (struct type
*type1
, struct type
*type2
);
94 static void gen_conversion (struct agent_expr
*ax
,
95 struct type
*from
, struct type
*to
);
96 static int is_nontrivial_conversion (struct type
*from
, struct type
*to
);
97 static void gen_usual_arithmetic (struct expression
*exp
,
98 struct agent_expr
*ax
,
99 struct axs_value
*value1
,
100 struct axs_value
*value2
);
101 static void gen_integral_promotions (struct expression
*exp
,
102 struct agent_expr
*ax
,
103 struct axs_value
*value
);
104 static void gen_cast (struct agent_expr
*ax
,
105 struct axs_value
*value
, struct type
*type
);
106 static void gen_scale (struct agent_expr
*ax
,
107 enum agent_op op
, struct type
*type
);
108 static void gen_ptradd (struct agent_expr
*ax
, struct axs_value
*value
,
109 struct axs_value
*value1
, struct axs_value
*value2
);
110 static void gen_ptrsub (struct agent_expr
*ax
, struct axs_value
*value
,
111 struct axs_value
*value1
, struct axs_value
*value2
);
112 static void gen_ptrdiff (struct agent_expr
*ax
, struct axs_value
*value
,
113 struct axs_value
*value1
, struct axs_value
*value2
,
114 struct type
*result_type
);
115 static void gen_binop (struct agent_expr
*ax
,
116 struct axs_value
*value
,
117 struct axs_value
*value1
,
118 struct axs_value
*value2
,
120 enum agent_op op_unsigned
, int may_carry
, char *name
);
121 static void gen_logical_not (struct agent_expr
*ax
, struct axs_value
*value
,
122 struct type
*result_type
);
123 static void gen_complement (struct agent_expr
*ax
, struct axs_value
*value
);
124 static void gen_deref (struct agent_expr
*, struct axs_value
*);
125 static void gen_address_of (struct agent_expr
*, struct axs_value
*);
126 static int find_field (struct type
*type
, char *name
);
127 static void gen_bitfield_ref (struct expression
*exp
, struct agent_expr
*ax
,
128 struct axs_value
*value
,
129 struct type
*type
, int start
, int end
);
130 static void gen_struct_ref (struct expression
*exp
, struct agent_expr
*ax
,
131 struct axs_value
*value
,
133 char *operator_name
, char *operand_name
);
134 static void gen_repeat (struct expression
*exp
, union exp_element
**pc
,
135 struct agent_expr
*ax
, struct axs_value
*value
);
136 static void gen_sizeof (struct expression
*exp
, union exp_element
**pc
,
137 struct agent_expr
*ax
, struct axs_value
*value
,
138 struct type
*size_type
);
139 static void gen_expr (struct expression
*exp
, union exp_element
**pc
,
140 struct agent_expr
*ax
, struct axs_value
*value
);
142 static void agent_command (char *exp
, int from_tty
);
145 /* Detecting constant expressions. */
147 /* If the variable reference at *PC is a constant, return its value.
148 Otherwise, return zero.
150 Hey, Wally! How can a variable reference be a constant?
152 Well, Beav, this function really handles the OP_VAR_VALUE operator,
153 not specifically variable references. GDB uses OP_VAR_VALUE to
154 refer to any kind of symbolic reference: function names, enum
155 elements, and goto labels are all handled through the OP_VAR_VALUE
156 operator, even though they're constants. It makes sense given the
159 Gee, Wally, don'cha wonder sometimes if data representations that
160 subvert commonly accepted definitions of terms in favor of heavily
161 context-specific interpretations are really just a tool of the
162 programming hegemony to preserve their power and exclude the
165 static struct value
*
166 const_var_ref (struct symbol
*var
)
168 struct type
*type
= SYMBOL_TYPE (var
);
170 switch (SYMBOL_CLASS (var
))
173 return value_from_longest (type
, (LONGEST
) SYMBOL_VALUE (var
));
176 return value_from_pointer (type
, (CORE_ADDR
) SYMBOL_VALUE_ADDRESS (var
));
184 /* If the expression starting at *PC has a constant value, return it.
185 Otherwise, return zero. If we return a value, then *PC will be
186 advanced to the end of it. If we return zero, *PC could be
188 static struct value
*
189 const_expr (union exp_element
**pc
)
191 enum exp_opcode op
= (*pc
)->opcode
;
198 struct type
*type
= (*pc
)[1].type
;
199 LONGEST k
= (*pc
)[2].longconst
;
201 return value_from_longest (type
, k
);
206 struct value
*v
= const_var_ref ((*pc
)[2].symbol
);
211 /* We could add more operators in here. */
215 v1
= const_expr (pc
);
217 return value_neg (v1
);
227 /* Like const_expr, but guarantee also that *PC is undisturbed if the
228 expression is not constant. */
229 static struct value
*
230 maybe_const_expr (union exp_element
**pc
)
232 union exp_element
*tentative_pc
= *pc
;
233 struct value
*v
= const_expr (&tentative_pc
);
235 /* If we got a value, then update the real PC. */
243 /* Generating bytecode from GDB expressions: general assumptions */
245 /* Here are a few general assumptions made throughout the code; if you
246 want to make a change that contradicts one of these, then you'd
247 better scan things pretty thoroughly.
249 - We assume that all values occupy one stack element. For example,
250 sometimes we'll swap to get at the left argument to a binary
251 operator. If we decide that void values should occupy no stack
252 elements, or that synthetic arrays (whose size is determined at
253 run time, created by the `@' operator) should occupy two stack
254 elements (address and length), then this will cause trouble.
256 - We assume the stack elements are infinitely wide, and that we
257 don't have to worry what happens if the user requests an
258 operation that is wider than the actual interpreter's stack.
259 That is, it's up to the interpreter to handle directly all the
260 integer widths the user has access to. (Woe betide the language
263 - We don't support side effects. Thus, we don't have to worry about
264 GCC's generalized lvalues, function calls, etc.
266 - We don't support floating point. Many places where we switch on
267 some type don't bother to include cases for floating point; there
268 may be even more subtle ways this assumption exists. For
269 example, the arguments to % must be integers.
271 - We assume all subexpressions have a static, unchanging type. If
272 we tried to support convenience variables, this would be a
275 - All values on the stack should always be fully zero- or
278 (I wasn't sure whether to choose this or its opposite --- that
279 only addresses are assumed extended --- but it turns out that
280 neither convention completely eliminates spurious extend
281 operations (if everything is always extended, then you have to
282 extend after add, because it could overflow; if nothing is
283 extended, then you end up producing extends whenever you change
284 sizes), and this is simpler.) */
287 /* Generating bytecode from GDB expressions: the `trace' kludge */
289 /* The compiler in this file is a general-purpose mechanism for
290 translating GDB expressions into bytecode. One ought to be able to
291 find a million and one uses for it.
293 However, at the moment it is HOPELESSLY BRAIN-DAMAGED for the sake
294 of expediency. Let he who is without sin cast the first stone.
296 For the data tracing facility, we need to insert `trace' bytecodes
297 before each data fetch; this records all the memory that the
298 expression touches in the course of evaluation, so that memory will
299 be available when the user later tries to evaluate the expression
302 This should be done (I think) in a post-processing pass, that walks
303 an arbitrary agent expression and inserts `trace' operations at the
304 appropriate points. But it's much faster to just hack them
305 directly into the code. And since we're in a crunch, that's what
308 Setting the flag trace_kludge to non-zero enables the code that
309 emits the trace bytecodes at the appropriate points. */
310 static int trace_kludge
;
312 /* Trace the lvalue on the stack, if it needs it. In either case, pop
313 the value. Useful on the left side of a comma, and at the end of
314 an expression being used for tracing. */
316 gen_traced_pop (struct agent_expr
*ax
, struct axs_value
*value
)
322 /* We don't trace rvalues, just the lvalues necessary to
323 produce them. So just dispose of this value. */
324 ax_simple (ax
, aop_pop
);
327 case axs_lvalue_memory
:
329 int length
= TYPE_LENGTH (check_typedef (value
->type
));
331 /* There's no point in trying to use a trace_quick bytecode
332 here, since "trace_quick SIZE pop" is three bytes, whereas
333 "const8 SIZE trace" is also three bytes, does the same
334 thing, and the simplest code which generates that will also
335 work correctly for objects with large sizes. */
336 ax_const_l (ax
, length
);
337 ax_simple (ax
, aop_trace
);
341 case axs_lvalue_register
:
342 /* We need to mention the register somewhere in the bytecode,
343 so ax_reqs will pick it up and add it to the mask of
345 ax_reg (ax
, value
->u
.reg
);
346 ax_simple (ax
, aop_pop
);
350 /* If we're not tracing, just pop the value. */
351 ax_simple (ax
, aop_pop
);
356 /* Generating bytecode from GDB expressions: helper functions */
358 /* Assume that the lower bits of the top of the stack is a value of
359 type TYPE, and the upper bits are zero. Sign-extend if necessary. */
361 gen_sign_extend (struct agent_expr
*ax
, struct type
*type
)
363 /* Do we need to sign-extend this? */
364 if (!TYPE_UNSIGNED (type
))
365 ax_ext (ax
, TYPE_LENGTH (type
) * TARGET_CHAR_BIT
);
369 /* Assume the lower bits of the top of the stack hold a value of type
370 TYPE, and the upper bits are garbage. Sign-extend or truncate as
373 gen_extend (struct agent_expr
*ax
, struct type
*type
)
375 int bits
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
377 ((TYPE_UNSIGNED (type
) ? ax_zero_ext
: ax_ext
) (ax
, bits
));
381 /* Assume that the top of the stack contains a value of type "pointer
382 to TYPE"; generate code to fetch its value. Note that TYPE is the
383 target type, not the pointer type. */
385 gen_fetch (struct agent_expr
*ax
, struct type
*type
)
389 /* Record the area of memory we're about to fetch. */
390 ax_trace_quick (ax
, TYPE_LENGTH (type
));
393 switch (TYPE_CODE (type
))
399 /* It's a scalar value, so we know how to dereference it. How
400 many bytes long is it? */
401 switch (TYPE_LENGTH (type
))
403 case 8 / TARGET_CHAR_BIT
:
404 ax_simple (ax
, aop_ref8
);
406 case 16 / TARGET_CHAR_BIT
:
407 ax_simple (ax
, aop_ref16
);
409 case 32 / TARGET_CHAR_BIT
:
410 ax_simple (ax
, aop_ref32
);
412 case 64 / TARGET_CHAR_BIT
:
413 ax_simple (ax
, aop_ref64
);
416 /* Either our caller shouldn't have asked us to dereference
417 that pointer (other code's fault), or we're not
418 implementing something we should be (this code's fault).
419 In any case, it's a bug the user shouldn't see. */
421 internal_error (__FILE__
, __LINE__
,
422 _("gen_fetch: strange size"));
425 gen_sign_extend (ax
, type
);
429 /* Either our caller shouldn't have asked us to dereference that
430 pointer (other code's fault), or we're not implementing
431 something we should be (this code's fault). In any case,
432 it's a bug the user shouldn't see. */
433 internal_error (__FILE__
, __LINE__
,
434 _("gen_fetch: bad type code"));
439 /* Generate code to left shift the top of the stack by DISTANCE bits, or
440 right shift it by -DISTANCE bits if DISTANCE < 0. This generates
441 unsigned (logical) right shifts. */
443 gen_left_shift (struct agent_expr
*ax
, int distance
)
447 ax_const_l (ax
, distance
);
448 ax_simple (ax
, aop_lsh
);
450 else if (distance
< 0)
452 ax_const_l (ax
, -distance
);
453 ax_simple (ax
, aop_rsh_unsigned
);
459 /* Generating bytecode from GDB expressions: symbol references */
461 /* Generate code to push the base address of the argument portion of
462 the top stack frame. */
464 gen_frame_args_address (struct gdbarch
*gdbarch
, struct agent_expr
*ax
)
467 LONGEST frame_offset
;
469 gdbarch_virtual_frame_pointer (gdbarch
,
470 ax
->scope
, &frame_reg
, &frame_offset
);
471 ax_reg (ax
, frame_reg
);
472 gen_offset (ax
, frame_offset
);
476 /* Generate code to push the base address of the locals portion of the
479 gen_frame_locals_address (struct gdbarch
*gdbarch
, struct agent_expr
*ax
)
482 LONGEST frame_offset
;
484 gdbarch_virtual_frame_pointer (gdbarch
,
485 ax
->scope
, &frame_reg
, &frame_offset
);
486 ax_reg (ax
, frame_reg
);
487 gen_offset (ax
, frame_offset
);
491 /* Generate code to add OFFSET to the top of the stack. Try to
492 generate short and readable code. We use this for getting to
493 variables on the stack, and structure members. If we were
494 programming in ML, it would be clearer why these are the same
497 gen_offset (struct agent_expr
*ax
, int offset
)
499 /* It would suffice to simply push the offset and add it, but this
500 makes it easier to read positive and negative offsets in the
504 ax_const_l (ax
, offset
);
505 ax_simple (ax
, aop_add
);
509 ax_const_l (ax
, -offset
);
510 ax_simple (ax
, aop_sub
);
515 /* In many cases, a symbol's value is the offset from some other
516 address (stack frame, base register, etc.) Generate code to add
517 VAR's value to the top of the stack. */
519 gen_sym_offset (struct agent_expr
*ax
, struct symbol
*var
)
521 gen_offset (ax
, SYMBOL_VALUE (var
));
525 /* Generate code for a variable reference to AX. The variable is the
526 symbol VAR. Set VALUE to describe the result. */
529 gen_var_ref (struct gdbarch
*gdbarch
, struct agent_expr
*ax
,
530 struct axs_value
*value
, struct symbol
*var
)
532 /* Dereference any typedefs. */
533 value
->type
= check_typedef (SYMBOL_TYPE (var
));
535 /* I'm imitating the code in read_var_value. */
536 switch (SYMBOL_CLASS (var
))
538 case LOC_CONST
: /* A constant, like an enum value. */
539 ax_const_l (ax
, (LONGEST
) SYMBOL_VALUE (var
));
540 value
->kind
= axs_rvalue
;
543 case LOC_LABEL
: /* A goto label, being used as a value. */
544 ax_const_l (ax
, (LONGEST
) SYMBOL_VALUE_ADDRESS (var
));
545 value
->kind
= axs_rvalue
;
548 case LOC_CONST_BYTES
:
549 internal_error (__FILE__
, __LINE__
,
550 _("gen_var_ref: LOC_CONST_BYTES symbols are not supported"));
552 /* Variable at a fixed location in memory. Easy. */
554 /* Push the address of the variable. */
555 ax_const_l (ax
, SYMBOL_VALUE_ADDRESS (var
));
556 value
->kind
= axs_lvalue_memory
;
559 case LOC_ARG
: /* var lives in argument area of frame */
560 gen_frame_args_address (gdbarch
, ax
);
561 gen_sym_offset (ax
, var
);
562 value
->kind
= axs_lvalue_memory
;
565 case LOC_REF_ARG
: /* As above, but the frame slot really
566 holds the address of the variable. */
567 gen_frame_args_address (gdbarch
, ax
);
568 gen_sym_offset (ax
, var
);
569 /* Don't assume any particular pointer size. */
570 gen_fetch (ax
, builtin_type (gdbarch
)->builtin_data_ptr
);
571 value
->kind
= axs_lvalue_memory
;
574 case LOC_LOCAL
: /* var lives in locals area of frame */
575 gen_frame_locals_address (gdbarch
, ax
);
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
;
591 /* Don't generate any code at all; in the process of treating
592 this as an lvalue or rvalue, the caller will generate the
594 value
->kind
= axs_lvalue_register
;
595 value
->u
.reg
= SYMBOL_REGISTER_OPS (var
)->register_number (var
, gdbarch
);
598 /* A lot like LOC_REF_ARG, but the pointer lives directly in a
599 register, not on the stack. Simpler than LOC_REGISTER
600 because it's just like any other case where the thing
601 has a real address. */
602 case LOC_REGPARM_ADDR
:
603 ax_reg (ax
, SYMBOL_REGISTER_OPS (var
)->register_number (var
, gdbarch
));
604 value
->kind
= axs_lvalue_memory
;
609 struct minimal_symbol
*msym
610 = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var
), NULL
, NULL
);
612 error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var
));
614 /* Push the address of the variable. */
615 ax_const_l (ax
, SYMBOL_VALUE_ADDRESS (msym
));
616 value
->kind
= axs_lvalue_memory
;
621 /* FIXME: cagney/2004-01-26: It should be possible to
622 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
623 Unfortunately DWARF 2 stores the frame-base (instead of the
624 function) location in a function's symbol. Oops! For the
625 moment enable this when/where applicable. */
626 SYMBOL_COMPUTED_OPS (var
)->tracepoint_var_ref (var
, gdbarch
, ax
, value
);
629 case LOC_OPTIMIZED_OUT
:
630 error (_("The variable `%s' has been optimized out."),
631 SYMBOL_PRINT_NAME (var
));
635 error (_("Cannot find value of botched symbol `%s'."),
636 SYMBOL_PRINT_NAME (var
));
643 /* Generating bytecode from GDB expressions: literals */
646 gen_int_literal (struct agent_expr
*ax
, struct axs_value
*value
, LONGEST k
,
650 value
->kind
= axs_rvalue
;
651 value
->type
= check_typedef (type
);
656 /* Generating bytecode from GDB expressions: unary conversions, casts */
658 /* Take what's on the top of the stack (as described by VALUE), and
659 try to make an rvalue out of it. Signal an error if we can't do
662 require_rvalue (struct agent_expr
*ax
, struct axs_value
*value
)
667 /* It's already an rvalue. */
670 case axs_lvalue_memory
:
671 /* The top of stack is the address of the object. Dereference. */
672 gen_fetch (ax
, value
->type
);
675 case axs_lvalue_register
:
676 /* There's nothing on the stack, but value->u.reg is the
677 register number containing the value.
679 When we add floating-point support, this is going to have to
680 change. What about SPARC register pairs, for example? */
681 ax_reg (ax
, value
->u
.reg
);
682 gen_extend (ax
, value
->type
);
686 value
->kind
= axs_rvalue
;
690 /* Assume the top of the stack is described by VALUE, and perform the
691 usual unary conversions. This is motivated by ANSI 6.2.2, but of
692 course GDB expressions are not ANSI; they're the mishmash union of
693 a bunch of languages. Rah.
695 NOTE! This function promises to produce an rvalue only when the
696 incoming value is of an appropriate type. In other words, the
697 consumer of the value this function produces may assume the value
698 is an rvalue only after checking its type.
700 The immediate issue is that if the user tries to use a structure or
701 union as an operand of, say, the `+' operator, we don't want to try
702 to convert that structure to an rvalue; require_rvalue will bomb on
703 structs and unions. Rather, we want to simply pass the struct
704 lvalue through unchanged, and let `+' raise an error. */
707 gen_usual_unary (struct expression
*exp
, struct agent_expr
*ax
,
708 struct axs_value
*value
)
710 /* We don't have to generate any code for the usual integral
711 conversions, since values are always represented as full-width on
712 the stack. Should we tweak the type? */
714 /* Some types require special handling. */
715 switch (TYPE_CODE (value
->type
))
717 /* Functions get converted to a pointer to the function. */
719 value
->type
= lookup_pointer_type (value
->type
);
720 value
->kind
= axs_rvalue
; /* Should always be true, but just in case. */
723 /* Arrays get converted to a pointer to their first element, and
724 are no longer an lvalue. */
725 case TYPE_CODE_ARRAY
:
727 struct type
*elements
= TYPE_TARGET_TYPE (value
->type
);
728 value
->type
= lookup_pointer_type (elements
);
729 value
->kind
= axs_rvalue
;
730 /* We don't need to generate any code; the address of the array
731 is also the address of its first element. */
735 /* Don't try to convert structures and unions to rvalues. Let the
736 consumer signal an error. */
737 case TYPE_CODE_STRUCT
:
738 case TYPE_CODE_UNION
:
741 /* If the value is an enum, call it an integer. */
743 value
->type
= builtin_type (exp
->gdbarch
)->builtin_int
;
747 /* If the value is an lvalue, dereference it. */
748 require_rvalue (ax
, value
);
752 /* Return non-zero iff the type TYPE1 is considered "wider" than the
753 type TYPE2, according to the rules described in gen_usual_arithmetic. */
755 type_wider_than (struct type
*type1
, struct type
*type2
)
757 return (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
)
758 || (TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
759 && TYPE_UNSIGNED (type1
)
760 && !TYPE_UNSIGNED (type2
)));
764 /* Return the "wider" of the two types TYPE1 and TYPE2. */
766 max_type (struct type
*type1
, struct type
*type2
)
768 return type_wider_than (type1
, type2
) ? type1
: type2
;
772 /* Generate code to convert a scalar value of type FROM to type TO. */
774 gen_conversion (struct agent_expr
*ax
, struct type
*from
, struct type
*to
)
776 /* Perhaps there is a more graceful way to state these rules. */
778 /* If we're converting to a narrower type, then we need to clear out
780 if (TYPE_LENGTH (to
) < TYPE_LENGTH (from
))
781 gen_extend (ax
, from
);
783 /* If the two values have equal width, but different signednesses,
784 then we need to extend. */
785 else if (TYPE_LENGTH (to
) == TYPE_LENGTH (from
))
787 if (TYPE_UNSIGNED (from
) != TYPE_UNSIGNED (to
))
791 /* If we're converting to a wider type, and becoming unsigned, then
792 we need to zero out any possible sign bits. */
793 else if (TYPE_LENGTH (to
) > TYPE_LENGTH (from
))
795 if (TYPE_UNSIGNED (to
))
801 /* Return non-zero iff the type FROM will require any bytecodes to be
802 emitted to be converted to the type TO. */
804 is_nontrivial_conversion (struct type
*from
, struct type
*to
)
806 struct agent_expr
*ax
= new_agent_expr (0);
809 /* Actually generate the code, and see if anything came out. At the
810 moment, it would be trivial to replicate the code in
811 gen_conversion here, but in the future, when we're supporting
812 floating point and the like, it may not be. Doing things this
813 way allows this function to be independent of the logic in
815 gen_conversion (ax
, from
, to
);
816 nontrivial
= ax
->len
> 0;
817 free_agent_expr (ax
);
822 /* Generate code to perform the "usual arithmetic conversions" (ANSI C
823 6.2.1.5) for the two operands of an arithmetic operator. This
824 effectively finds a "least upper bound" type for the two arguments,
825 and promotes each argument to that type. *VALUE1 and *VALUE2
826 describe the values as they are passed in, and as they are left. */
828 gen_usual_arithmetic (struct expression
*exp
, struct agent_expr
*ax
,
829 struct axs_value
*value1
, struct axs_value
*value2
)
831 /* Do the usual binary conversions. */
832 if (TYPE_CODE (value1
->type
) == TYPE_CODE_INT
833 && TYPE_CODE (value2
->type
) == TYPE_CODE_INT
)
835 /* The ANSI integral promotions seem to work this way: Order the
836 integer types by size, and then by signedness: an n-bit
837 unsigned type is considered "wider" than an n-bit signed
838 type. Promote to the "wider" of the two types, and always
839 promote at least to int. */
840 struct type
*target
= max_type (builtin_type (exp
->gdbarch
)->builtin_int
,
841 max_type (value1
->type
, value2
->type
));
843 /* Deal with value2, on the top of the stack. */
844 gen_conversion (ax
, value2
->type
, target
);
846 /* Deal with value1, not on the top of the stack. Don't
847 generate the `swap' instructions if we're not actually going
849 if (is_nontrivial_conversion (value1
->type
, target
))
851 ax_simple (ax
, aop_swap
);
852 gen_conversion (ax
, value1
->type
, target
);
853 ax_simple (ax
, aop_swap
);
856 value1
->type
= value2
->type
= check_typedef (target
);
861 /* Generate code to perform the integral promotions (ANSI 6.2.1.1) on
862 the value on the top of the stack, as described by VALUE. Assume
863 the value has integral type. */
865 gen_integral_promotions (struct expression
*exp
, struct agent_expr
*ax
,
866 struct axs_value
*value
)
868 const struct builtin_type
*builtin
= builtin_type (exp
->gdbarch
);
870 if (!type_wider_than (value
->type
, builtin
->builtin_int
))
872 gen_conversion (ax
, value
->type
, builtin
->builtin_int
);
873 value
->type
= builtin
->builtin_int
;
875 else if (!type_wider_than (value
->type
, builtin
->builtin_unsigned_int
))
877 gen_conversion (ax
, value
->type
, builtin
->builtin_unsigned_int
);
878 value
->type
= builtin
->builtin_unsigned_int
;
883 /* Generate code for a cast to TYPE. */
885 gen_cast (struct agent_expr
*ax
, struct axs_value
*value
, struct type
*type
)
887 /* GCC does allow casts to yield lvalues, so this should be fixed
888 before merging these changes into the trunk. */
889 require_rvalue (ax
, value
);
890 /* Dereference typedefs. */
891 type
= check_typedef (type
);
893 switch (TYPE_CODE (type
))
896 /* It's implementation-defined, and I'll bet this is what GCC
900 case TYPE_CODE_ARRAY
:
901 case TYPE_CODE_STRUCT
:
902 case TYPE_CODE_UNION
:
904 error (_("Invalid type cast: intended type must be scalar."));
907 /* We don't have to worry about the size of the value, because
908 all our integral values are fully sign-extended, and when
909 casting pointers we can do anything we like. Is there any
910 way for us to know what GCC actually does with a cast like
915 gen_conversion (ax
, value
->type
, type
);
919 /* We could pop the value, and rely on everyone else to check
920 the type and notice that this value doesn't occupy a stack
921 slot. But for now, leave the value on the stack, and
922 preserve the "value == stack element" assumption. */
926 error (_("Casts to requested type are not yet implemented."));
934 /* Generating bytecode from GDB expressions: arithmetic */
936 /* Scale the integer on the top of the stack by the size of the target
937 of the pointer type TYPE. */
939 gen_scale (struct agent_expr
*ax
, enum agent_op op
, struct type
*type
)
941 struct type
*element
= TYPE_TARGET_TYPE (type
);
943 if (TYPE_LENGTH (element
) != 1)
945 ax_const_l (ax
, TYPE_LENGTH (element
));
951 /* Generate code for pointer arithmetic PTR + INT. */
953 gen_ptradd (struct agent_expr
*ax
, struct axs_value
*value
,
954 struct axs_value
*value1
, struct axs_value
*value2
)
956 gdb_assert (TYPE_CODE (value1
->type
) == TYPE_CODE_PTR
);
957 gdb_assert (TYPE_CODE (value2
->type
) == 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
;
963 value
->kind
= axs_rvalue
;
967 /* Generate code for pointer arithmetic PTR - INT. */
969 gen_ptrsub (struct agent_expr
*ax
, struct axs_value
*value
,
970 struct axs_value
*value1
, struct axs_value
*value2
)
972 gdb_assert (TYPE_CODE (value1
->type
) == TYPE_CODE_PTR
);
973 gdb_assert (TYPE_CODE (value2
->type
) == TYPE_CODE_INT
);
975 gen_scale (ax
, aop_mul
, value1
->type
);
976 ax_simple (ax
, aop_sub
);
977 gen_extend (ax
, value1
->type
); /* Catch overflow. */
978 value
->type
= value1
->type
;
979 value
->kind
= axs_rvalue
;
983 /* Generate code for pointer arithmetic PTR - PTR. */
985 gen_ptrdiff (struct agent_expr
*ax
, struct axs_value
*value
,
986 struct axs_value
*value1
, struct axs_value
*value2
,
987 struct type
*result_type
)
989 gdb_assert (TYPE_CODE (value1
->type
) == TYPE_CODE_PTR
);
990 gdb_assert (TYPE_CODE (value2
->type
) == TYPE_CODE_PTR
);
992 if (TYPE_LENGTH (TYPE_TARGET_TYPE (value1
->type
))
993 != TYPE_LENGTH (TYPE_TARGET_TYPE (value2
->type
)))
995 First argument of `-' is a pointer, but second argument is neither\n\
996 an integer nor a pointer of the same type."));
998 ax_simple (ax
, aop_sub
);
999 gen_scale (ax
, aop_div_unsigned
, value1
->type
);
1000 value
->type
= result_type
;
1001 value
->kind
= axs_rvalue
;
1005 /* Generate code for a binary operator that doesn't do pointer magic.
1006 We set VALUE to describe the result value; we assume VALUE1 and
1007 VALUE2 describe the two operands, and that they've undergone the
1008 usual binary conversions. MAY_CARRY should be non-zero iff the
1009 result needs to be extended. NAME is the English name of the
1010 operator, used in error messages */
1012 gen_binop (struct agent_expr
*ax
, struct axs_value
*value
,
1013 struct axs_value
*value1
, struct axs_value
*value2
, enum agent_op op
,
1014 enum agent_op op_unsigned
, int may_carry
, char *name
)
1016 /* We only handle INT op INT. */
1017 if ((TYPE_CODE (value1
->type
) != TYPE_CODE_INT
)
1018 || (TYPE_CODE (value2
->type
) != TYPE_CODE_INT
))
1019 error (_("Invalid combination of types in %s."), name
);
1022 TYPE_UNSIGNED (value1
->type
) ? op_unsigned
: op
);
1024 gen_extend (ax
, value1
->type
); /* catch overflow */
1025 value
->type
= value1
->type
;
1026 value
->kind
= axs_rvalue
;
1031 gen_logical_not (struct agent_expr
*ax
, struct axs_value
*value
,
1032 struct type
*result_type
)
1034 if (TYPE_CODE (value
->type
) != TYPE_CODE_INT
1035 && TYPE_CODE (value
->type
) != TYPE_CODE_PTR
)
1036 error (_("Invalid type of operand to `!'."));
1038 ax_simple (ax
, aop_log_not
);
1039 value
->type
= result_type
;
1044 gen_complement (struct agent_expr
*ax
, struct axs_value
*value
)
1046 if (TYPE_CODE (value
->type
) != TYPE_CODE_INT
)
1047 error (_("Invalid type of operand to `~'."));
1049 ax_simple (ax
, aop_bit_not
);
1050 gen_extend (ax
, value
->type
);
1055 /* Generating bytecode from GDB expressions: * & . -> @ sizeof */
1057 /* Dereference the value on the top of the stack. */
1059 gen_deref (struct agent_expr
*ax
, struct axs_value
*value
)
1061 /* The caller should check the type, because several operators use
1062 this, and we don't know what error message to generate. */
1063 if (TYPE_CODE (value
->type
) != TYPE_CODE_PTR
)
1064 internal_error (__FILE__
, __LINE__
,
1065 _("gen_deref: expected a pointer"));
1067 /* We've got an rvalue now, which is a pointer. We want to yield an
1068 lvalue, whose address is exactly that pointer. So we don't
1069 actually emit any code; we just change the type from "Pointer to
1070 T" to "T", and mark the value as an lvalue in memory. Leave it
1071 to the consumer to actually dereference it. */
1072 value
->type
= check_typedef (TYPE_TARGET_TYPE (value
->type
));
1073 value
->kind
= ((TYPE_CODE (value
->type
) == TYPE_CODE_FUNC
)
1074 ? axs_rvalue
: axs_lvalue_memory
);
1078 /* Produce the address of the lvalue on the top of the stack. */
1080 gen_address_of (struct agent_expr
*ax
, struct axs_value
*value
)
1082 /* Special case for taking the address of a function. The ANSI
1083 standard describes this as a special case, too, so this
1084 arrangement is not without motivation. */
1085 if (TYPE_CODE (value
->type
) == TYPE_CODE_FUNC
)
1086 /* The value's already an rvalue on the stack, so we just need to
1088 value
->type
= lookup_pointer_type (value
->type
);
1090 switch (value
->kind
)
1093 error (_("Operand of `&' is an rvalue, which has no address."));
1095 case axs_lvalue_register
:
1096 error (_("Operand of `&' is in a register, and has no address."));
1098 case axs_lvalue_memory
:
1099 value
->kind
= axs_rvalue
;
1100 value
->type
= lookup_pointer_type (value
->type
);
1106 /* A lot of this stuff will have to change to support C++. But we're
1107 not going to deal with that at the moment. */
1109 /* Find the field in the structure type TYPE named NAME, and return
1110 its index in TYPE's field array. */
1112 find_field (struct type
*type
, char *name
)
1116 CHECK_TYPEDEF (type
);
1118 /* Make sure this isn't C++. */
1119 if (TYPE_N_BASECLASSES (type
) != 0)
1120 internal_error (__FILE__
, __LINE__
,
1121 _("find_field: derived classes supported"));
1123 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1125 char *this_name
= TYPE_FIELD_NAME (type
, i
);
1129 if (strcmp (name
, this_name
) == 0)
1132 if (this_name
[0] == '\0')
1133 internal_error (__FILE__
, __LINE__
,
1134 _("find_field: anonymous unions not supported"));
1138 error (_("Couldn't find member named `%s' in struct/union `%s'"),
1139 name
, TYPE_TAG_NAME (type
));
1145 /* Generate code to push the value of a bitfield of a structure whose
1146 address is on the top of the stack. START and END give the
1147 starting and one-past-ending *bit* numbers of the field within the
1150 gen_bitfield_ref (struct expression
*exp
, struct agent_expr
*ax
,
1151 struct axs_value
*value
, struct type
*type
,
1154 /* Note that ops[i] fetches 8 << i bits. */
1155 static enum agent_op ops
[]
1157 {aop_ref8
, aop_ref16
, aop_ref32
, aop_ref64
};
1158 static int num_ops
= (sizeof (ops
) / sizeof (ops
[0]));
1160 /* We don't want to touch any byte that the bitfield doesn't
1161 actually occupy; we shouldn't make any accesses we're not
1162 explicitly permitted to. We rely here on the fact that the
1163 bytecode `ref' operators work on unaligned addresses.
1165 It takes some fancy footwork to get the stack to work the way
1166 we'd like. Say we're retrieving a bitfield that requires three
1167 fetches. Initially, the stack just contains the address:
1169 For the first fetch, we duplicate the address
1171 then add the byte offset, do the fetch, and shift and mask as
1172 needed, yielding a fragment of the value, properly aligned for
1173 the final bitwise or:
1175 then we swap, and repeat the process:
1176 frag1 addr --- address on top
1177 frag1 addr addr --- duplicate it
1178 frag1 addr frag2 --- get second fragment
1179 frag1 frag2 addr --- swap again
1180 frag1 frag2 frag3 --- get third fragment
1181 Notice that, since the third fragment is the last one, we don't
1182 bother duplicating the address this time. Now we have all the
1183 fragments on the stack, and we can simply `or' them together,
1184 yielding the final value of the bitfield. */
1186 /* The first and one-after-last bits in the field, but rounded down
1187 and up to byte boundaries. */
1188 int bound_start
= (start
/ TARGET_CHAR_BIT
) * TARGET_CHAR_BIT
;
1189 int bound_end
= (((end
+ TARGET_CHAR_BIT
- 1)
1193 /* current bit offset within the structure */
1196 /* The index in ops of the opcode we're considering. */
1199 /* The number of fragments we generated in the process. Probably
1200 equal to the number of `one' bits in bytesize, but who cares? */
1203 /* Dereference any typedefs. */
1204 type
= check_typedef (type
);
1206 /* Can we fetch the number of bits requested at all? */
1207 if ((end
- start
) > ((1 << num_ops
) * 8))
1208 internal_error (__FILE__
, __LINE__
,
1209 _("gen_bitfield_ref: bitfield too wide"));
1211 /* Note that we know here that we only need to try each opcode once.
1212 That may not be true on machines with weird byte sizes. */
1213 offset
= bound_start
;
1215 for (op
= num_ops
- 1; op
>= 0; op
--)
1217 /* number of bits that ops[op] would fetch */
1218 int op_size
= 8 << op
;
1220 /* The stack at this point, from bottom to top, contains zero or
1221 more fragments, then the address. */
1223 /* Does this fetch fit within the bitfield? */
1224 if (offset
+ op_size
<= bound_end
)
1226 /* Is this the last fragment? */
1227 int last_frag
= (offset
+ op_size
== bound_end
);
1230 ax_simple (ax
, aop_dup
); /* keep a copy of the address */
1232 /* Add the offset. */
1233 gen_offset (ax
, offset
/ TARGET_CHAR_BIT
);
1237 /* Record the area of memory we're about to fetch. */
1238 ax_trace_quick (ax
, op_size
/ TARGET_CHAR_BIT
);
1241 /* Perform the fetch. */
1242 ax_simple (ax
, ops
[op
]);
1244 /* Shift the bits we have to their proper position.
1245 gen_left_shift will generate right shifts when the operand
1248 A big-endian field diagram to ponder:
1249 byte 0 byte 1 byte 2 byte 3 byte 4 byte 5 byte 6 byte 7
1250 +------++------++------++------++------++------++------++------+
1251 xxxxAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCxxxxxxxxxxx
1253 bit number 16 32 48 53
1254 These are bit numbers as supplied by GDB. Note that the
1255 bit numbers run from right to left once you've fetched the
1258 A little-endian field diagram to ponder:
1259 byte 7 byte 6 byte 5 byte 4 byte 3 byte 2 byte 1 byte 0
1260 +------++------++------++------++------++------++------++------+
1261 xxxxxxxxxxxAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCxxxx
1263 bit number 48 32 16 4 0
1265 In both cases, the most significant end is on the left
1266 (i.e. normal numeric writing order), which means that you
1267 don't go crazy thinking about `left' and `right' shifts.
1269 We don't have to worry about masking yet:
1270 - If they contain garbage off the least significant end, then we
1271 must be looking at the low end of the field, and the right
1272 shift will wipe them out.
1273 - If they contain garbage off the most significant end, then we
1274 must be looking at the most significant end of the word, and
1275 the sign/zero extension will wipe them out.
1276 - If we're in the interior of the word, then there is no garbage
1277 on either end, because the ref operators zero-extend. */
1278 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
1279 gen_left_shift (ax
, end
- (offset
+ op_size
));
1281 gen_left_shift (ax
, offset
- start
);
1284 /* Bring the copy of the address up to the top. */
1285 ax_simple (ax
, aop_swap
);
1292 /* Generate enough bitwise `or' operations to combine all the
1293 fragments we left on the stack. */
1294 while (fragment_count
-- > 1)
1295 ax_simple (ax
, aop_bit_or
);
1297 /* Sign- or zero-extend the value as appropriate. */
1298 ((TYPE_UNSIGNED (type
) ? ax_zero_ext
: ax_ext
) (ax
, end
- start
));
1300 /* This is *not* an lvalue. Ugh. */
1301 value
->kind
= axs_rvalue
;
1306 /* Generate code to reference the member named FIELD of a structure or
1307 union. The top of the stack, as described by VALUE, should have
1308 type (pointer to a)* struct/union. OPERATOR_NAME is the name of
1309 the operator being compiled, and OPERAND_NAME is the kind of thing
1310 it operates on; we use them in error messages. */
1312 gen_struct_ref (struct expression
*exp
, struct agent_expr
*ax
,
1313 struct axs_value
*value
, char *field
,
1314 char *operator_name
, char *operand_name
)
1319 /* Follow pointers until we reach a non-pointer. These aren't the C
1320 semantics, but they're what the normal GDB evaluator does, so we
1321 should at least be consistent. */
1322 while (TYPE_CODE (value
->type
) == TYPE_CODE_PTR
)
1324 require_rvalue (ax
, value
);
1325 gen_deref (ax
, value
);
1327 type
= check_typedef (value
->type
);
1329 /* This must yield a structure or a union. */
1330 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1331 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1332 error (_("The left operand of `%s' is not a %s."),
1333 operator_name
, operand_name
);
1335 /* And it must be in memory; we don't deal with structure rvalues,
1336 or structures living in registers. */
1337 if (value
->kind
!= axs_lvalue_memory
)
1338 error (_("Structure does not live in memory."));
1340 i
= find_field (type
, field
);
1342 /* Is this a bitfield? */
1343 if (TYPE_FIELD_PACKED (type
, i
))
1344 gen_bitfield_ref (exp
, ax
, value
, TYPE_FIELD_TYPE (type
, i
),
1345 TYPE_FIELD_BITPOS (type
, i
),
1346 (TYPE_FIELD_BITPOS (type
, i
)
1347 + TYPE_FIELD_BITSIZE (type
, i
)));
1350 gen_offset (ax
, TYPE_FIELD_BITPOS (type
, i
) / TARGET_CHAR_BIT
);
1351 value
->kind
= axs_lvalue_memory
;
1352 value
->type
= TYPE_FIELD_TYPE (type
, i
);
1357 /* Generate code for GDB's magical `repeat' operator.
1358 LVALUE @ INT creates an array INT elements long, and whose elements
1359 have the same type as LVALUE, located in memory so that LVALUE is
1360 its first element. For example, argv[0]@argc gives you the array
1361 of command-line arguments.
1363 Unfortunately, because we have to know the types before we actually
1364 have a value for the expression, we can't implement this perfectly
1365 without changing the type system, having values that occupy two
1366 stack slots, doing weird things with sizeof, etc. So we require
1367 the right operand to be a constant expression. */
1369 gen_repeat (struct expression
*exp
, union exp_element
**pc
,
1370 struct agent_expr
*ax
, struct axs_value
*value
)
1372 struct axs_value value1
;
1373 /* We don't want to turn this into an rvalue, so no conversions
1375 gen_expr (exp
, pc
, ax
, &value1
);
1376 if (value1
.kind
!= axs_lvalue_memory
)
1377 error (_("Left operand of `@' must be an object in memory."));
1379 /* Evaluate the length; it had better be a constant. */
1381 struct value
*v
= const_expr (pc
);
1385 error (_("Right operand of `@' must be a constant, in agent expressions."));
1386 if (TYPE_CODE (value_type (v
)) != TYPE_CODE_INT
)
1387 error (_("Right operand of `@' must be an integer."));
1388 length
= value_as_long (v
);
1390 error (_("Right operand of `@' must be positive."));
1392 /* The top of the stack is already the address of the object, so
1393 all we need to do is frob the type of the lvalue. */
1395 /* FIXME-type-allocation: need a way to free this type when we are
1398 = lookup_array_range_type (value1
.type
, 0, length
- 1);
1400 value
->kind
= axs_lvalue_memory
;
1401 value
->type
= array
;
1407 /* Emit code for the `sizeof' operator.
1408 *PC should point at the start of the operand expression; we advance it
1409 to the first instruction after the operand. */
1411 gen_sizeof (struct expression
*exp
, union exp_element
**pc
,
1412 struct agent_expr
*ax
, struct axs_value
*value
,
1413 struct type
*size_type
)
1415 /* We don't care about the value of the operand expression; we only
1416 care about its type. However, in the current arrangement, the
1417 only way to find an expression's type is to generate code for it.
1418 So we generate code for the operand, and then throw it away,
1419 replacing it with code that simply pushes its size. */
1420 int start
= ax
->len
;
1421 gen_expr (exp
, pc
, ax
, value
);
1423 /* Throw away the code we just generated. */
1426 ax_const_l (ax
, TYPE_LENGTH (value
->type
));
1427 value
->kind
= axs_rvalue
;
1428 value
->type
= size_type
;
1432 /* Generating bytecode from GDB expressions: general recursive thingy */
1435 /* A gen_expr function written by a Gen-X'er guy.
1436 Append code for the subexpression of EXPR starting at *POS_P to AX. */
1438 gen_expr (struct expression
*exp
, union exp_element
**pc
,
1439 struct agent_expr
*ax
, struct axs_value
*value
)
1441 /* Used to hold the descriptions of operand expressions. */
1442 struct axs_value value1
, value2
;
1443 enum exp_opcode op
= (*pc
)[0].opcode
;
1445 /* If we're looking at a constant expression, just push its value. */
1447 struct value
*v
= maybe_const_expr (pc
);
1451 ax_const_l (ax
, value_as_long (v
));
1452 value
->kind
= axs_rvalue
;
1453 value
->type
= check_typedef (value_type (v
));
1458 /* Otherwise, go ahead and generate code for it. */
1461 /* Binary arithmetic operators. */
1467 case BINOP_SUBSCRIPT
:
1468 case BINOP_BITWISE_AND
:
1469 case BINOP_BITWISE_IOR
:
1470 case BINOP_BITWISE_XOR
:
1472 gen_expr (exp
, pc
, ax
, &value1
);
1473 gen_usual_unary (exp
, ax
, &value1
);
1474 gen_expr (exp
, pc
, ax
, &value2
);
1475 gen_usual_unary (exp
, ax
, &value2
);
1476 gen_usual_arithmetic (exp
, ax
, &value1
, &value2
);
1480 if (TYPE_CODE (value1
.type
) == TYPE_CODE_INT
1481 && TYPE_CODE (value2
.type
) == TYPE_CODE_PTR
)
1483 /* Swap the values and proceed normally. */
1484 ax_simple (ax
, aop_swap
);
1485 gen_ptradd (ax
, value
, &value2
, &value1
);
1487 else if (TYPE_CODE (value1
.type
) == TYPE_CODE_PTR
1488 && TYPE_CODE (value2
.type
) == TYPE_CODE_INT
)
1489 gen_ptradd (ax
, value
, &value1
, &value2
);
1491 gen_binop (ax
, value
, &value1
, &value2
,
1492 aop_add
, aop_add
, 1, "addition");
1495 if (TYPE_CODE (value1
.type
) == TYPE_CODE_PTR
1496 && TYPE_CODE (value2
.type
) == TYPE_CODE_INT
)
1497 gen_ptrsub (ax
,value
, &value1
, &value2
);
1498 else if (TYPE_CODE (value1
.type
) == TYPE_CODE_PTR
1499 && TYPE_CODE (value2
.type
) == TYPE_CODE_PTR
)
1500 /* FIXME --- result type should be ptrdiff_t */
1501 gen_ptrdiff (ax
, value
, &value1
, &value2
,
1502 builtin_type (exp
->gdbarch
)->builtin_long
);
1504 gen_binop (ax
, value
, &value1
, &value2
,
1505 aop_sub
, aop_sub
, 1, "subtraction");
1508 gen_binop (ax
, value
, &value1
, &value2
,
1509 aop_mul
, aop_mul
, 1, "multiplication");
1512 gen_binop (ax
, value
, &value1
, &value2
,
1513 aop_div_signed
, aop_div_unsigned
, 1, "division");
1516 gen_binop (ax
, value
, &value1
, &value2
,
1517 aop_rem_signed
, aop_rem_unsigned
, 1, "remainder");
1519 case BINOP_SUBSCRIPT
:
1520 gen_ptradd (ax
, value
, &value1
, &value2
);
1521 if (TYPE_CODE (value
->type
) != TYPE_CODE_PTR
)
1522 error (_("Invalid combination of types in array subscripting."));
1523 gen_deref (ax
, value
);
1525 case BINOP_BITWISE_AND
:
1526 gen_binop (ax
, value
, &value1
, &value2
,
1527 aop_bit_and
, aop_bit_and
, 0, "bitwise and");
1530 case BINOP_BITWISE_IOR
:
1531 gen_binop (ax
, value
, &value1
, &value2
,
1532 aop_bit_or
, aop_bit_or
, 0, "bitwise or");
1535 case BINOP_BITWISE_XOR
:
1536 gen_binop (ax
, value
, &value1
, &value2
,
1537 aop_bit_xor
, aop_bit_xor
, 0, "bitwise exclusive-or");
1541 /* We should only list operators in the outer case statement
1542 that we actually handle in the inner case statement. */
1543 internal_error (__FILE__
, __LINE__
,
1544 _("gen_expr: op case sets don't match"));
1548 /* Note that we need to be a little subtle about generating code
1549 for comma. In C, we can do some optimizations here because
1550 we know the left operand is only being evaluated for effect.
1551 However, if the tracing kludge is in effect, then we always
1552 need to evaluate the left hand side fully, so that all the
1553 variables it mentions get traced. */
1556 gen_expr (exp
, pc
, ax
, &value1
);
1557 /* Don't just dispose of the left operand. We might be tracing,
1558 in which case we want to emit code to trace it if it's an
1560 gen_traced_pop (ax
, &value1
);
1561 gen_expr (exp
, pc
, ax
, value
);
1562 /* It's the consumer's responsibility to trace the right operand. */
1565 case OP_LONG
: /* some integer constant */
1567 struct type
*type
= (*pc
)[1].type
;
1568 LONGEST k
= (*pc
)[2].longconst
;
1570 gen_int_literal (ax
, value
, k
, type
);
1575 gen_var_ref (exp
->gdbarch
, ax
, value
, (*pc
)[2].symbol
);
1581 const char *name
= &(*pc
)[2].string
;
1583 (*pc
) += 4 + BYTES_TO_EXP_ELEM ((*pc
)[1].longconst
+ 1);
1584 reg
= user_reg_map_name_to_regnum (exp
->gdbarch
, name
, strlen (name
));
1586 internal_error (__FILE__
, __LINE__
,
1587 _("Register $%s not available"), name
);
1588 if (reg
>= gdbarch_num_regs (exp
->gdbarch
))
1589 error (_("'%s' is a pseudo-register; "
1590 "GDB cannot yet trace pseudoregister contents."),
1592 value
->kind
= axs_lvalue_register
;
1594 value
->type
= register_type (exp
->gdbarch
, reg
);
1598 case OP_INTERNALVAR
:
1599 error (_("GDB agent expressions cannot use convenience variables."));
1601 /* Weirdo operator: see comments for gen_repeat for details. */
1603 /* Note that gen_repeat handles its own argument evaluation. */
1605 gen_repeat (exp
, pc
, ax
, value
);
1610 struct type
*type
= (*pc
)[1].type
;
1612 gen_expr (exp
, pc
, ax
, value
);
1613 gen_cast (ax
, value
, type
);
1619 struct type
*type
= check_typedef ((*pc
)[1].type
);
1621 gen_expr (exp
, pc
, ax
, value
);
1622 /* I'm not sure I understand UNOP_MEMVAL entirely. I think
1623 it's just a hack for dealing with minsyms; you take some
1624 integer constant, pretend it's the address of an lvalue of
1625 the given type, and dereference it. */
1626 if (value
->kind
!= axs_rvalue
)
1627 /* This would be weird. */
1628 internal_error (__FILE__
, __LINE__
,
1629 _("gen_expr: OP_MEMVAL operand isn't an rvalue???"));
1631 value
->kind
= axs_lvalue_memory
;
1637 /* + FOO is equivalent to 0 + FOO, which can be optimized. */
1638 gen_expr (exp
, pc
, ax
, value
);
1639 gen_usual_unary (exp
, ax
, value
);
1644 /* -FOO is equivalent to 0 - FOO. */
1645 gen_int_literal (ax
, &value1
, 0,
1646 builtin_type (exp
->gdbarch
)->builtin_int
);
1647 gen_usual_unary (exp
, ax
, &value1
); /* shouldn't do much */
1648 gen_expr (exp
, pc
, ax
, &value2
);
1649 gen_usual_unary (exp
, ax
, &value2
);
1650 gen_usual_arithmetic (exp
, ax
, &value1
, &value2
);
1651 gen_binop (ax
, value
, &value1
, &value2
, aop_sub
, aop_sub
, 1, "negation");
1654 case UNOP_LOGICAL_NOT
:
1656 gen_expr (exp
, pc
, ax
, value
);
1657 gen_usual_unary (exp
, ax
, value
);
1658 gen_logical_not (ax
, value
,
1659 language_bool_type (exp
->language_defn
, exp
->gdbarch
));
1662 case UNOP_COMPLEMENT
:
1664 gen_expr (exp
, pc
, ax
, value
);
1665 gen_usual_unary (exp
, ax
, value
);
1666 gen_integral_promotions (exp
, ax
, value
);
1667 gen_complement (ax
, value
);
1672 gen_expr (exp
, pc
, ax
, value
);
1673 gen_usual_unary (exp
, ax
, value
);
1674 if (TYPE_CODE (value
->type
) != TYPE_CODE_PTR
)
1675 error (_("Argument of unary `*' is not a pointer."));
1676 gen_deref (ax
, value
);
1681 gen_expr (exp
, pc
, ax
, value
);
1682 gen_address_of (ax
, value
);
1687 /* Notice that gen_sizeof handles its own operand, unlike most
1688 of the other unary operator functions. This is because we
1689 have to throw away the code we generate. */
1690 gen_sizeof (exp
, pc
, ax
, value
,
1691 builtin_type (exp
->gdbarch
)->builtin_int
);
1694 case STRUCTOP_STRUCT
:
1697 int length
= (*pc
)[1].longconst
;
1698 char *name
= &(*pc
)[2].string
;
1700 (*pc
) += 4 + BYTES_TO_EXP_ELEM (length
+ 1);
1701 gen_expr (exp
, pc
, ax
, value
);
1702 if (op
== STRUCTOP_STRUCT
)
1703 gen_struct_ref (exp
, ax
, value
, name
, ".", "structure or union");
1704 else if (op
== STRUCTOP_PTR
)
1705 gen_struct_ref (exp
, ax
, value
, name
, "->",
1706 "pointer to a structure or union");
1708 /* If this `if' chain doesn't handle it, then the case list
1709 shouldn't mention it, and we shouldn't be here. */
1710 internal_error (__FILE__
, __LINE__
,
1711 _("gen_expr: unhandled struct case"));
1716 error (_("Attempt to use a type name as an expression."));
1719 error (_("Unsupported operator in expression."));
1725 /* Generating bytecode from GDB expressions: driver */
1727 /* Given a GDB expression EXPR, return bytecode to trace its value.
1728 The result will use the `trace' and `trace_quick' bytecodes to
1729 record the value of all memory touched by the expression. The
1730 caller can then use the ax_reqs function to discover which
1731 registers it relies upon. */
1733 gen_trace_for_expr (CORE_ADDR scope
, struct expression
*expr
)
1735 struct cleanup
*old_chain
= 0;
1736 struct agent_expr
*ax
= new_agent_expr (scope
);
1737 union exp_element
*pc
;
1738 struct axs_value value
;
1740 old_chain
= make_cleanup_free_agent_expr (ax
);
1744 gen_expr (expr
, &pc
, ax
, &value
);
1746 /* Make sure we record the final object, and get rid of it. */
1747 gen_traced_pop (ax
, &value
);
1749 /* Oh, and terminate. */
1750 ax_simple (ax
, aop_end
);
1752 /* We have successfully built the agent expr, so cancel the cleanup
1753 request. If we add more cleanups that we always want done, this
1754 will have to get more complicated. */
1755 discard_cleanups (old_chain
);
1760 agent_command (char *exp
, int from_tty
)
1762 struct cleanup
*old_chain
= 0;
1763 struct expression
*expr
;
1764 struct agent_expr
*agent
;
1765 struct frame_info
*fi
= get_current_frame (); /* need current scope */
1767 /* We don't deal with overlay debugging at the moment. We need to
1768 think more carefully about this. If you copy this code into
1769 another command, change the error message; the user shouldn't
1770 have to know anything about agent expressions. */
1771 if (overlay_debugging
)
1772 error (_("GDB can't do agent expression translation with overlays."));
1775 error_no_arg (_("expression to translate"));
1777 expr
= parse_expression (exp
);
1778 old_chain
= make_cleanup (free_current_contents
, &expr
);
1779 agent
= gen_trace_for_expr (get_frame_pc (fi
), expr
);
1780 make_cleanup_free_agent_expr (agent
);
1781 ax_print (gdb_stdout
, agent
);
1783 /* It would be nice to call ax_reqs here to gather some general info
1784 about the expression, and then print out the result. */
1786 do_cleanups (old_chain
);
1791 /* Initialization code. */
1793 void _initialize_ax_gdb (void);
1795 _initialize_ax_gdb (void)
1797 add_cmd ("agent", class_maintenance
, agent_command
,
1798 _("Translate an expression into remote agent bytecode."),
This page took 0.078446 seconds and 4 git commands to generate.