1 /* GDB-specific functions for operating on agent expressions.
3 Copyright (C) 1998-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
35 #include "user-regs.h"
36 #include "dictionary.h"
37 #include "breakpoint.h"
38 #include "tracepoint.h"
39 #include "cp-support.h"
40 #include "arch-utils.h"
41 #include "cli/cli-utils.h"
45 #include "typeprint.h"
49 #include "common/format.h"
51 /* To make sense of this file, you should read doc/agentexpr.texi.
52 Then look at the types and enums in ax-gdb.h. For the code itself,
53 look at gen_expr, towards the bottom; that's the main function that
54 looks at the GDB expressions and calls everything else to generate
57 I'm beginning to wonder whether it wouldn't be nicer to internally
58 generate trees, with types, and then spit out the bytecode in
59 linear form afterwards; we could generate fewer `swap', `ext', and
60 `zero_ext' bytecodes that way; it would make good constant folding
61 easier, too. But at the moment, I think we should be willing to
62 pay for the simplicity of this code with less-than-optimal bytecode
65 Remember, "GBD" stands for "Great Britain, Dammit!" So be careful. */
69 /* Prototypes for local functions. */
71 /* There's a standard order to the arguments of these functions:
72 union exp_element ** --- pointer into expression
73 struct agent_expr * --- agent expression buffer to generate code into
74 struct axs_value * --- describes value left on top of stack */
76 static struct value *const_var_ref (struct symbol *var);
77 static struct value *const_expr (union exp_element **pc);
78 static struct value *maybe_const_expr (union exp_element **pc);
80 static void gen_traced_pop (struct agent_expr *, struct axs_value *);
82 static void gen_sign_extend (struct agent_expr *, struct type *);
83 static void gen_extend (struct agent_expr *, struct type *);
84 static void gen_fetch (struct agent_expr *, struct type *);
85 static void gen_left_shift (struct agent_expr *, int);
88 static void gen_frame_args_address (struct agent_expr *);
89 static void gen_frame_locals_address (struct agent_expr *);
90 static void gen_offset (struct agent_expr *ax, int offset);
91 static void gen_sym_offset (struct agent_expr *, struct symbol *);
92 static void gen_var_ref (struct agent_expr *ax, struct axs_value *value,
96 static void gen_int_literal (struct agent_expr *ax,
97 struct axs_value *value,
98 LONGEST k, struct type *type);
100 static void gen_usual_unary (struct agent_expr *ax, struct axs_value *value);
101 static int type_wider_than (struct type *type1, struct type *type2);
102 static struct type *max_type (struct type *type1, struct type *type2);
103 static void gen_conversion (struct agent_expr *ax,
104 struct type *from, struct type *to);
105 static int is_nontrivial_conversion (struct type *from, struct type *to);
106 static void gen_usual_arithmetic (struct agent_expr *ax,
107 struct axs_value *value1,
108 struct axs_value *value2);
109 static void gen_integral_promotions (struct agent_expr *ax,
110 struct axs_value *value);
111 static void gen_cast (struct agent_expr *ax,
112 struct axs_value *value, struct type *type);
113 static void gen_scale (struct agent_expr *ax,
114 enum agent_op op, struct type *type);
115 static void gen_ptradd (struct agent_expr *ax, struct axs_value *value,
116 struct axs_value *value1, struct axs_value *value2);
117 static void gen_ptrsub (struct agent_expr *ax, struct axs_value *value,
118 struct axs_value *value1, struct axs_value *value2);
119 static void gen_ptrdiff (struct agent_expr *ax, struct axs_value *value,
120 struct axs_value *value1, struct axs_value *value2,
121 struct type *result_type);
122 static void gen_binop (struct agent_expr *ax,
123 struct axs_value *value,
124 struct axs_value *value1,
125 struct axs_value *value2,
127 enum agent_op op_unsigned, int may_carry,
129 static void gen_logical_not (struct agent_expr *ax, struct axs_value *value,
130 struct type *result_type);
131 static void gen_complement (struct agent_expr *ax, struct axs_value *value);
132 static void gen_deref (struct axs_value *);
133 static void gen_address_of (struct axs_value *);
134 static void gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value,
135 struct type *type, int start, int end);
136 static void gen_primitive_field (struct agent_expr *ax,
137 struct axs_value *value,
138 int offset, int fieldno, struct type *type);
139 static int gen_struct_ref_recursive (struct agent_expr *ax,
140 struct axs_value *value,
141 const char *field, int offset,
143 static void gen_struct_ref (struct agent_expr *ax,
144 struct axs_value *value,
146 const char *operator_name,
147 const char *operand_name);
148 static void gen_static_field (struct agent_expr *ax, struct axs_value *value,
149 struct type *type, int fieldno);
150 static void gen_repeat (struct expression *exp, union exp_element **pc,
151 struct agent_expr *ax, struct axs_value *value);
152 static void gen_sizeof (struct expression *exp, union exp_element **pc,
153 struct agent_expr *ax, struct axs_value *value,
154 struct type *size_type);
155 static void gen_expr_binop_rest (struct expression *exp,
156 enum exp_opcode op, union exp_element **pc,
157 struct agent_expr *ax,
158 struct axs_value *value,
159 struct axs_value *value1,
160 struct axs_value *value2);
163 /* Detecting constant expressions. */
165 /* If the variable reference at *PC is a constant, return its value.
166 Otherwise, return zero.
168 Hey, Wally! How can a variable reference be a constant?
170 Well, Beav, this function really handles the OP_VAR_VALUE operator,
171 not specifically variable references. GDB uses OP_VAR_VALUE to
172 refer to any kind of symbolic reference: function names, enum
173 elements, and goto labels are all handled through the OP_VAR_VALUE
174 operator, even though they're constants. It makes sense given the
177 Gee, Wally, don'cha wonder sometimes if data representations that
178 subvert commonly accepted definitions of terms in favor of heavily
179 context-specific interpretations are really just a tool of the
180 programming hegemony to preserve their power and exclude the
183 static struct value *
184 const_var_ref (struct symbol *var)
186 struct type *type = SYMBOL_TYPE (var);
188 switch (SYMBOL_CLASS (var))
191 return value_from_longest (type, (LONGEST) SYMBOL_VALUE (var));
194 return value_from_pointer (type, (CORE_ADDR) SYMBOL_VALUE_ADDRESS (var));
202 /* If the expression starting at *PC has a constant value, return it.
203 Otherwise, return zero. If we return a value, then *PC will be
204 advanced to the end of it. If we return zero, *PC could be
206 static struct value *
207 const_expr (union exp_element **pc)
209 enum exp_opcode op = (*pc)->opcode;
216 struct type *type = (*pc)[1].type;
217 LONGEST k = (*pc)[2].longconst;
220 return value_from_longest (type, k);
225 struct value *v = const_var_ref ((*pc)[2].symbol);
231 /* We could add more operators in here. */
235 v1 = const_expr (pc);
237 return value_neg (v1);
247 /* Like const_expr, but guarantee also that *PC is undisturbed if the
248 expression is not constant. */
249 static struct value *
250 maybe_const_expr (union exp_element **pc)
252 union exp_element *tentative_pc = *pc;
253 struct value *v = const_expr (&tentative_pc);
255 /* If we got a value, then update the real PC. */
263 /* Generating bytecode from GDB expressions: general assumptions */
265 /* Here are a few general assumptions made throughout the code; if you
266 want to make a change that contradicts one of these, then you'd
267 better scan things pretty thoroughly.
269 - We assume that all values occupy one stack element. For example,
270 sometimes we'll swap to get at the left argument to a binary
271 operator. If we decide that void values should occupy no stack
272 elements, or that synthetic arrays (whose size is determined at
273 run time, created by the `@' operator) should occupy two stack
274 elements (address and length), then this will cause trouble.
276 - We assume the stack elements are infinitely wide, and that we
277 don't have to worry what happens if the user requests an
278 operation that is wider than the actual interpreter's stack.
279 That is, it's up to the interpreter to handle directly all the
280 integer widths the user has access to. (Woe betide the language
283 - We don't support side effects. Thus, we don't have to worry about
284 GCC's generalized lvalues, function calls, etc.
286 - We don't support floating point. Many places where we switch on
287 some type don't bother to include cases for floating point; there
288 may be even more subtle ways this assumption exists. For
289 example, the arguments to % must be integers.
291 - We assume all subexpressions have a static, unchanging type. If
292 we tried to support convenience variables, this would be a
295 - All values on the stack should always be fully zero- or
298 (I wasn't sure whether to choose this or its opposite --- that
299 only addresses are assumed extended --- but it turns out that
300 neither convention completely eliminates spurious extend
301 operations (if everything is always extended, then you have to
302 extend after add, because it could overflow; if nothing is
303 extended, then you end up producing extends whenever you change
304 sizes), and this is simpler.) */
307 /* Scan for all static fields in the given class, including any base
308 classes, and generate tracing bytecodes for each. */
311 gen_trace_static_fields (struct agent_expr *ax,
314 int i, nbases = TYPE_N_BASECLASSES (type);
315 struct axs_value value;
317 type = check_typedef (type);
319 for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
321 if (field_is_static (&TYPE_FIELD (type, i)))
323 gen_static_field (ax, &value, type, i);
324 if (value.optimized_out)
328 case axs_lvalue_memory:
330 /* Initialize the TYPE_LENGTH if it is a typedef. */
331 check_typedef (value.type);
332 ax_const_l (ax, TYPE_LENGTH (value.type));
333 ax_simple (ax, aop_trace);
337 case axs_lvalue_register:
338 /* We don't actually need the register's value to be pushed,
339 just note that we need it to be collected. */
340 ax_reg_mask (ax, value.u.reg);
348 /* Now scan through base classes recursively. */
349 for (i = 0; i < nbases; i++)
351 struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
353 gen_trace_static_fields (ax, basetype);
357 /* Trace the lvalue on the stack, if it needs it. In either case, pop
358 the value. Useful on the left side of a comma, and at the end of
359 an expression being used for tracing. */
361 gen_traced_pop (struct agent_expr *ax, struct axs_value *value)
363 int string_trace = 0;
365 && TYPE_CODE (value->type) == TYPE_CODE_PTR
366 && c_textual_element_type (check_typedef (TYPE_TARGET_TYPE (value->type)),
376 ax_const_l (ax, ax->trace_string);
377 ax_simple (ax, aop_tracenz);
380 /* We don't trace rvalues, just the lvalues necessary to
381 produce them. So just dispose of this value. */
382 ax_simple (ax, aop_pop);
385 case axs_lvalue_memory:
387 /* Initialize the TYPE_LENGTH if it is a typedef. */
388 check_typedef (value->type);
392 gen_fetch (ax, value->type);
393 ax_const_l (ax, ax->trace_string);
394 ax_simple (ax, aop_tracenz);
398 /* There's no point in trying to use a trace_quick bytecode
399 here, since "trace_quick SIZE pop" is three bytes, whereas
400 "const8 SIZE trace" is also three bytes, does the same
401 thing, and the simplest code which generates that will also
402 work correctly for objects with large sizes. */
403 ax_const_l (ax, TYPE_LENGTH (value->type));
404 ax_simple (ax, aop_trace);
409 case axs_lvalue_register:
410 /* We don't actually need the register's value to be on the
411 stack, and the target will get heartburn if the register is
412 larger than will fit in a stack, so just mark it for
413 collection and be done with it. */
414 ax_reg_mask (ax, value->u.reg);
416 /* But if the register points to a string, assume the value
417 will fit on the stack and push it anyway. */
420 ax_reg (ax, value->u.reg);
421 ax_const_l (ax, ax->trace_string);
422 ax_simple (ax, aop_tracenz);
427 /* If we're not tracing, just pop the value. */
428 ax_simple (ax, aop_pop);
430 /* To trace C++ classes with static fields stored elsewhere. */
432 && (TYPE_CODE (value->type) == TYPE_CODE_STRUCT
433 || TYPE_CODE (value->type) == TYPE_CODE_UNION))
434 gen_trace_static_fields (ax, value->type);
439 /* Generating bytecode from GDB expressions: helper functions */
441 /* Assume that the lower bits of the top of the stack is a value of
442 type TYPE, and the upper bits are zero. Sign-extend if necessary. */
444 gen_sign_extend (struct agent_expr *ax, struct type *type)
446 /* Do we need to sign-extend this? */
447 if (!TYPE_UNSIGNED (type))
448 ax_ext (ax, TYPE_LENGTH (type) * TARGET_CHAR_BIT);
452 /* Assume the lower bits of the top of the stack hold a value of type
453 TYPE, and the upper bits are garbage. Sign-extend or truncate as
456 gen_extend (struct agent_expr *ax, struct type *type)
458 int bits = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
461 ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, bits));
465 /* Assume that the top of the stack contains a value of type "pointer
466 to TYPE"; generate code to fetch its value. Note that TYPE is the
467 target type, not the pointer type. */
469 gen_fetch (struct agent_expr *ax, struct type *type)
473 /* Record the area of memory we're about to fetch. */
474 ax_trace_quick (ax, TYPE_LENGTH (type));
477 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
478 type = TYPE_TARGET_TYPE (type);
480 switch (TYPE_CODE (type))
484 case TYPE_CODE_RVALUE_REF:
489 /* It's a scalar value, so we know how to dereference it. How
490 many bytes long is it? */
491 switch (TYPE_LENGTH (type))
493 case 8 / TARGET_CHAR_BIT:
494 ax_simple (ax, aop_ref8);
496 case 16 / TARGET_CHAR_BIT:
497 ax_simple (ax, aop_ref16);
499 case 32 / TARGET_CHAR_BIT:
500 ax_simple (ax, aop_ref32);
502 case 64 / TARGET_CHAR_BIT:
503 ax_simple (ax, aop_ref64);
506 /* Either our caller shouldn't have asked us to dereference
507 that pointer (other code's fault), or we're not
508 implementing something we should be (this code's fault).
509 In any case, it's a bug the user shouldn't see. */
511 internal_error (__FILE__, __LINE__,
512 _("gen_fetch: strange size"));
515 gen_sign_extend (ax, type);
519 /* Our caller requested us to dereference a pointer from an unsupported
520 type. Error out and give callers a chance to handle the failure
522 error (_("gen_fetch: Unsupported type code `%s'."),
528 /* Generate code to left shift the top of the stack by DISTANCE bits, or
529 right shift it by -DISTANCE bits if DISTANCE < 0. This generates
530 unsigned (logical) right shifts. */
532 gen_left_shift (struct agent_expr *ax, int distance)
536 ax_const_l (ax, distance);
537 ax_simple (ax, aop_lsh);
539 else if (distance < 0)
541 ax_const_l (ax, -distance);
542 ax_simple (ax, aop_rsh_unsigned);
548 /* Generating bytecode from GDB expressions: symbol references */
550 /* Generate code to push the base address of the argument portion of
551 the top stack frame. */
553 gen_frame_args_address (struct agent_expr *ax)
556 LONGEST frame_offset;
558 gdbarch_virtual_frame_pointer (ax->gdbarch,
559 ax->scope, &frame_reg, &frame_offset);
560 ax_reg (ax, frame_reg);
561 gen_offset (ax, frame_offset);
565 /* Generate code to push the base address of the locals portion of the
568 gen_frame_locals_address (struct agent_expr *ax)
571 LONGEST frame_offset;
573 gdbarch_virtual_frame_pointer (ax->gdbarch,
574 ax->scope, &frame_reg, &frame_offset);
575 ax_reg (ax, frame_reg);
576 gen_offset (ax, frame_offset);
580 /* Generate code to add OFFSET to the top of the stack. Try to
581 generate short and readable code. We use this for getting to
582 variables on the stack, and structure members. If we were
583 programming in ML, it would be clearer why these are the same
586 gen_offset (struct agent_expr *ax, int offset)
588 /* It would suffice to simply push the offset and add it, but this
589 makes it easier to read positive and negative offsets in the
593 ax_const_l (ax, offset);
594 ax_simple (ax, aop_add);
598 ax_const_l (ax, -offset);
599 ax_simple (ax, aop_sub);
604 /* In many cases, a symbol's value is the offset from some other
605 address (stack frame, base register, etc.) Generate code to add
606 VAR's value to the top of the stack. */
608 gen_sym_offset (struct agent_expr *ax, struct symbol *var)
610 gen_offset (ax, SYMBOL_VALUE (var));
614 /* Generate code for a variable reference to AX. The variable is the
615 symbol VAR. Set VALUE to describe the result. */
618 gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var)
620 /* Dereference any typedefs. */
621 value->type = check_typedef (SYMBOL_TYPE (var));
622 value->optimized_out = 0;
624 if (SYMBOL_COMPUTED_OPS (var) != NULL)
626 SYMBOL_COMPUTED_OPS (var)->tracepoint_var_ref (var, ax, value);
630 /* I'm imitating the code in read_var_value. */
631 switch (SYMBOL_CLASS (var))
633 case LOC_CONST: /* A constant, like an enum value. */
634 ax_const_l (ax, (LONGEST) SYMBOL_VALUE (var));
635 value->kind = axs_rvalue;
638 case LOC_LABEL: /* A goto label, being used as a value. */
639 ax_const_l (ax, (LONGEST) SYMBOL_VALUE_ADDRESS (var));
640 value->kind = axs_rvalue;
643 case LOC_CONST_BYTES:
644 internal_error (__FILE__, __LINE__,
645 _("gen_var_ref: LOC_CONST_BYTES "
646 "symbols are not supported"));
648 /* Variable at a fixed location in memory. Easy. */
650 /* Push the address of the variable. */
651 ax_const_l (ax, SYMBOL_VALUE_ADDRESS (var));
652 value->kind = axs_lvalue_memory;
655 case LOC_ARG: /* var lives in argument area of frame */
656 gen_frame_args_address (ax);
657 gen_sym_offset (ax, var);
658 value->kind = axs_lvalue_memory;
661 case LOC_REF_ARG: /* As above, but the frame slot really
662 holds the address of the variable. */
663 gen_frame_args_address (ax);
664 gen_sym_offset (ax, var);
665 /* Don't assume any particular pointer size. */
666 gen_fetch (ax, builtin_type (ax->gdbarch)->builtin_data_ptr);
667 value->kind = axs_lvalue_memory;
670 case LOC_LOCAL: /* var lives in locals area of frame */
671 gen_frame_locals_address (ax);
672 gen_sym_offset (ax, var);
673 value->kind = axs_lvalue_memory;
677 error (_("Cannot compute value of typedef `%s'."),
678 SYMBOL_PRINT_NAME (var));
682 ax_const_l (ax, BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (var)));
683 value->kind = axs_rvalue;
687 /* Don't generate any code at all; in the process of treating
688 this as an lvalue or rvalue, the caller will generate the
690 value->kind = axs_lvalue_register;
692 = SYMBOL_REGISTER_OPS (var)->register_number (var, ax->gdbarch);
695 /* A lot like LOC_REF_ARG, but the pointer lives directly in a
696 register, not on the stack. Simpler than LOC_REGISTER
697 because it's just like any other case where the thing
698 has a real address. */
699 case LOC_REGPARM_ADDR:
701 SYMBOL_REGISTER_OPS (var)->register_number (var, ax->gdbarch));
702 value->kind = axs_lvalue_memory;
707 struct bound_minimal_symbol msym
708 = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL);
711 error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var));
713 /* Push the address of the variable. */
714 ax_const_l (ax, BMSYMBOL_VALUE_ADDRESS (msym));
715 value->kind = axs_lvalue_memory;
720 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
722 case LOC_OPTIMIZED_OUT:
723 /* Flag this, but don't say anything; leave it up to callers to
725 value->optimized_out = 1;
729 error (_("Cannot find value of botched symbol `%s'."),
730 SYMBOL_PRINT_NAME (var));
735 /* Generate code for a minimal symbol variable reference to AX. The
736 variable is the symbol MINSYM, of OBJFILE. Set VALUE to describe
740 gen_msym_var_ref (agent_expr *ax, axs_value *value,
741 minimal_symbol *msymbol, objfile *objf)
744 type *t = find_minsym_type_and_address (msymbol, objf, &address);
746 value->optimized_out = false;
747 ax_const_l (ax, address);
748 value->kind = axs_lvalue_memory;
754 /* Generating bytecode from GDB expressions: literals */
757 gen_int_literal (struct agent_expr *ax, struct axs_value *value, LONGEST k,
761 value->kind = axs_rvalue;
762 value->type = check_typedef (type);
767 /* Generating bytecode from GDB expressions: unary conversions, casts */
769 /* Take what's on the top of the stack (as described by VALUE), and
770 try to make an rvalue out of it. Signal an error if we can't do
773 require_rvalue (struct agent_expr *ax, struct axs_value *value)
775 /* Only deal with scalars, structs and such may be too large
776 to fit in a stack entry. */
777 value->type = check_typedef (value->type);
778 if (TYPE_CODE (value->type) == TYPE_CODE_ARRAY
779 || TYPE_CODE (value->type) == TYPE_CODE_STRUCT
780 || TYPE_CODE (value->type) == TYPE_CODE_UNION
781 || TYPE_CODE (value->type) == TYPE_CODE_FUNC)
782 error (_("Value not scalar: cannot be an rvalue."));
787 /* It's already an rvalue. */
790 case axs_lvalue_memory:
791 /* The top of stack is the address of the object. Dereference. */
792 gen_fetch (ax, value->type);
795 case axs_lvalue_register:
796 /* There's nothing on the stack, but value->u.reg is the
797 register number containing the value.
799 When we add floating-point support, this is going to have to
800 change. What about SPARC register pairs, for example? */
801 ax_reg (ax, value->u.reg);
802 gen_extend (ax, value->type);
806 value->kind = axs_rvalue;
810 /* Assume the top of the stack is described by VALUE, and perform the
811 usual unary conversions. This is motivated by ANSI 6.2.2, but of
812 course GDB expressions are not ANSI; they're the mishmash union of
813 a bunch of languages. Rah.
815 NOTE! This function promises to produce an rvalue only when the
816 incoming value is of an appropriate type. In other words, the
817 consumer of the value this function produces may assume the value
818 is an rvalue only after checking its type.
820 The immediate issue is that if the user tries to use a structure or
821 union as an operand of, say, the `+' operator, we don't want to try
822 to convert that structure to an rvalue; require_rvalue will bomb on
823 structs and unions. Rather, we want to simply pass the struct
824 lvalue through unchanged, and let `+' raise an error. */
827 gen_usual_unary (struct agent_expr *ax, struct axs_value *value)
829 /* We don't have to generate any code for the usual integral
830 conversions, since values are always represented as full-width on
831 the stack. Should we tweak the type? */
833 /* Some types require special handling. */
834 switch (TYPE_CODE (value->type))
836 /* Functions get converted to a pointer to the function. */
838 value->type = lookup_pointer_type (value->type);
839 value->kind = axs_rvalue; /* Should always be true, but just in case. */
842 /* Arrays get converted to a pointer to their first element, and
843 are no longer an lvalue. */
844 case TYPE_CODE_ARRAY:
846 struct type *elements = TYPE_TARGET_TYPE (value->type);
848 value->type = lookup_pointer_type (elements);
849 value->kind = axs_rvalue;
850 /* We don't need to generate any code; the address of the array
851 is also the address of its first element. */
855 /* Don't try to convert structures and unions to rvalues. Let the
856 consumer signal an error. */
857 case TYPE_CODE_STRUCT:
858 case TYPE_CODE_UNION:
862 /* If the value is an lvalue, dereference it. */
863 require_rvalue (ax, value);
867 /* Return non-zero iff the type TYPE1 is considered "wider" than the
868 type TYPE2, according to the rules described in gen_usual_arithmetic. */
870 type_wider_than (struct type *type1, struct type *type2)
872 return (TYPE_LENGTH (type1) > TYPE_LENGTH (type2)
873 || (TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
874 && TYPE_UNSIGNED (type1)
875 && !TYPE_UNSIGNED (type2)));
879 /* Return the "wider" of the two types TYPE1 and TYPE2. */
881 max_type (struct type *type1, struct type *type2)
883 return type_wider_than (type1, type2) ? type1 : type2;
887 /* Generate code to convert a scalar value of type FROM to type TO. */
889 gen_conversion (struct agent_expr *ax, struct type *from, struct type *to)
891 /* Perhaps there is a more graceful way to state these rules. */
893 /* If we're converting to a narrower type, then we need to clear out
895 if (TYPE_LENGTH (to) < TYPE_LENGTH (from))
898 /* If the two values have equal width, but different signednesses,
899 then we need to extend. */
900 else if (TYPE_LENGTH (to) == TYPE_LENGTH (from))
902 if (TYPE_UNSIGNED (from) != TYPE_UNSIGNED (to))
906 /* If we're converting to a wider type, and becoming unsigned, then
907 we need to zero out any possible sign bits. */
908 else if (TYPE_LENGTH (to) > TYPE_LENGTH (from))
910 if (TYPE_UNSIGNED (to))
916 /* Return non-zero iff the type FROM will require any bytecodes to be
917 emitted to be converted to the type TO. */
919 is_nontrivial_conversion (struct type *from, struct type *to)
921 agent_expr_up ax (new agent_expr (NULL, 0));
924 /* Actually generate the code, and see if anything came out. At the
925 moment, it would be trivial to replicate the code in
926 gen_conversion here, but in the future, when we're supporting
927 floating point and the like, it may not be. Doing things this
928 way allows this function to be independent of the logic in
930 gen_conversion (ax.get (), from, to);
931 nontrivial = ax->len > 0;
936 /* Generate code to perform the "usual arithmetic conversions" (ANSI C
937 6.2.1.5) for the two operands of an arithmetic operator. This
938 effectively finds a "least upper bound" type for the two arguments,
939 and promotes each argument to that type. *VALUE1 and *VALUE2
940 describe the values as they are passed in, and as they are left. */
942 gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1,
943 struct axs_value *value2)
945 /* Do the usual binary conversions. */
946 if (TYPE_CODE (value1->type) == TYPE_CODE_INT
947 && TYPE_CODE (value2->type) == TYPE_CODE_INT)
949 /* The ANSI integral promotions seem to work this way: Order the
950 integer types by size, and then by signedness: an n-bit
951 unsigned type is considered "wider" than an n-bit signed
952 type. Promote to the "wider" of the two types, and always
953 promote at least to int. */
954 struct type *target = max_type (builtin_type (ax->gdbarch)->builtin_int,
955 max_type (value1->type, value2->type));
957 /* Deal with value2, on the top of the stack. */
958 gen_conversion (ax, value2->type, target);
960 /* Deal with value1, not on the top of the stack. Don't
961 generate the `swap' instructions if we're not actually going
963 if (is_nontrivial_conversion (value1->type, target))
965 ax_simple (ax, aop_swap);
966 gen_conversion (ax, value1->type, target);
967 ax_simple (ax, aop_swap);
970 value1->type = value2->type = check_typedef (target);
975 /* Generate code to perform the integral promotions (ANSI 6.2.1.1) on
976 the value on the top of the stack, as described by VALUE. Assume
977 the value has integral type. */
979 gen_integral_promotions (struct agent_expr *ax, struct axs_value *value)
981 const struct builtin_type *builtin = builtin_type (ax->gdbarch);
983 if (!type_wider_than (value->type, builtin->builtin_int))
985 gen_conversion (ax, value->type, builtin->builtin_int);
986 value->type = builtin->builtin_int;
988 else if (!type_wider_than (value->type, builtin->builtin_unsigned_int))
990 gen_conversion (ax, value->type, builtin->builtin_unsigned_int);
991 value->type = builtin->builtin_unsigned_int;
996 /* Generate code for a cast to TYPE. */
998 gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type)
1000 /* GCC does allow casts to yield lvalues, so this should be fixed
1001 before merging these changes into the trunk. */
1002 require_rvalue (ax, value);
1003 /* Dereference typedefs. */
1004 type = check_typedef (type);
1006 switch (TYPE_CODE (type))
1010 case TYPE_CODE_RVALUE_REF:
1011 /* It's implementation-defined, and I'll bet this is what GCC
1015 case TYPE_CODE_ARRAY:
1016 case TYPE_CODE_STRUCT:
1017 case TYPE_CODE_UNION:
1018 case TYPE_CODE_FUNC:
1019 error (_("Invalid type cast: intended type must be scalar."));
1021 case TYPE_CODE_ENUM:
1022 case TYPE_CODE_BOOL:
1023 /* We don't have to worry about the size of the value, because
1024 all our integral values are fully sign-extended, and when
1025 casting pointers we can do anything we like. Is there any
1026 way for us to know what GCC actually does with a cast like
1031 gen_conversion (ax, value->type, type);
1034 case TYPE_CODE_VOID:
1035 /* We could pop the value, and rely on everyone else to check
1036 the type and notice that this value doesn't occupy a stack
1037 slot. But for now, leave the value on the stack, and
1038 preserve the "value == stack element" assumption. */
1042 error (_("Casts to requested type are not yet implemented."));
1050 /* Generating bytecode from GDB expressions: arithmetic */
1052 /* Scale the integer on the top of the stack by the size of the target
1053 of the pointer type TYPE. */
1055 gen_scale (struct agent_expr *ax, enum agent_op op, struct type *type)
1057 struct type *element = TYPE_TARGET_TYPE (type);
1059 if (TYPE_LENGTH (element) != 1)
1061 ax_const_l (ax, TYPE_LENGTH (element));
1067 /* Generate code for pointer arithmetic PTR + INT. */
1069 gen_ptradd (struct agent_expr *ax, struct axs_value *value,
1070 struct axs_value *value1, struct axs_value *value2)
1072 gdb_assert (pointer_type (value1->type));
1073 gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_INT);
1075 gen_scale (ax, aop_mul, value1->type);
1076 ax_simple (ax, aop_add);
1077 gen_extend (ax, value1->type); /* Catch overflow. */
1078 value->type = value1->type;
1079 value->kind = axs_rvalue;
1083 /* Generate code for pointer arithmetic PTR - INT. */
1085 gen_ptrsub (struct agent_expr *ax, struct axs_value *value,
1086 struct axs_value *value1, struct axs_value *value2)
1088 gdb_assert (pointer_type (value1->type));
1089 gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_INT);
1091 gen_scale (ax, aop_mul, value1->type);
1092 ax_simple (ax, aop_sub);
1093 gen_extend (ax, value1->type); /* Catch overflow. */
1094 value->type = value1->type;
1095 value->kind = axs_rvalue;
1099 /* Generate code for pointer arithmetic PTR - PTR. */
1101 gen_ptrdiff (struct agent_expr *ax, struct axs_value *value,
1102 struct axs_value *value1, struct axs_value *value2,
1103 struct type *result_type)
1105 gdb_assert (pointer_type (value1->type));
1106 gdb_assert (pointer_type (value2->type));
1108 if (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type))
1109 != TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type)))
1111 First argument of `-' is a pointer, but second argument is neither\n\
1112 an integer nor a pointer of the same type."));
1114 ax_simple (ax, aop_sub);
1115 gen_scale (ax, aop_div_unsigned, value1->type);
1116 value->type = result_type;
1117 value->kind = axs_rvalue;
1121 gen_equal (struct agent_expr *ax, struct axs_value *value,
1122 struct axs_value *value1, struct axs_value *value2,
1123 struct type *result_type)
1125 if (pointer_type (value1->type) || pointer_type (value2->type))
1126 ax_simple (ax, aop_equal);
1128 gen_binop (ax, value, value1, value2,
1129 aop_equal, aop_equal, 0, "equal");
1130 value->type = result_type;
1131 value->kind = axs_rvalue;
1135 gen_less (struct agent_expr *ax, struct axs_value *value,
1136 struct axs_value *value1, struct axs_value *value2,
1137 struct type *result_type)
1139 if (pointer_type (value1->type) || pointer_type (value2->type))
1140 ax_simple (ax, aop_less_unsigned);
1142 gen_binop (ax, value, value1, value2,
1143 aop_less_signed, aop_less_unsigned, 0, "less than");
1144 value->type = result_type;
1145 value->kind = axs_rvalue;
1148 /* Generate code for a binary operator that doesn't do pointer magic.
1149 We set VALUE to describe the result value; we assume VALUE1 and
1150 VALUE2 describe the two operands, and that they've undergone the
1151 usual binary conversions. MAY_CARRY should be non-zero iff the
1152 result needs to be extended. NAME is the English name of the
1153 operator, used in error messages */
1155 gen_binop (struct agent_expr *ax, struct axs_value *value,
1156 struct axs_value *value1, struct axs_value *value2,
1157 enum agent_op op, enum agent_op op_unsigned,
1158 int may_carry, const char *name)
1160 /* We only handle INT op INT. */
1161 if ((TYPE_CODE (value1->type) != TYPE_CODE_INT)
1162 || (TYPE_CODE (value2->type) != TYPE_CODE_INT))
1163 error (_("Invalid combination of types in %s."), name);
1166 TYPE_UNSIGNED (value1->type) ? op_unsigned : op);
1168 gen_extend (ax, value1->type); /* catch overflow */
1169 value->type = value1->type;
1170 value->kind = axs_rvalue;
1175 gen_logical_not (struct agent_expr *ax, struct axs_value *value,
1176 struct type *result_type)
1178 if (TYPE_CODE (value->type) != TYPE_CODE_INT
1179 && TYPE_CODE (value->type) != TYPE_CODE_PTR)
1180 error (_("Invalid type of operand to `!'."));
1182 ax_simple (ax, aop_log_not);
1183 value->type = result_type;
1188 gen_complement (struct agent_expr *ax, struct axs_value *value)
1190 if (TYPE_CODE (value->type) != TYPE_CODE_INT)
1191 error (_("Invalid type of operand to `~'."));
1193 ax_simple (ax, aop_bit_not);
1194 gen_extend (ax, value->type);
1199 /* Generating bytecode from GDB expressions: * & . -> @ sizeof */
1201 /* Dereference the value on the top of the stack. */
1203 gen_deref (struct axs_value *value)
1205 /* The caller should check the type, because several operators use
1206 this, and we don't know what error message to generate. */
1207 if (!pointer_type (value->type))
1208 internal_error (__FILE__, __LINE__,
1209 _("gen_deref: expected a pointer"));
1211 /* We've got an rvalue now, which is a pointer. We want to yield an
1212 lvalue, whose address is exactly that pointer. So we don't
1213 actually emit any code; we just change the type from "Pointer to
1214 T" to "T", and mark the value as an lvalue in memory. Leave it
1215 to the consumer to actually dereference it. */
1216 value->type = check_typedef (TYPE_TARGET_TYPE (value->type));
1217 if (TYPE_CODE (value->type) == TYPE_CODE_VOID)
1218 error (_("Attempt to dereference a generic pointer."));
1219 value->kind = ((TYPE_CODE (value->type) == TYPE_CODE_FUNC)
1220 ? axs_rvalue : axs_lvalue_memory);
1224 /* Produce the address of the lvalue on the top of the stack. */
1226 gen_address_of (struct axs_value *value)
1228 /* Special case for taking the address of a function. The ANSI
1229 standard describes this as a special case, too, so this
1230 arrangement is not without motivation. */
1231 if (TYPE_CODE (value->type) == TYPE_CODE_FUNC)
1232 /* The value's already an rvalue on the stack, so we just need to
1234 value->type = lookup_pointer_type (value->type);
1236 switch (value->kind)
1239 error (_("Operand of `&' is an rvalue, which has no address."));
1241 case axs_lvalue_register:
1242 error (_("Operand of `&' is in a register, and has no address."));
1244 case axs_lvalue_memory:
1245 value->kind = axs_rvalue;
1246 value->type = lookup_pointer_type (value->type);
1251 /* Generate code to push the value of a bitfield of a structure whose
1252 address is on the top of the stack. START and END give the
1253 starting and one-past-ending *bit* numbers of the field within the
1256 gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value,
1257 struct type *type, int start, int end)
1259 /* Note that ops[i] fetches 8 << i bits. */
1260 static enum agent_op ops[]
1261 = {aop_ref8, aop_ref16, aop_ref32, aop_ref64};
1262 static int num_ops = (sizeof (ops) / sizeof (ops[0]));
1264 /* We don't want to touch any byte that the bitfield doesn't
1265 actually occupy; we shouldn't make any accesses we're not
1266 explicitly permitted to. We rely here on the fact that the
1267 bytecode `ref' operators work on unaligned addresses.
1269 It takes some fancy footwork to get the stack to work the way
1270 we'd like. Say we're retrieving a bitfield that requires three
1271 fetches. Initially, the stack just contains the address:
1273 For the first fetch, we duplicate the address
1275 then add the byte offset, do the fetch, and shift and mask as
1276 needed, yielding a fragment of the value, properly aligned for
1277 the final bitwise or:
1279 then we swap, and repeat the process:
1280 frag1 addr --- address on top
1281 frag1 addr addr --- duplicate it
1282 frag1 addr frag2 --- get second fragment
1283 frag1 frag2 addr --- swap again
1284 frag1 frag2 frag3 --- get third fragment
1285 Notice that, since the third fragment is the last one, we don't
1286 bother duplicating the address this time. Now we have all the
1287 fragments on the stack, and we can simply `or' them together,
1288 yielding the final value of the bitfield. */
1290 /* The first and one-after-last bits in the field, but rounded down
1291 and up to byte boundaries. */
1292 int bound_start = (start / TARGET_CHAR_BIT) * TARGET_CHAR_BIT;
1293 int bound_end = (((end + TARGET_CHAR_BIT - 1)
1297 /* current bit offset within the structure */
1300 /* The index in ops of the opcode we're considering. */
1303 /* The number of fragments we generated in the process. Probably
1304 equal to the number of `one' bits in bytesize, but who cares? */
1307 /* Dereference any typedefs. */
1308 type = check_typedef (type);
1310 /* Can we fetch the number of bits requested at all? */
1311 if ((end - start) > ((1 << num_ops) * 8))
1312 internal_error (__FILE__, __LINE__,
1313 _("gen_bitfield_ref: bitfield too wide"));
1315 /* Note that we know here that we only need to try each opcode once.
1316 That may not be true on machines with weird byte sizes. */
1317 offset = bound_start;
1319 for (op = num_ops - 1; op >= 0; op--)
1321 /* number of bits that ops[op] would fetch */
1322 int op_size = 8 << op;
1324 /* The stack at this point, from bottom to top, contains zero or
1325 more fragments, then the address. */
1327 /* Does this fetch fit within the bitfield? */
1328 if (offset + op_size <= bound_end)
1330 /* Is this the last fragment? */
1331 int last_frag = (offset + op_size == bound_end);
1334 ax_simple (ax, aop_dup); /* keep a copy of the address */
1336 /* Add the offset. */
1337 gen_offset (ax, offset / TARGET_CHAR_BIT);
1341 /* Record the area of memory we're about to fetch. */
1342 ax_trace_quick (ax, op_size / TARGET_CHAR_BIT);
1345 /* Perform the fetch. */
1346 ax_simple (ax, ops[op]);
1348 /* Shift the bits we have to their proper position.
1349 gen_left_shift will generate right shifts when the operand
1352 A big-endian field diagram to ponder:
1353 byte 0 byte 1 byte 2 byte 3 byte 4 byte 5 byte 6 byte 7
1354 +------++------++------++------++------++------++------++------+
1355 xxxxAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCxxxxxxxxxxx
1357 bit number 16 32 48 53
1358 These are bit numbers as supplied by GDB. Note that the
1359 bit numbers run from right to left once you've fetched the
1362 A little-endian field diagram to ponder:
1363 byte 7 byte 6 byte 5 byte 4 byte 3 byte 2 byte 1 byte 0
1364 +------++------++------++------++------++------++------++------+
1365 xxxxxxxxxxxAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCxxxx
1367 bit number 48 32 16 4 0
1369 In both cases, the most significant end is on the left
1370 (i.e. normal numeric writing order), which means that you
1371 don't go crazy thinking about `left' and `right' shifts.
1373 We don't have to worry about masking yet:
1374 - If they contain garbage off the least significant end, then we
1375 must be looking at the low end of the field, and the right
1376 shift will wipe them out.
1377 - If they contain garbage off the most significant end, then we
1378 must be looking at the most significant end of the word, and
1379 the sign/zero extension will wipe them out.
1380 - If we're in the interior of the word, then there is no garbage
1381 on either end, because the ref operators zero-extend. */
1382 if (gdbarch_byte_order (ax->gdbarch) == BFD_ENDIAN_BIG)
1383 gen_left_shift (ax, end - (offset + op_size));
1385 gen_left_shift (ax, offset - start);
1388 /* Bring the copy of the address up to the top. */
1389 ax_simple (ax, aop_swap);
1396 /* Generate enough bitwise `or' operations to combine all the
1397 fragments we left on the stack. */
1398 while (fragment_count-- > 1)
1399 ax_simple (ax, aop_bit_or);
1401 /* Sign- or zero-extend the value as appropriate. */
1402 ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, end - start));
1404 /* This is *not* an lvalue. Ugh. */
1405 value->kind = axs_rvalue;
1409 /* Generate bytecodes for field number FIELDNO of type TYPE. OFFSET
1410 is an accumulated offset (in bytes), will be nonzero for objects
1411 embedded in other objects, like C++ base classes. Behavior should
1412 generally follow value_primitive_field. */
1415 gen_primitive_field (struct agent_expr *ax, struct axs_value *value,
1416 int offset, int fieldno, struct type *type)
1418 /* Is this a bitfield? */
1419 if (TYPE_FIELD_PACKED (type, fieldno))
1420 gen_bitfield_ref (ax, value, TYPE_FIELD_TYPE (type, fieldno),
1421 (offset * TARGET_CHAR_BIT
1422 + TYPE_FIELD_BITPOS (type, fieldno)),
1423 (offset * TARGET_CHAR_BIT
1424 + TYPE_FIELD_BITPOS (type, fieldno)
1425 + TYPE_FIELD_BITSIZE (type, fieldno)));
1428 gen_offset (ax, offset
1429 + TYPE_FIELD_BITPOS (type, fieldno) / TARGET_CHAR_BIT);
1430 value->kind = axs_lvalue_memory;
1431 value->type = TYPE_FIELD_TYPE (type, fieldno);
1435 /* Search for the given field in either the given type or one of its
1436 base classes. Return 1 if found, 0 if not. */
1439 gen_struct_ref_recursive (struct agent_expr *ax, struct axs_value *value,
1440 const char *field, int offset, struct type *type)
1443 int nbases = TYPE_N_BASECLASSES (type);
1445 type = check_typedef (type);
1447 for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
1449 const char *this_name = TYPE_FIELD_NAME (type, i);
1453 if (strcmp (field, this_name) == 0)
1455 /* Note that bytecodes for the struct's base (aka
1456 "this") will have been generated already, which will
1457 be unnecessary but not harmful if the static field is
1458 being handled as a global. */
1459 if (field_is_static (&TYPE_FIELD (type, i)))
1461 gen_static_field (ax, value, type, i);
1462 if (value->optimized_out)
1463 error (_("static field `%s' has been "
1464 "optimized out, cannot use"),
1469 gen_primitive_field (ax, value, offset, i, type);
1472 #if 0 /* is this right? */
1473 if (this_name[0] == '\0')
1474 internal_error (__FILE__, __LINE__,
1475 _("find_field: anonymous unions not supported"));
1480 /* Now scan through base classes recursively. */
1481 for (i = 0; i < nbases; i++)
1483 struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
1485 rslt = gen_struct_ref_recursive (ax, value, field,
1486 offset + TYPE_BASECLASS_BITPOS (type, i)
1493 /* Not found anywhere, flag so caller can complain. */
1497 /* Generate code to reference the member named FIELD of a structure or
1498 union. The top of the stack, as described by VALUE, should have
1499 type (pointer to a)* struct/union. OPERATOR_NAME is the name of
1500 the operator being compiled, and OPERAND_NAME is the kind of thing
1501 it operates on; we use them in error messages. */
1503 gen_struct_ref (struct agent_expr *ax, struct axs_value *value,
1504 const char *field, const char *operator_name,
1505 const char *operand_name)
1510 /* Follow pointers until we reach a non-pointer. These aren't the C
1511 semantics, but they're what the normal GDB evaluator does, so we
1512 should at least be consistent. */
1513 while (pointer_type (value->type))
1515 require_rvalue (ax, value);
1518 type = check_typedef (value->type);
1520 /* This must yield a structure or a union. */
1521 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1522 && TYPE_CODE (type) != TYPE_CODE_UNION)
1523 error (_("The left operand of `%s' is not a %s."),
1524 operator_name, operand_name);
1526 /* And it must be in memory; we don't deal with structure rvalues,
1527 or structures living in registers. */
1528 if (value->kind != axs_lvalue_memory)
1529 error (_("Structure does not live in memory."));
1531 /* Search through fields and base classes recursively. */
1532 found = gen_struct_ref_recursive (ax, value, field, 0, type);
1535 error (_("Couldn't find member named `%s' in struct/union/class `%s'"),
1536 field, TYPE_NAME (type));
1540 gen_namespace_elt (struct agent_expr *ax, struct axs_value *value,
1541 const struct type *curtype, char *name);
1543 gen_maybe_namespace_elt (struct agent_expr *ax, struct axs_value *value,
1544 const struct type *curtype, char *name);
1547 gen_static_field (struct agent_expr *ax, struct axs_value *value,
1548 struct type *type, int fieldno)
1550 if (TYPE_FIELD_LOC_KIND (type, fieldno) == FIELD_LOC_KIND_PHYSADDR)
1552 ax_const_l (ax, TYPE_FIELD_STATIC_PHYSADDR (type, fieldno));
1553 value->kind = axs_lvalue_memory;
1554 value->type = TYPE_FIELD_TYPE (type, fieldno);
1555 value->optimized_out = 0;
1559 const char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
1560 struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0).symbol;
1564 gen_var_ref (ax, value, sym);
1566 /* Don't error if the value was optimized out, we may be
1567 scanning all static fields and just want to pass over this
1568 and continue with the rest. */
1572 /* Silently assume this was optimized out; class printing
1573 will let the user know why the data is missing. */
1574 value->optimized_out = 1;
1580 gen_struct_elt_for_reference (struct agent_expr *ax, struct axs_value *value,
1581 struct type *type, char *fieldname)
1583 struct type *t = type;
1586 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1587 && TYPE_CODE (t) != TYPE_CODE_UNION)
1588 internal_error (__FILE__, __LINE__,
1589 _("non-aggregate type to gen_struct_elt_for_reference"));
1591 for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
1593 const char *t_field_name = TYPE_FIELD_NAME (t, i);
1595 if (t_field_name && strcmp (t_field_name, fieldname) == 0)
1597 if (field_is_static (&TYPE_FIELD (t, i)))
1599 gen_static_field (ax, value, t, i);
1600 if (value->optimized_out)
1601 error (_("static field `%s' has been "
1602 "optimized out, cannot use"),
1606 if (TYPE_FIELD_PACKED (t, i))
1607 error (_("pointers to bitfield members not allowed"));
1609 /* FIXME we need a way to do "want_address" equivalent */
1611 error (_("Cannot reference non-static field \"%s\""), fieldname);
1615 /* FIXME add other scoped-reference cases here */
1617 /* Do a last-ditch lookup. */
1618 return gen_maybe_namespace_elt (ax, value, type, fieldname);
1621 /* C++: Return the member NAME of the namespace given by the type
1625 gen_namespace_elt (struct agent_expr *ax, struct axs_value *value,
1626 const struct type *curtype, char *name)
1628 int found = gen_maybe_namespace_elt (ax, value, curtype, name);
1631 error (_("No symbol \"%s\" in namespace \"%s\"."),
1632 name, TYPE_NAME (curtype));
1637 /* A helper function used by value_namespace_elt and
1638 value_struct_elt_for_reference. It looks up NAME inside the
1639 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
1640 is a class and NAME refers to a type in CURTYPE itself (as opposed
1641 to, say, some base class of CURTYPE). */
1644 gen_maybe_namespace_elt (struct agent_expr *ax, struct axs_value *value,
1645 const struct type *curtype, char *name)
1647 const char *namespace_name = TYPE_NAME (curtype);
1648 struct block_symbol sym;
1650 sym = cp_lookup_symbol_namespace (namespace_name, name,
1651 block_for_pc (ax->scope),
1654 if (sym.symbol == NULL)
1657 gen_var_ref (ax, value, sym.symbol);
1659 if (value->optimized_out)
1660 error (_("`%s' has been optimized out, cannot use"),
1661 SYMBOL_PRINT_NAME (sym.symbol));
1668 gen_aggregate_elt_ref (struct agent_expr *ax, struct axs_value *value,
1669 struct type *type, char *field)
1671 switch (TYPE_CODE (type))
1673 case TYPE_CODE_STRUCT:
1674 case TYPE_CODE_UNION:
1675 return gen_struct_elt_for_reference (ax, value, type, field);
1677 case TYPE_CODE_NAMESPACE:
1678 return gen_namespace_elt (ax, value, type, field);
1681 internal_error (__FILE__, __LINE__,
1682 _("non-aggregate type in gen_aggregate_elt_ref"));
1688 /* Generate code for GDB's magical `repeat' operator.
1689 LVALUE @ INT creates an array INT elements long, and whose elements
1690 have the same type as LVALUE, located in memory so that LVALUE is
1691 its first element. For example, argv[0]@argc gives you the array
1692 of command-line arguments.
1694 Unfortunately, because we have to know the types before we actually
1695 have a value for the expression, we can't implement this perfectly
1696 without changing the type system, having values that occupy two
1697 stack slots, doing weird things with sizeof, etc. So we require
1698 the right operand to be a constant expression. */
1700 gen_repeat (struct expression *exp, union exp_element **pc,
1701 struct agent_expr *ax, struct axs_value *value)
1703 struct axs_value value1;
1705 /* We don't want to turn this into an rvalue, so no conversions
1707 gen_expr (exp, pc, ax, &value1);
1708 if (value1.kind != axs_lvalue_memory)
1709 error (_("Left operand of `@' must be an object in memory."));
1711 /* Evaluate the length; it had better be a constant. */
1713 struct value *v = const_expr (pc);
1717 error (_("Right operand of `@' must be a "
1718 "constant, in agent expressions."));
1719 if (TYPE_CODE (value_type (v)) != TYPE_CODE_INT)
1720 error (_("Right operand of `@' must be an integer."));
1721 length = value_as_long (v);
1723 error (_("Right operand of `@' must be positive."));
1725 /* The top of the stack is already the address of the object, so
1726 all we need to do is frob the type of the lvalue. */
1728 /* FIXME-type-allocation: need a way to free this type when we are
1731 = lookup_array_range_type (value1.type, 0, length - 1);
1733 value->kind = axs_lvalue_memory;
1734 value->type = array;
1740 /* Emit code for the `sizeof' operator.
1741 *PC should point at the start of the operand expression; we advance it
1742 to the first instruction after the operand. */
1744 gen_sizeof (struct expression *exp, union exp_element **pc,
1745 struct agent_expr *ax, struct axs_value *value,
1746 struct type *size_type)
1748 /* We don't care about the value of the operand expression; we only
1749 care about its type. However, in the current arrangement, the
1750 only way to find an expression's type is to generate code for it.
1751 So we generate code for the operand, and then throw it away,
1752 replacing it with code that simply pushes its size. */
1753 int start = ax->len;
1755 gen_expr (exp, pc, ax, value);
1757 /* Throw away the code we just generated. */
1760 ax_const_l (ax, TYPE_LENGTH (value->type));
1761 value->kind = axs_rvalue;
1762 value->type = size_type;
1766 /* Generate bytecode for a cast to TO_TYPE. Advance *PC over the
1770 gen_expr_for_cast (struct expression *exp, union exp_element **pc,
1771 struct agent_expr *ax, struct axs_value *value,
1772 struct type *to_type)
1774 enum exp_opcode op = (*pc)[0].opcode;
1776 /* Don't let symbols be handled with gen_expr because that throws an
1777 "unknown type" error for no-debug data symbols. Instead, we want
1778 the cast to reinterpret such symbols. */
1779 if (op == OP_VAR_MSYM_VALUE || op == OP_VAR_VALUE)
1781 if (op == OP_VAR_VALUE)
1783 gen_var_ref (ax, value, (*pc)[2].symbol);
1785 if (value->optimized_out)
1786 error (_("`%s' has been optimized out, cannot use"),
1787 SYMBOL_PRINT_NAME ((*pc)[2].symbol));
1790 gen_msym_var_ref (ax, value, (*pc)[2].msymbol, (*pc)[1].objfile);
1791 if (TYPE_CODE (value->type) == TYPE_CODE_ERROR)
1792 value->type = to_type;
1796 gen_expr (exp, pc, ax, value);
1797 gen_cast (ax, value, to_type);
1800 /* Generating bytecode from GDB expressions: general recursive thingy */
1803 /* A gen_expr function written by a Gen-X'er guy.
1804 Append code for the subexpression of EXPR starting at *POS_P to AX. */
1806 gen_expr (struct expression *exp, union exp_element **pc,
1807 struct agent_expr *ax, struct axs_value *value)
1809 /* Used to hold the descriptions of operand expressions. */
1810 struct axs_value value1, value2, value3;
1811 enum exp_opcode op = (*pc)[0].opcode, op2;
1812 int if1, go1, if2, go2, end;
1813 struct type *int_type = builtin_type (ax->gdbarch)->builtin_int;
1815 /* If we're looking at a constant expression, just push its value. */
1817 struct value *v = maybe_const_expr (pc);
1821 ax_const_l (ax, value_as_long (v));
1822 value->kind = axs_rvalue;
1823 value->type = check_typedef (value_type (v));
1828 /* Otherwise, go ahead and generate code for it. */
1831 /* Binary arithmetic operators. */
1839 case BINOP_SUBSCRIPT:
1840 case BINOP_BITWISE_AND:
1841 case BINOP_BITWISE_IOR:
1842 case BINOP_BITWISE_XOR:
1844 case BINOP_NOTEQUAL:
1850 gen_expr (exp, pc, ax, &value1);
1851 gen_usual_unary (ax, &value1);
1852 gen_expr_binop_rest (exp, op, pc, ax, value, &value1, &value2);
1855 case BINOP_LOGICAL_AND:
1857 /* Generate the obvious sequence of tests and jumps. */
1858 gen_expr (exp, pc, ax, &value1);
1859 gen_usual_unary (ax, &value1);
1860 if1 = ax_goto (ax, aop_if_goto);
1861 go1 = ax_goto (ax, aop_goto);
1862 ax_label (ax, if1, ax->len);
1863 gen_expr (exp, pc, ax, &value2);
1864 gen_usual_unary (ax, &value2);
1865 if2 = ax_goto (ax, aop_if_goto);
1866 go2 = ax_goto (ax, aop_goto);
1867 ax_label (ax, if2, ax->len);
1869 end = ax_goto (ax, aop_goto);
1870 ax_label (ax, go1, ax->len);
1871 ax_label (ax, go2, ax->len);
1873 ax_label (ax, end, ax->len);
1874 value->kind = axs_rvalue;
1875 value->type = int_type;
1878 case BINOP_LOGICAL_OR:
1880 /* Generate the obvious sequence of tests and jumps. */
1881 gen_expr (exp, pc, ax, &value1);
1882 gen_usual_unary (ax, &value1);
1883 if1 = ax_goto (ax, aop_if_goto);
1884 gen_expr (exp, pc, ax, &value2);
1885 gen_usual_unary (ax, &value2);
1886 if2 = ax_goto (ax, aop_if_goto);
1888 end = ax_goto (ax, aop_goto);
1889 ax_label (ax, if1, ax->len);
1890 ax_label (ax, if2, ax->len);
1892 ax_label (ax, end, ax->len);
1893 value->kind = axs_rvalue;
1894 value->type = int_type;
1899 gen_expr (exp, pc, ax, &value1);
1900 gen_usual_unary (ax, &value1);
1901 /* For (A ? B : C), it's easiest to generate subexpression
1902 bytecodes in order, but if_goto jumps on true, so we invert
1903 the sense of A. Then we can do B by dropping through, and
1905 gen_logical_not (ax, &value1, int_type);
1906 if1 = ax_goto (ax, aop_if_goto);
1907 gen_expr (exp, pc, ax, &value2);
1908 gen_usual_unary (ax, &value2);
1909 end = ax_goto (ax, aop_goto);
1910 ax_label (ax, if1, ax->len);
1911 gen_expr (exp, pc, ax, &value3);
1912 gen_usual_unary (ax, &value3);
1913 ax_label (ax, end, ax->len);
1914 /* This is arbitary - what if B and C are incompatible types? */
1915 value->type = value2.type;
1916 value->kind = value2.kind;
1921 if ((*pc)[0].opcode == OP_INTERNALVAR)
1923 char *name = internalvar_name ((*pc)[1].internalvar);
1924 struct trace_state_variable *tsv;
1927 gen_expr (exp, pc, ax, value);
1928 tsv = find_trace_state_variable (name);
1931 ax_tsv (ax, aop_setv, tsv->number);
1933 ax_tsv (ax, aop_tracev, tsv->number);
1936 error (_("$%s is not a trace state variable, "
1937 "may not assign to it"), name);
1940 error (_("May only assign to trace state variables"));
1943 case BINOP_ASSIGN_MODIFY:
1945 op2 = (*pc)[0].opcode;
1948 if ((*pc)[0].opcode == OP_INTERNALVAR)
1950 char *name = internalvar_name ((*pc)[1].internalvar);
1951 struct trace_state_variable *tsv;
1954 tsv = find_trace_state_variable (name);
1957 /* The tsv will be the left half of the binary operation. */
1958 ax_tsv (ax, aop_getv, tsv->number);
1960 ax_tsv (ax, aop_tracev, tsv->number);
1961 /* Trace state variables are always 64-bit integers. */
1962 value1.kind = axs_rvalue;
1963 value1.type = builtin_type (ax->gdbarch)->builtin_long_long;
1964 /* Now do right half of expression. */
1965 gen_expr_binop_rest (exp, op2, pc, ax, value, &value1, &value2);
1966 /* We have a result of the binary op, set the tsv. */
1967 ax_tsv (ax, aop_setv, tsv->number);
1969 ax_tsv (ax, aop_tracev, tsv->number);
1972 error (_("$%s is not a trace state variable, "
1973 "may not assign to it"), name);
1976 error (_("May only assign to trace state variables"));
1979 /* Note that we need to be a little subtle about generating code
1980 for comma. In C, we can do some optimizations here because
1981 we know the left operand is only being evaluated for effect.
1982 However, if the tracing kludge is in effect, then we always
1983 need to evaluate the left hand side fully, so that all the
1984 variables it mentions get traced. */
1987 gen_expr (exp, pc, ax, &value1);
1988 /* Don't just dispose of the left operand. We might be tracing,
1989 in which case we want to emit code to trace it if it's an
1991 gen_traced_pop (ax, &value1);
1992 gen_expr (exp, pc, ax, value);
1993 /* It's the consumer's responsibility to trace the right operand. */
1996 case OP_LONG: /* some integer constant */
1998 struct type *type = (*pc)[1].type;
1999 LONGEST k = (*pc)[2].longconst;
2002 gen_int_literal (ax, value, k, type);
2007 gen_var_ref (ax, value, (*pc)[2].symbol);
2009 if (value->optimized_out)
2010 error (_("`%s' has been optimized out, cannot use"),
2011 SYMBOL_PRINT_NAME ((*pc)[2].symbol));
2013 if (TYPE_CODE (value->type) == TYPE_CODE_ERROR)
2014 error_unknown_type (SYMBOL_PRINT_NAME ((*pc)[2].symbol));
2019 case OP_VAR_MSYM_VALUE:
2020 gen_msym_var_ref (ax, value, (*pc)[2].msymbol, (*pc)[1].objfile);
2022 if (TYPE_CODE (value->type) == TYPE_CODE_ERROR)
2023 error_unknown_type (MSYMBOL_PRINT_NAME ((*pc)[2].msymbol));
2030 const char *name = &(*pc)[2].string;
2033 (*pc) += 4 + BYTES_TO_EXP_ELEM ((*pc)[1].longconst + 1);
2034 reg = user_reg_map_name_to_regnum (ax->gdbarch, name, strlen (name));
2036 internal_error (__FILE__, __LINE__,
2037 _("Register $%s not available"), name);
2038 /* No support for tracing user registers yet. */
2039 if (reg >= gdbarch_num_cooked_regs (ax->gdbarch))
2040 error (_("'%s' is a user-register; "
2041 "GDB cannot yet trace user-register contents."),
2043 value->kind = axs_lvalue_register;
2045 value->type = register_type (ax->gdbarch, reg);
2049 case OP_INTERNALVAR:
2051 struct internalvar *var = (*pc)[1].internalvar;
2052 const char *name = internalvar_name (var);
2053 struct trace_state_variable *tsv;
2056 tsv = find_trace_state_variable (name);
2059 ax_tsv (ax, aop_getv, tsv->number);
2061 ax_tsv (ax, aop_tracev, tsv->number);
2062 /* Trace state variables are always 64-bit integers. */
2063 value->kind = axs_rvalue;
2064 value->type = builtin_type (ax->gdbarch)->builtin_long_long;
2066 else if (! compile_internalvar_to_ax (var, ax, value))
2067 error (_("$%s is not a trace state variable; GDB agent "
2068 "expressions cannot use convenience variables."), name);
2072 /* Weirdo operator: see comments for gen_repeat for details. */
2074 /* Note that gen_repeat handles its own argument evaluation. */
2076 gen_repeat (exp, pc, ax, value);
2081 struct type *type = (*pc)[1].type;
2084 gen_expr_for_cast (exp, pc, ax, value, type);
2088 case UNOP_CAST_TYPE:
2095 offset = *pc - exp->elts;
2096 val = evaluate_subexp (NULL, exp, &offset, EVAL_AVOID_SIDE_EFFECTS);
2097 type = value_type (val);
2098 *pc = &exp->elts[offset];
2099 gen_expr_for_cast (exp, pc, ax, value, type);
2105 struct type *type = check_typedef ((*pc)[1].type);
2108 gen_expr (exp, pc, ax, value);
2110 /* If we have an axs_rvalue or an axs_lvalue_memory, then we
2111 already have the right value on the stack. For
2112 axs_lvalue_register, we must convert. */
2113 if (value->kind == axs_lvalue_register)
2114 require_rvalue (ax, value);
2117 value->kind = axs_lvalue_memory;
2121 case UNOP_MEMVAL_TYPE:
2128 offset = *pc - exp->elts;
2129 val = evaluate_subexp (NULL, exp, &offset, EVAL_AVOID_SIDE_EFFECTS);
2130 type = value_type (val);
2131 *pc = &exp->elts[offset];
2133 gen_expr (exp, pc, ax, value);
2135 /* If we have an axs_rvalue or an axs_lvalue_memory, then we
2136 already have the right value on the stack. For
2137 axs_lvalue_register, we must convert. */
2138 if (value->kind == axs_lvalue_register)
2139 require_rvalue (ax, value);
2142 value->kind = axs_lvalue_memory;
2148 /* + FOO is equivalent to 0 + FOO, which can be optimized. */
2149 gen_expr (exp, pc, ax, value);
2150 gen_usual_unary (ax, value);
2155 /* -FOO is equivalent to 0 - FOO. */
2156 gen_int_literal (ax, &value1, 0,
2157 builtin_type (ax->gdbarch)->builtin_int);
2158 gen_usual_unary (ax, &value1); /* shouldn't do much */
2159 gen_expr (exp, pc, ax, &value2);
2160 gen_usual_unary (ax, &value2);
2161 gen_usual_arithmetic (ax, &value1, &value2);
2162 gen_binop (ax, value, &value1, &value2, aop_sub, aop_sub, 1, "negation");
2165 case UNOP_LOGICAL_NOT:
2167 gen_expr (exp, pc, ax, value);
2168 gen_usual_unary (ax, value);
2169 gen_logical_not (ax, value, int_type);
2172 case UNOP_COMPLEMENT:
2174 gen_expr (exp, pc, ax, value);
2175 gen_usual_unary (ax, value);
2176 gen_integral_promotions (ax, value);
2177 gen_complement (ax, value);
2182 gen_expr (exp, pc, ax, value);
2183 gen_usual_unary (ax, value);
2184 if (!pointer_type (value->type))
2185 error (_("Argument of unary `*' is not a pointer."));
2191 gen_expr (exp, pc, ax, value);
2192 gen_address_of (value);
2197 /* Notice that gen_sizeof handles its own operand, unlike most
2198 of the other unary operator functions. This is because we
2199 have to throw away the code we generate. */
2200 gen_sizeof (exp, pc, ax, value,
2201 builtin_type (ax->gdbarch)->builtin_int);
2204 case STRUCTOP_STRUCT:
2207 int length = (*pc)[1].longconst;
2208 char *name = &(*pc)[2].string;
2210 (*pc) += 4 + BYTES_TO_EXP_ELEM (length + 1);
2211 gen_expr (exp, pc, ax, value);
2212 if (op == STRUCTOP_STRUCT)
2213 gen_struct_ref (ax, value, name, ".", "structure or union");
2214 else if (op == STRUCTOP_PTR)
2215 gen_struct_ref (ax, value, name, "->",
2216 "pointer to a structure or union");
2218 /* If this `if' chain doesn't handle it, then the case list
2219 shouldn't mention it, and we shouldn't be here. */
2220 internal_error (__FILE__, __LINE__,
2221 _("gen_expr: unhandled struct case"));
2227 struct symbol *sym, *func;
2228 const struct block *b;
2229 const struct language_defn *lang;
2231 b = block_for_pc (ax->scope);
2232 func = block_linkage_function (b);
2233 lang = language_def (SYMBOL_LANGUAGE (func));
2235 sym = lookup_language_this (lang, b).symbol;
2237 error (_("no `%s' found"), lang->la_name_of_this);
2239 gen_var_ref (ax, value, sym);
2241 if (value->optimized_out)
2242 error (_("`%s' has been optimized out, cannot use"),
2243 SYMBOL_PRINT_NAME (sym));
2251 struct type *type = (*pc)[1].type;
2252 int length = longest_to_int ((*pc)[2].longconst);
2253 char *name = &(*pc)[3].string;
2256 found = gen_aggregate_elt_ref (ax, value, type, name);
2258 error (_("There is no field named %s"), name);
2259 (*pc) += 5 + BYTES_TO_EXP_ELEM (length + 1);
2266 error (_("Attempt to use a type name as an expression."));
2269 error (_("Unsupported operator %s (%d) in expression."),
2270 op_name (exp, op), op);
2274 /* This handles the middle-to-right-side of code generation for binary
2275 expressions, which is shared between regular binary operations and
2276 assign-modify (+= and friends) expressions. */
2279 gen_expr_binop_rest (struct expression *exp,
2280 enum exp_opcode op, union exp_element **pc,
2281 struct agent_expr *ax, struct axs_value *value,
2282 struct axs_value *value1, struct axs_value *value2)
2284 struct type *int_type = builtin_type (ax->gdbarch)->builtin_int;
2286 gen_expr (exp, pc, ax, value2);
2287 gen_usual_unary (ax, value2);
2288 gen_usual_arithmetic (ax, value1, value2);
2292 if (TYPE_CODE (value1->type) == TYPE_CODE_INT
2293 && pointer_type (value2->type))
2295 /* Swap the values and proceed normally. */
2296 ax_simple (ax, aop_swap);
2297 gen_ptradd (ax, value, value2, value1);
2299 else if (pointer_type (value1->type)
2300 && TYPE_CODE (value2->type) == TYPE_CODE_INT)
2301 gen_ptradd (ax, value, value1, value2);
2303 gen_binop (ax, value, value1, value2,
2304 aop_add, aop_add, 1, "addition");
2307 if (pointer_type (value1->type)
2308 && TYPE_CODE (value2->type) == TYPE_CODE_INT)
2309 gen_ptrsub (ax,value, value1, value2);
2310 else if (pointer_type (value1->type)
2311 && pointer_type (value2->type))
2312 /* FIXME --- result type should be ptrdiff_t */
2313 gen_ptrdiff (ax, value, value1, value2,
2314 builtin_type (ax->gdbarch)->builtin_long);
2316 gen_binop (ax, value, value1, value2,
2317 aop_sub, aop_sub, 1, "subtraction");
2320 gen_binop (ax, value, value1, value2,
2321 aop_mul, aop_mul, 1, "multiplication");
2324 gen_binop (ax, value, value1, value2,
2325 aop_div_signed, aop_div_unsigned, 1, "division");
2328 gen_binop (ax, value, value1, value2,
2329 aop_rem_signed, aop_rem_unsigned, 1, "remainder");
2332 gen_binop (ax, value, value1, value2,
2333 aop_lsh, aop_lsh, 1, "left shift");
2336 gen_binop (ax, value, value1, value2,
2337 aop_rsh_signed, aop_rsh_unsigned, 1, "right shift");
2339 case BINOP_SUBSCRIPT:
2343 if (binop_types_user_defined_p (op, value1->type, value2->type))
2345 error (_("cannot subscript requested type: "
2346 "cannot call user defined functions"));
2350 /* If the user attempts to subscript something that is not
2351 an array or pointer type (like a plain int variable for
2352 example), then report this as an error. */
2353 type = check_typedef (value1->type);
2354 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2355 && TYPE_CODE (type) != TYPE_CODE_PTR)
2357 if (TYPE_NAME (type))
2358 error (_("cannot subscript something of type `%s'"),
2361 error (_("cannot subscript requested type"));
2365 if (!is_integral_type (value2->type))
2366 error (_("Argument to arithmetic operation "
2367 "not a number or boolean."));
2369 gen_ptradd (ax, value, value1, value2);
2373 case BINOP_BITWISE_AND:
2374 gen_binop (ax, value, value1, value2,
2375 aop_bit_and, aop_bit_and, 0, "bitwise and");
2378 case BINOP_BITWISE_IOR:
2379 gen_binop (ax, value, value1, value2,
2380 aop_bit_or, aop_bit_or, 0, "bitwise or");
2383 case BINOP_BITWISE_XOR:
2384 gen_binop (ax, value, value1, value2,
2385 aop_bit_xor, aop_bit_xor, 0, "bitwise exclusive-or");
2389 gen_equal (ax, value, value1, value2, int_type);
2392 case BINOP_NOTEQUAL:
2393 gen_equal (ax, value, value1, value2, int_type);
2394 gen_logical_not (ax, value, int_type);
2398 gen_less (ax, value, value1, value2, int_type);
2402 ax_simple (ax, aop_swap);
2403 gen_less (ax, value, value1, value2, int_type);
2407 ax_simple (ax, aop_swap);
2408 gen_less (ax, value, value1, value2, int_type);
2409 gen_logical_not (ax, value, int_type);
2413 gen_less (ax, value, value1, value2, int_type);
2414 gen_logical_not (ax, value, int_type);
2418 /* We should only list operators in the outer case statement
2419 that we actually handle in the inner case statement. */
2420 internal_error (__FILE__, __LINE__,
2421 _("gen_expr: op case sets don't match"));
2426 /* Given a single variable and a scope, generate bytecodes to trace
2427 its value. This is for use in situations where we have only a
2428 variable's name, and no parsed expression; for instance, when the
2429 name comes from a list of local variables of a function. */
2432 gen_trace_for_var (CORE_ADDR scope, struct gdbarch *gdbarch,
2433 struct symbol *var, int trace_string)
2435 agent_expr_up ax (new agent_expr (gdbarch, scope));
2436 struct axs_value value;
2439 ax->trace_string = trace_string;
2440 gen_var_ref (ax.get (), &value, var);
2442 /* If there is no actual variable to trace, flag it by returning
2443 an empty agent expression. */
2444 if (value.optimized_out)
2445 return agent_expr_up ();
2447 /* Make sure we record the final object, and get rid of it. */
2448 gen_traced_pop (ax.get (), &value);
2450 /* Oh, and terminate. */
2451 ax_simple (ax.get (), aop_end);
2456 /* Generating bytecode from GDB expressions: driver */
2458 /* Given a GDB expression EXPR, return bytecode to trace its value.
2459 The result will use the `trace' and `trace_quick' bytecodes to
2460 record the value of all memory touched by the expression. The
2461 caller can then use the ax_reqs function to discover which
2462 registers it relies upon. */
2465 gen_trace_for_expr (CORE_ADDR scope, struct expression *expr,
2468 agent_expr_up ax (new agent_expr (expr->gdbarch, scope));
2469 union exp_element *pc;
2470 struct axs_value value;
2474 ax->trace_string = trace_string;
2475 value.optimized_out = 0;
2476 gen_expr (expr, &pc, ax.get (), &value);
2478 /* Make sure we record the final object, and get rid of it. */
2479 gen_traced_pop (ax.get (), &value);
2481 /* Oh, and terminate. */
2482 ax_simple (ax.get (), aop_end);
2487 /* Given a GDB expression EXPR, return a bytecode sequence that will
2488 evaluate and return a result. The bytecodes will do a direct
2489 evaluation, using the current data on the target, rather than
2490 recording blocks of memory and registers for later use, as
2491 gen_trace_for_expr does. The generated bytecode sequence leaves
2492 the result of expression evaluation on the top of the stack. */
2495 gen_eval_for_expr (CORE_ADDR scope, struct expression *expr)
2497 agent_expr_up ax (new agent_expr (expr->gdbarch, scope));
2498 union exp_element *pc;
2499 struct axs_value value;
2503 value.optimized_out = 0;
2504 gen_expr (expr, &pc, ax.get (), &value);
2506 require_rvalue (ax.get (), &value);
2508 /* Oh, and terminate. */
2509 ax_simple (ax.get (), aop_end);
2515 gen_trace_for_return_address (CORE_ADDR scope, struct gdbarch *gdbarch,
2518 agent_expr_up ax (new agent_expr (gdbarch, scope));
2519 struct axs_value value;
2522 ax->trace_string = trace_string;
2524 gdbarch_gen_return_address (gdbarch, ax.get (), &value, scope);
2526 /* Make sure we record the final object, and get rid of it. */
2527 gen_traced_pop (ax.get (), &value);
2529 /* Oh, and terminate. */
2530 ax_simple (ax.get (), aop_end);
2535 /* Given a collection of printf-style arguments, generate code to
2536 evaluate the arguments and pass everything to a special
2540 gen_printf (CORE_ADDR scope, struct gdbarch *gdbarch,
2541 CORE_ADDR function, LONGEST channel,
2542 const char *format, int fmtlen,
2543 int nargs, struct expression **exprs)
2545 agent_expr_up ax (new agent_expr (gdbarch, scope));
2546 union exp_element *pc;
2547 struct axs_value value;
2550 /* We're computing values, not doing side effects. */
2553 /* Evaluate and push the args on the stack in reverse order,
2554 for simplicity of collecting them on the target side. */
2555 for (tem = nargs - 1; tem >= 0; --tem)
2557 pc = exprs[tem]->elts;
2558 value.optimized_out = 0;
2559 gen_expr (exprs[tem], &pc, ax.get (), &value);
2560 require_rvalue (ax.get (), &value);
2563 /* Push function and channel. */
2564 ax_const_l (ax.get (), channel);
2565 ax_const_l (ax.get (), function);
2567 /* Issue the printf bytecode proper. */
2568 ax_simple (ax.get (), aop_printf);
2569 ax_raw_byte (ax.get (), nargs);
2570 ax_string (ax.get (), format, fmtlen);
2572 /* And terminate. */
2573 ax_simple (ax.get (), aop_end);
2579 agent_eval_command_one (const char *exp, int eval, CORE_ADDR pc)
2582 int trace_string = 0;
2587 exp = decode_agent_options (exp, &trace_string);
2590 agent_expr_up agent;
2593 if (!eval && strcmp (arg, "$_ret") == 0)
2595 agent = gen_trace_for_return_address (pc, get_current_arch (),
2600 expression_up expr = parse_exp_1 (&arg, pc, block_for_pc (pc), 0);
2604 gdb_assert (trace_string == 0);
2605 agent = gen_eval_for_expr (pc, expr.get ());
2608 agent = gen_trace_for_expr (pc, expr.get (), trace_string);
2611 ax_reqs (agent.get ());
2612 ax_print (gdb_stdout, agent.get ());
2614 /* It would be nice to call ax_reqs here to gather some general info
2615 about the expression, and then print out the result. */
2621 agent_command_1 (const char *exp, int eval)
2623 /* We don't deal with overlay debugging at the moment. We need to
2624 think more carefully about this. If you copy this code into
2625 another command, change the error message; the user shouldn't
2626 have to know anything about agent expressions. */
2627 if (overlay_debugging)
2628 error (_("GDB can't do agent expression translation with overlays."));
2631 error_no_arg (_("expression to translate"));
2633 if (check_for_argument (&exp, "-at", sizeof ("-at") - 1))
2635 struct linespec_result canonical;
2637 event_location_up location
2638 = new_linespec_location (&exp, symbol_name_match_type::WILD);
2639 decode_line_full (location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
2640 NULL, 0, &canonical,
2642 exp = skip_spaces (exp);
2646 exp = skip_spaces (exp);
2648 for (const auto &lsal : canonical.lsals)
2649 for (const auto &sal : lsal.sals)
2650 agent_eval_command_one (exp, eval, sal.pc);
2653 agent_eval_command_one (exp, eval, get_frame_pc (get_current_frame ()));
2659 agent_command (const char *exp, int from_tty)
2661 agent_command_1 (exp, 0);
2664 /* Parse the given expression, compile it into an agent expression
2665 that does direct evaluation, and display the resulting
2669 agent_eval_command (const char *exp, int from_tty)
2671 agent_command_1 (exp, 1);
2674 /* Parse the given expression, compile it into an agent expression
2675 that does a printf, and display the resulting expression. */
2678 maint_agent_printf_command (const char *cmdrest, int from_tty)
2680 struct frame_info *fi = get_current_frame (); /* need current scope */
2681 const char *format_start, *format_end;
2683 /* We don't deal with overlay debugging at the moment. We need to
2684 think more carefully about this. If you copy this code into
2685 another command, change the error message; the user shouldn't
2686 have to know anything about agent expressions. */
2687 if (overlay_debugging)
2688 error (_("GDB can't do agent expression translation with overlays."));
2691 error_no_arg (_("expression to translate"));
2693 cmdrest = skip_spaces (cmdrest);
2695 if (*cmdrest++ != '"')
2696 error (_("Must start with a format string."));
2698 format_start = cmdrest;
2700 format_pieces fpieces (&cmdrest);
2702 format_end = cmdrest;
2704 if (*cmdrest++ != '"')
2705 error (_("Bad format string, non-terminated '\"'."));
2707 cmdrest = skip_spaces (cmdrest);
2709 if (*cmdrest != ',' && *cmdrest != 0)
2710 error (_("Invalid argument syntax"));
2712 if (*cmdrest == ',')
2714 cmdrest = skip_spaces (cmdrest);
2716 std::vector<struct expression *> argvec;
2717 while (*cmdrest != '\0')
2722 expression_up expr = parse_exp_1 (&cmd1, 0, (struct block *) 0, 1);
2723 argvec.push_back (expr.release ());
2725 if (*cmdrest == ',')
2727 /* else complain? */
2731 agent_expr_up agent = gen_printf (get_frame_pc (fi), get_current_arch (),
2733 format_start, format_end - format_start,
2734 argvec.size (), argvec.data ());
2735 ax_reqs (agent.get ());
2736 ax_print (gdb_stdout, agent.get ());
2738 /* It would be nice to call ax_reqs here to gather some general info
2739 about the expression, and then print out the result. */
2744 /* Initialization code. */
2747 _initialize_ax_gdb (void)
2749 add_cmd ("agent", class_maintenance, agent_command,
2751 Translate an expression into remote agent bytecode for tracing.\n\
2752 Usage: maint agent [-at LOCATION,] EXPRESSION\n\
2753 If -at is given, generate remote agent bytecode for this location.\n\
2754 If not, generate remote agent bytecode for current frame pc address."),
2757 add_cmd ("agent-eval", class_maintenance, agent_eval_command,
2759 Translate an expression into remote agent bytecode for evaluation.\n\
2760 Usage: maint agent-eval [-at LOCATION,] EXPRESSION\n\
2761 If -at is given, generate remote agent bytecode for this location.\n\
2762 If not, generate remote agent bytecode for current frame pc address."),
2765 add_cmd ("agent-printf", class_maintenance, maint_agent_printf_command,
2766 _("Translate an expression into remote "
2767 "agent bytecode for evaluation and display the bytecodes."),