GDB (xrefs)

/tmp/gdb-8.1/gdb/ax-gdb.c
Go to the documentation of this file.
1 /* GDB-specific functions for operating on agent expressions.
2
3 Copyright (C) 1998-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20 #include "defs.h"
21 #include "symtab.h"
22 #include "symfile.h"
23 #include "gdbtypes.h"
24 #include "language.h"
25 #include "value.h"
26 #include "expression.h"
27 #include "command.h"
28 #include "gdbcmd.h"
29 #include "frame.h"
30 #include "target.h"
31 #include "ax.h"
32 #include "ax-gdb.h"
33 #include "block.h"
34 #include "regcache.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"
42 #include "linespec.h"
43 #include "location.h"
44 #include "objfiles.h"
45 #include "typeprint.h"
46 #include "valprint.h"
47 #include "c-lang.h"
48
49 #include "format.h"
50
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
55 code.
56
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
63 strings.
64
65 Remember, "GBD" stands for "Great Britain, Dammit!" So be careful. */
66
67
68
69 /* Prototypes for local functions. */
70
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 */
75
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);
79
80 static void gen_traced_pop (struct agent_expr *, struct axs_value *);
81
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);
86
87
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,
93 struct symbol *var);
94
95
96 static void gen_int_literal (struct agent_expr *ax,
97 struct axs_value *value,
98 LONGEST k, struct type *type);
99
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,
126 enum agent_op op,
127 enum agent_op op_unsigned, int may_carry,
128 const char *name);
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,
142 struct type *type);
143 static void gen_struct_ref (struct agent_expr *ax,
144 struct axs_value *value,
145 const char *field,
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);
161
162
163 /* Detecting constant expressions. */
164
165 /* If the variable reference at *PC is a constant, return its value.
166 Otherwise, return zero.
167
168 Hey, Wally! How can a variable reference be a constant?
169
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
175 situation.
176
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
181 proletariat? */
182
183 static struct value *
184 const_var_ref (struct symbol *var)
185 {
186 struct type *type = SYMBOL_TYPE (var);
187
188 switch (SYMBOL_CLASS (var))
189 {
190 case LOC_CONST:
191 return value_from_longest (type, (LONGEST) SYMBOL_VALUE (var));
192
193 case LOC_LABEL:
194 return value_from_pointer (type, (CORE_ADDR) SYMBOL_VALUE_ADDRESS (var));
195
196 default:
197 return 0;
198 }
199 }
200
201
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
205 anywhere. */
206 static struct value *
207 const_expr (union exp_element **pc)
208 {
209 enum exp_opcode op = (*pc)->opcode;
210 struct value *v1;
211
212 switch (op)
213 {
214 case OP_LONG:
215 {
216 struct type *type = (*pc)[1].type;
217 LONGEST k = (*pc)[2].longconst;
218
219 (*pc) += 4;
220 return value_from_longest (type, k);
221 }
222
223 case OP_VAR_VALUE:
224 {
225 struct value *v = const_var_ref ((*pc)[2].symbol);
226
227 (*pc) += 4;
228 return v;
229 }
230
231 /* We could add more operators in here. */
232
233 case UNOP_NEG:
234 (*pc)++;
235 v1 = const_expr (pc);
236 if (v1)
237 return value_neg (v1);
238 else
239 return 0;
240
241 default:
242 return 0;
243 }
244 }
245
246
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)
251 {
252 union exp_element *tentative_pc = *pc;
253 struct value *v = const_expr (&tentative_pc);
254
255 /* If we got a value, then update the real PC. */
256 if (v)
257 *pc = tentative_pc;
258
259 return v;
260 }
261
262
263 /* Generating bytecode from GDB expressions: general assumptions */
264
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.
268
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.
275
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
281 with bignums!)
282
283 - We don't support side effects. Thus, we don't have to worry about
284 GCC's generalized lvalues, function calls, etc.
285
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.
290
291 - We assume all subexpressions have a static, unchanging type. If
292 we tried to support convenience variables, this would be a
293 problem.
294
295 - All values on the stack should always be fully zero- or
296 sign-extended.
297
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.) */
305
306
307 /* Scan for all static fields in the given class, including any base
308 classes, and generate tracing bytecodes for each. */
309
310 static void
311 gen_trace_static_fields (struct agent_expr *ax,
312 struct type *type)
313 {
314 int i, nbases = TYPE_N_BASECLASSES (type);
315 struct axs_value value;
316
317 type = check_typedef (type);
318
319 for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
320 {
321 if (field_is_static (&TYPE_FIELD (type, i)))
322 {
323 gen_static_field (ax, &value, type, i);
324 if (value.optimized_out)
325 continue;
326 switch (value.kind)
327 {
328 case axs_lvalue_memory:
329 {
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);
334 }
335 break;
336
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);
341
342 default:
343 break;
344 }
345 }
346 }
347
348 /* Now scan through base classes recursively. */
349 for (i = 0; i < nbases; i++)
350 {
351 struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
352
353 gen_trace_static_fields (ax, basetype);
354 }
355 }
356
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. */
360 static void
361 gen_traced_pop (struct agent_expr *ax, struct axs_value *value)
362 {
363 int string_trace = 0;
364 if (ax->trace_string
365 && TYPE_CODE (value->type) == TYPE_CODE_PTR
366 && c_textual_element_type (check_typedef (TYPE_TARGET_TYPE (value->type)),
367 's'))
368 string_trace = 1;
369
370 if (ax->tracing)
371 switch (value->kind)
372 {
373 case axs_rvalue:
374 if (string_trace)
375 {
376 ax_const_l (ax, ax->trace_string);
377 ax_simple (ax, aop_tracenz);
378 }
379 else
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);
383 break;
384
385 case axs_lvalue_memory:
386 {
387 /* Initialize the TYPE_LENGTH if it is a typedef. */
388 check_typedef (value->type);
389
390 if (string_trace)
391 {
392 gen_fetch (ax, value->type);
393 ax_const_l (ax, ax->trace_string);
394 ax_simple (ax, aop_tracenz);
395 }
396 else
397 {
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);
405 }
406 }
407 break;
408
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);
415
416 /* But if the register points to a string, assume the value
417 will fit on the stack and push it anyway. */
418 if (string_trace)
419 {
420 ax_reg (ax, value->u.reg);
421 ax_const_l (ax, ax->trace_string);
422 ax_simple (ax, aop_tracenz);
423 }
424 break;
425 }
426 else
427 /* If we're not tracing, just pop the value. */
428 ax_simple (ax, aop_pop);
429
430 /* To trace C++ classes with static fields stored elsewhere. */
431 if (ax->tracing
432 && (TYPE_CODE (value->type) == TYPE_CODE_STRUCT
433 || TYPE_CODE (value->type) == TYPE_CODE_UNION))
434 gen_trace_static_fields (ax, value->type);
435 }
436
437
438
439 /* Generating bytecode from GDB expressions: helper functions */
440
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. */
443 static void
444 gen_sign_extend (struct agent_expr *ax, struct type *type)
445 {
446 /* Do we need to sign-extend this? */
447 if (!TYPE_UNSIGNED (type))
448 ax_ext (ax, TYPE_LENGTH (type) * TARGET_CHAR_BIT);
449 }
450
451
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
454 needed. */
455 static void
456 gen_extend (struct agent_expr *ax, struct type *type)
457 {
458 int bits = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
459
460 /* I just had to. */
461 ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, bits));
462 }
463
464
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. */
468 static void
469 gen_fetch (struct agent_expr *ax, struct type *type)
470 {
471 if (ax->tracing)
472 {
473 /* Record the area of memory we're about to fetch. */
474 ax_trace_quick (ax, TYPE_LENGTH (type));
475 }
476
477 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
478 type = TYPE_TARGET_TYPE (type);
479
480 switch (TYPE_CODE (type))
481 {
482 case TYPE_CODE_PTR:
483 case TYPE_CODE_REF:
484 case TYPE_CODE_RVALUE_REF:
485 case TYPE_CODE_ENUM:
486 case TYPE_CODE_INT:
487 case TYPE_CODE_CHAR:
488 case TYPE_CODE_BOOL:
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))
492 {
493 case 8 / TARGET_CHAR_BIT:
494 ax_simple (ax, aop_ref8);
495 break;
496 case 16 / TARGET_CHAR_BIT:
497 ax_simple (ax, aop_ref16);
498 break;
499 case 32 / TARGET_CHAR_BIT:
500 ax_simple (ax, aop_ref32);
501 break;
502 case 64 / TARGET_CHAR_BIT:
503 ax_simple (ax, aop_ref64);
504 break;
505
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. */
510 default:
511 internal_error (__FILE__, __LINE__,
512 _("gen_fetch: strange size"));
513 }
514
515 gen_sign_extend (ax, type);
516 break;
517
518 default:
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
521 gracefully. */
522 error (_("gen_fetch: Unsupported type code `%s'."),
523 TYPE_NAME (type));
524 }
525 }
526
527
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. */
531 static void
532 gen_left_shift (struct agent_expr *ax, int distance)
533 {
534 if (distance > 0)
535 {
536 ax_const_l (ax, distance);
537 ax_simple (ax, aop_lsh);
538 }
539 else if (distance < 0)
540 {
541 ax_const_l (ax, -distance);
542 ax_simple (ax, aop_rsh_unsigned);
543 }
544 }
545
546
547
548 /* Generating bytecode from GDB expressions: symbol references */
549
550 /* Generate code to push the base address of the argument portion of
551 the top stack frame. */
552 static void
553 gen_frame_args_address (struct agent_expr *ax)
554 {
555 int frame_reg;
556 LONGEST frame_offset;
557
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);
562 }
563
564
565 /* Generate code to push the base address of the locals portion of the
566 top stack frame. */
567 static void
568 gen_frame_locals_address (struct agent_expr *ax)
569 {
570 int frame_reg;
571 LONGEST frame_offset;
572
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);
577 }
578
579
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
584 thing. */
585 static void
586 gen_offset (struct agent_expr *ax, int offset)
587 {
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
590 bytecode. */
591 if (offset > 0)
592 {
593 ax_const_l (ax, offset);
594 ax_simple (ax, aop_add);
595 }
596 else if (offset < 0)
597 {
598 ax_const_l (ax, -offset);
599 ax_simple (ax, aop_sub);
600 }
601 }
602
603
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. */
607 static void
608 gen_sym_offset (struct agent_expr *ax, struct symbol *var)
609 {
610 gen_offset (ax, SYMBOL_VALUE (var));
611 }
612
613
614 /* Generate code for a variable reference to AX. The variable is the
615 symbol VAR. Set VALUE to describe the result. */
616
617 static void
618 gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var)
619 {
620 /* Dereference any typedefs. */
621 value->type = check_typedef (SYMBOL_TYPE (var));
622 value->optimized_out = 0;
623
624 if (SYMBOL_COMPUTED_OPS (var) != NULL)
625 {
626 SYMBOL_COMPUTED_OPS (var)->tracepoint_var_ref (var, ax, value);
627 return;
628 }
629
630 /* I'm imitating the code in read_var_value. */
631 switch (SYMBOL_CLASS (var))
632 {
633 case LOC_CONST: /* A constant, like an enum value. */
634 ax_const_l (ax, (LONGEST) SYMBOL_VALUE (var));
635 value->kind = axs_rvalue;
636 break;
637
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;
641 break;
642
643 case LOC_CONST_BYTES:
644 internal_error (__FILE__, __LINE__,
645 _("gen_var_ref: LOC_CONST_BYTES "
646 "symbols are not supported"));
647
648 /* Variable at a fixed location in memory. Easy. */
649 case LOC_STATIC:
650 /* Push the address of the variable. */
651 ax_const_l (ax, SYMBOL_VALUE_ADDRESS (var));
652 value->kind = axs_lvalue_memory;
653 break;
654
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;
659 break;
660
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;
668 break;
669
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;
674 break;
675
676 case LOC_TYPEDEF:
677 error (_("Cannot compute value of typedef `%s'."),
678 SYMBOL_PRINT_NAME (var));
679 break;
680
681 case LOC_BLOCK:
682 ax_const_l (ax, BLOCK_START (SYMBOL_BLOCK_VALUE (var)));
683 value->kind = axs_rvalue;
684 break;
685
686 case LOC_REGISTER:
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
689 right code. */
690 value->kind = axs_lvalue_register;
691 value->u.reg
692 = SYMBOL_REGISTER_OPS (var)->register_number (var, ax->gdbarch);
693 break;
694
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:
700 ax_reg (ax,
701 SYMBOL_REGISTER_OPS (var)->register_number (var, ax->gdbarch));
702 value->kind = axs_lvalue_memory;
703 break;
704
705 case LOC_UNRESOLVED:
706 {
707 struct bound_minimal_symbol msym
708 = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL);
709
710 if (!msym.minsym)
711 error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var));
712
713 /* Push the address of the variable. */
714 ax_const_l (ax, BMSYMBOL_VALUE_ADDRESS (msym));
715 value->kind = axs_lvalue_memory;
716 }
717 break;
718
719 case LOC_COMPUTED:
720 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
721
722 case LOC_OPTIMIZED_OUT:
723 /* Flag this, but don't say anything; leave it up to callers to
724 warn the user. */
725 value->optimized_out = 1;
726 break;
727
728 default:
729 error (_("Cannot find value of botched symbol `%s'."),
730 SYMBOL_PRINT_NAME (var));
731 break;
732 }
733 }
734
735 /* Generate code for a minimal symbol variable reference to AX. The
736 variable is the symbol MINSYM, of OBJFILE. Set VALUE to describe
737 the result. */
738
739 static void
740 gen_msym_var_ref (agent_expr *ax, axs_value *value,
741 minimal_symbol *msymbol, objfile *objf)
742 {
743 CORE_ADDR address;
744 type *t = find_minsym_type_and_address (msymbol, objf, &address);
745 value->type = t;
746 value->optimized_out = false;
747 ax_const_l (ax, address);
748 value->kind = axs_lvalue_memory;
749 }
750
751
752
753
754 /* Generating bytecode from GDB expressions: literals */
755
756 static void
757 gen_int_literal (struct agent_expr *ax, struct axs_value *value, LONGEST k,
758 struct type *type)
759 {
760 ax_const_l (ax, k);
761 value->kind = axs_rvalue;
762 value->type = check_typedef (type);
763 }
764
765
766
767 /* Generating bytecode from GDB expressions: unary conversions, casts */
768
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
771 that. */
772 void
773 require_rvalue (struct agent_expr *ax, struct axs_value *value)
774 {
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."));
783
784 switch (value->kind)
785 {
786 case axs_rvalue:
787 /* It's already an rvalue. */
788 break;
789
790 case axs_lvalue_memory:
791 /* The top of stack is the address of the object. Dereference. */
792 gen_fetch (ax, value->type);
793 break;
794
795 case axs_lvalue_register:
796 /* There's nothing on the stack, but value->u.reg is the
797 register number containing the value.
798
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);
803 break;
804 }
805
806 value->kind = axs_rvalue;
807 }
808
809
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.
814
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.
819
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. */
825
826 static void
827 gen_usual_unary (struct agent_expr *ax, struct axs_value *value)
828 {
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? */
832
833 /* Some types require special handling. */
834 switch (TYPE_CODE (value->type))
835 {
836 /* Functions get converted to a pointer to the function. */
837 case TYPE_CODE_FUNC:
838 value->type = lookup_pointer_type (value->type);
839 value->kind = axs_rvalue; /* Should always be true, but just in case. */
840 break;
841
842 /* Arrays get converted to a pointer to their first element, and
843 are no longer an lvalue. */
844 case TYPE_CODE_ARRAY:
845 {
846 struct type *elements = TYPE_TARGET_TYPE (value->type);
847
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. */
852 }
853 break;
854
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:
859 return;
860 }
861
862 /* If the value is an lvalue, dereference it. */
863 require_rvalue (ax, value);
864 }
865
866
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. */
869 static int
870 type_wider_than (struct type *type1, struct type *type2)
871 {
872 return (TYPE_LENGTH (type1) > TYPE_LENGTH (type2)
873 || (TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
874 && TYPE_UNSIGNED (type1)
875 && !TYPE_UNSIGNED (type2)));
876 }
877
878
879 /* Return the "wider" of the two types TYPE1 and TYPE2. */
880 static struct type *
881 max_type (struct type *type1, struct type *type2)
882 {
883 return type_wider_than (type1, type2) ? type1 : type2;
884 }
885
886
887 /* Generate code to convert a scalar value of type FROM to type TO. */
888 static void
889 gen_conversion (struct agent_expr *ax, struct type *from, struct type *to)
890 {
891 /* Perhaps there is a more graceful way to state these rules. */
892
893 /* If we're converting to a narrower type, then we need to clear out
894 the upper bits. */
895 if (TYPE_LENGTH (to) < TYPE_LENGTH (from))
896 gen_extend (ax, to);
897
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))
901 {
902 if (TYPE_UNSIGNED (from) != TYPE_UNSIGNED (to))
903 gen_extend (ax, to);
904 }
905
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))
909 {
910 if (TYPE_UNSIGNED (to))
911 gen_extend (ax, to);
912 }
913 }
914
915
916 /* Return non-zero iff the type FROM will require any bytecodes to be
917 emitted to be converted to the type TO. */
918 static int
919 is_nontrivial_conversion (struct type *from, struct type *to)
920 {
921 agent_expr_up ax (new agent_expr (NULL, 0));
922 int nontrivial;
923
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
929 gen_conversion. */
930 gen_conversion (ax.get (), from, to);
931 nontrivial = ax->len > 0;
932 return nontrivial;
933 }
934
935
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. */
941 static void
942 gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1,
943 struct axs_value *value2)
944 {
945 /* Do the usual binary conversions. */
946 if (TYPE_CODE (value1->type) == TYPE_CODE_INT
947 && TYPE_CODE (value2->type) == TYPE_CODE_INT)
948 {
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));
956
957 /* Deal with value2, on the top of the stack. */
958 gen_conversion (ax, value2->type, target);
959
960 /* Deal with value1, not on the top of the stack. Don't
961 generate the `swap' instructions if we're not actually going
962 to do anything. */
963 if (is_nontrivial_conversion (value1->type, target))
964 {
965 ax_simple (ax, aop_swap);
966 gen_conversion (ax, value1->type, target);
967 ax_simple (ax, aop_swap);
968 }
969
970 value1->type = value2->type = check_typedef (target);
971 }
972 }
973
974
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. */
978 static void
979 gen_integral_promotions (struct agent_expr *ax, struct axs_value *value)
980 {
981 const struct builtin_type *builtin = builtin_type (ax->gdbarch);
982
983 if (!type_wider_than (value->type, builtin->builtin_int))
984 {
985 gen_conversion (ax, value->type, builtin->builtin_int);
986 value->type = builtin->builtin_int;
987 }
988 else if (!type_wider_than (value->type, builtin->builtin_unsigned_int))
989 {
990 gen_conversion (ax, value->type, builtin->builtin_unsigned_int);
991 value->type = builtin->builtin_unsigned_int;
992 }
993 }
994
995
996 /* Generate code for a cast to TYPE. */
997 static void
998 gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type)
999 {
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);
1005
1006 switch (TYPE_CODE (type))
1007 {
1008 case TYPE_CODE_PTR:
1009 case TYPE_CODE_REF:
1010 case TYPE_CODE_RVALUE_REF:
1011 /* It's implementation-defined, and I'll bet this is what GCC
1012 does. */
1013 break;
1014
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."));
1020
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
1027 this? */
1028 break;
1029
1030 case TYPE_CODE_INT:
1031 gen_conversion (ax, value->type, type);
1032 break;
1033
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. */
1039 break;
1040
1041 default:
1042 error (_("Casts to requested type are not yet implemented."));
1043 }
1044
1045 value->type = type;
1046 }
1047
1048
1049
1050 /* Generating bytecode from GDB expressions: arithmetic */
1051
1052 /* Scale the integer on the top of the stack by the size of the target
1053 of the pointer type TYPE. */
1054 static void
1055 gen_scale (struct agent_expr *ax, enum agent_op op, struct type *type)
1056 {
1057 struct type *element = TYPE_TARGET_TYPE (type);
1058
1059 if (TYPE_LENGTH (element) != 1)
1060 {
1061 ax_const_l (ax, TYPE_LENGTH (element));
1062 ax_simple (ax, op);
1063 }
1064 }
1065
1066
1067 /* Generate code for pointer arithmetic PTR + INT. */
1068 static void
1069 gen_ptradd (struct agent_expr *ax, struct axs_value *value,
1070 struct axs_value *value1, struct axs_value *value2)
1071 {
1072 gdb_assert (pointer_type (value1->type));
1073 gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_INT);
1074
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;
1080 }
1081
1082
1083 /* Generate code for pointer arithmetic PTR - INT. */
1084 static void
1085 gen_ptrsub (struct agent_expr *ax, struct axs_value *value,
1086 struct axs_value *value1, struct axs_value *value2)
1087 {
1088 gdb_assert (pointer_type (value1->type));
1089 gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_INT);
1090
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;
1096 }
1097
1098
1099 /* Generate code for pointer arithmetic PTR - PTR. */
1100 static void
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)
1104 {
1105 gdb_assert (pointer_type (value1->type));
1106 gdb_assert (pointer_type (value2->type));
1107
1108 if (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type))
1109 != TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type)))
1110 error (_("\
1111 First argument of `-' is a pointer, but second argument is neither\n\
1112 an integer nor a pointer of the same type."));
1113
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;
1118 }
1119
1120 static void
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)
1124 {
1125 if (pointer_type (value1->type) || pointer_type (value2->type))
1126 ax_simple (ax, aop_equal);
1127 else
1128 gen_binop (ax, value, value1, value2,
1129 aop_equal, aop_equal, 0, "equal");
1130 value->type = result_type;
1131 value->kind = axs_rvalue;
1132 }
1133
1134 static void
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)
1138 {
1139 if (pointer_type (value1->type) || pointer_type (value2->type))
1140 ax_simple (ax, aop_less_unsigned);
1141 else
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;
1146 }
1147
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 */
1154 static void
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)
1159 {
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);
1164
1165 ax_simple (ax,
1166 TYPE_UNSIGNED (value1->type) ? op_unsigned : op);
1167 if (may_carry)
1168 gen_extend (ax, value1->type); /* catch overflow */
1169 value->type = value1->type;
1170 value->kind = axs_rvalue;
1171 }
1172
1173
1174 static void
1175 gen_logical_not (struct agent_expr *ax, struct axs_value *value,
1176 struct type *result_type)
1177 {
1178 if (TYPE_CODE (value->type) != TYPE_CODE_INT
1179 && TYPE_CODE (value->type) != TYPE_CODE_PTR)
1180 error (_("Invalid type of operand to `!'."));
1181
1182 ax_simple (ax, aop_log_not);
1183 value->type = result_type;
1184 }
1185
1186
1187 static void
1188 gen_complement (struct agent_expr *ax, struct axs_value *value)
1189 {
1190 if (TYPE_CODE (value->type) != TYPE_CODE_INT)
1191 error (_("Invalid type of operand to `~'."));
1192
1193 ax_simple (ax, aop_bit_not);
1194 gen_extend (ax, value->type);
1195 }
1196
1197
1198
1199 /* Generating bytecode from GDB expressions: * & . -> @ sizeof */
1200
1201 /* Dereference the value on the top of the stack. */
1202 static void
1203 gen_deref (struct axs_value *value)
1204 {
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"));
1210
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);
1221 }
1222
1223
1224 /* Produce the address of the lvalue on the top of the stack. */
1225 static void
1226 gen_address_of (struct axs_value *value)
1227 {
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
1233 change the type. */
1234 value->type = lookup_pointer_type (value->type);
1235 else
1236 switch (value->kind)
1237 {
1238 case axs_rvalue:
1239 error (_("Operand of `&' is an rvalue, which has no address."));
1240
1241 case axs_lvalue_register:
1242 error (_("Operand of `&' is in a register, and has no address."));
1243
1244 case axs_lvalue_memory:
1245 value->kind = axs_rvalue;
1246 value->type = lookup_pointer_type (value->type);
1247 break;
1248 }
1249 }
1250
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
1254 structure. */
1255 static void
1256 gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value,
1257 struct type *type, int start, int end)
1258 {
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]));
1263
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.
1268
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:
1272 addr
1273 For the first fetch, we duplicate the address
1274 addr addr
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:
1278 addr frag1
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. */
1289
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)
1294 / TARGET_CHAR_BIT)
1295 * TARGET_CHAR_BIT);
1296
1297 /* current bit offset within the structure */
1298 int offset;
1299
1300 /* The index in ops of the opcode we're considering. */
1301 int op;
1302
1303 /* The number of fragments we generated in the process. Probably
1304 equal to the number of `one' bits in bytesize, but who cares? */
1305 int fragment_count;
1306
1307 /* Dereference any typedefs. */
1308 type = check_typedef (type);
1309
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"));
1314
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;
1318 fragment_count = 0;
1319 for (op = num_ops - 1; op >= 0; op--)
1320 {
1321 /* number of bits that ops[op] would fetch */
1322 int op_size = 8 << op;
1323
1324 /* The stack at this point, from bottom to top, contains zero or
1325 more fragments, then the address. */
1326
1327 /* Does this fetch fit within the bitfield? */
1328 if (offset + op_size <= bound_end)
1329 {
1330 /* Is this the last fragment? */
1331 int last_frag = (offset + op_size == bound_end);
1332
1333 if (!last_frag)
1334 ax_simple (ax, aop_dup); /* keep a copy of the address */
1335
1336 /* Add the offset. */
1337 gen_offset (ax, offset / TARGET_CHAR_BIT);
1338
1339 if (ax->tracing)
1340 {
1341 /* Record the area of memory we're about to fetch. */
1342 ax_trace_quick (ax, op_size / TARGET_CHAR_BIT);
1343 }
1344
1345 /* Perform the fetch. */
1346 ax_simple (ax, ops[op]);
1347
1348 /* Shift the bits we have to their proper position.
1349 gen_left_shift will generate right shifts when the operand
1350 is negative.
1351
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
1356 ^ ^ ^ ^
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
1360 value!
1361
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
1366 ^ ^ ^ ^ ^
1367 bit number 48 32 16 4 0
1368
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.
1372
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));
1384 else
1385 gen_left_shift (ax, offset - start);
1386
1387 if (!last_frag)
1388 /* Bring the copy of the address up to the top. */
1389 ax_simple (ax, aop_swap);
1390
1391 offset += op_size;
1392 fragment_count++;
1393 }
1394 }
1395
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);
1400
1401 /* Sign- or zero-extend the value as appropriate. */
1402 ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, end - start));
1403
1404 /* This is *not* an lvalue. Ugh. */
1405 value->kind = axs_rvalue;
1406 value->type = type;
1407 }
1408
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. */
1413
1414 static void
1415 gen_primitive_field (struct agent_expr *ax, struct axs_value *value,
1416 int offset, int fieldno, struct type *type)
1417 {
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)));
1426 else
1427 {
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);
1432 }
1433 }
1434
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. */
1437
1438 static int
1439 gen_struct_ref_recursive (struct agent_expr *ax, struct axs_value *value,
1440 const char *field, int offset, struct type *type)
1441 {
1442 int i, rslt;
1443 int nbases = TYPE_N_BASECLASSES (type);
1444
1445 type = check_typedef (type);
1446
1447 for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
1448 {
1449 const char *this_name = TYPE_FIELD_NAME (type, i);
1450
1451 if (this_name)
1452 {
1453 if (strcmp (field, this_name) == 0)
1454 {
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)))
1460 {
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"),
1465 field);
1466 return 1;
1467 }
1468
1469 gen_primitive_field (ax, value, offset, i, type);
1470 return 1;
1471 }
1472 #if 0 /* is this right? */
1473 if (this_name[0] == '\0')
1474 internal_error (__FILE__, __LINE__,
1475 _("find_field: anonymous unions not supported"));
1476 #endif
1477 }
1478 }
1479
1480 /* Now scan through base classes recursively. */
1481 for (i = 0; i < nbases; i++)
1482 {
1483 struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
1484
1485 rslt = gen_struct_ref_recursive (ax, value, field,
1486 offset + TYPE_BASECLASS_BITPOS (type, i)
1487 / TARGET_CHAR_BIT,
1488 basetype);
1489 if (rslt)
1490 return 1;
1491 }
1492
1493 /* Not found anywhere, flag so caller can complain. */
1494 return 0;
1495 }
1496
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. */
1502 static void
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)
1506 {
1507 struct type *type;
1508 int found;
1509
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))
1514 {
1515 require_rvalue (ax, value);
1516 gen_deref (value);
1517 }
1518 type = check_typedef (value->type);
1519
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);
1525
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."));
1530
1531 /* Search through fields and base classes recursively. */
1532 found = gen_struct_ref_recursive (ax, value, field, 0, type);
1533
1534 if (!found)
1535 error (_("Couldn't find member named `%s' in struct/union/class `%s'"),
1536 field, TYPE_TAG_NAME (type));
1537 }
1538
1539 static int
1540 gen_namespace_elt (struct agent_expr *ax, struct axs_value *value,
1541 const struct type *curtype, char *name);
1542 static int
1543 gen_maybe_namespace_elt (struct agent_expr *ax, struct axs_value *value,
1544 const struct type *curtype, char *name);
1545
1546 static void
1547 gen_static_field (struct agent_expr *ax, struct axs_value *value,
1548 struct type *type, int fieldno)
1549 {
1550 if (TYPE_FIELD_LOC_KIND (type, fieldno) == FIELD_LOC_KIND_PHYSADDR)
1551 {
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;
1556 }
1557 else
1558 {
1559 const char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
1560 struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0).symbol;
1561
1562 if (sym)
1563 {
1564 gen_var_ref (ax, value, sym);
1565
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. */
1569 }
1570 else
1571 {
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;
1575 }
1576 }
1577 }
1578
1579 static int
1580 gen_struct_elt_for_reference (struct agent_expr *ax, struct axs_value *value,
1581 struct type *type, char *fieldname)
1582 {
1583 struct type *t = type;
1584 int i;
1585
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"));
1590
1591 for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
1592 {
1593 const char *t_field_name = TYPE_FIELD_NAME (t, i);
1594
1595 if (t_field_name && strcmp (t_field_name, fieldname) == 0)
1596 {
1597 if (field_is_static (&TYPE_FIELD (t, i)))
1598 {
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"),
1603 fieldname);
1604 return 1;
1605 }
1606 if (TYPE_FIELD_PACKED (t, i))
1607 error (_("pointers to bitfield members not allowed"));
1608
1609 /* FIXME we need a way to do "want_address" equivalent */
1610
1611 error (_("Cannot reference non-static field \"%s\""), fieldname);
1612 }
1613 }
1614
1615 /* FIXME add other scoped-reference cases here */
1616
1617 /* Do a last-ditch lookup. */
1618 return gen_maybe_namespace_elt (ax, value, type, fieldname);
1619 }
1620
1621 /* C++: Return the member NAME of the namespace given by the type
1622 CURTYPE. */
1623
1624 static int
1625 gen_namespace_elt (struct agent_expr *ax, struct axs_value *value,
1626 const struct type *curtype, char *name)
1627 {
1628 int found = gen_maybe_namespace_elt (ax, value, curtype, name);
1629
1630 if (!found)
1631 error (_("No symbol \"%s\" in namespace \"%s\"."),
1632 name, TYPE_TAG_NAME (curtype));
1633
1634 return found;
1635 }
1636
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). */
1642
1643 static int
1644 gen_maybe_namespace_elt (struct agent_expr *ax, struct axs_value *value,
1645 const struct type *curtype, char *name)
1646 {
1647 const char *namespace_name = TYPE_TAG_NAME (curtype);
1648 struct block_symbol sym;
1649
1650 sym = cp_lookup_symbol_namespace (namespace_name, name,
1651 block_for_pc (ax->scope),
1652 VAR_DOMAIN);
1653
1654 if (sym.symbol == NULL)
1655 return 0;
1656
1657 gen_var_ref (ax, value, sym.symbol);
1658
1659 if (value->optimized_out)
1660 error (_("`%s' has been optimized out, cannot use"),
1661 SYMBOL_PRINT_NAME (sym.symbol));
1662
1663 return 1;
1664 }
1665
1666
1667 static int
1668 gen_aggregate_elt_ref (struct agent_expr *ax, struct axs_value *value,
1669 struct type *type, char *field)
1670 {
1671 switch (TYPE_CODE (type))
1672 {
1673 case TYPE_CODE_STRUCT:
1674 case TYPE_CODE_UNION:
1675 return gen_struct_elt_for_reference (ax, value, type, field);
1676 break;
1677 case TYPE_CODE_NAMESPACE:
1678 return gen_namespace_elt (ax, value, type, field);
1679 break;
1680 default:
1681 internal_error (__FILE__, __LINE__,
1682 _("non-aggregate type in gen_aggregate_elt_ref"));
1683 }
1684
1685 return 0;
1686 }
1687
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.
1693
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. */
1699 static void
1700 gen_repeat (struct expression *exp, union exp_element **pc,
1701 struct agent_expr *ax, struct axs_value *value)
1702 {
1703 struct axs_value value1;
1704
1705 /* We don't want to turn this into an rvalue, so no conversions
1706 here. */
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."));
1710
1711 /* Evaluate the length; it had better be a constant. */
1712 {
1713 struct value *v = const_expr (pc);
1714 int length;
1715
1716 if (!v)
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);
1722 if (length <= 0)
1723 error (_("Right operand of `@' must be positive."));
1724
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. */
1727 {
1728 /* FIXME-type-allocation: need a way to free this type when we are
1729 done with it. */
1730 struct type *array
1731 = lookup_array_range_type (value1.type, 0, length - 1);
1732
1733 value->kind = axs_lvalue_memory;
1734 value->type = array;
1735 }
1736 }
1737 }
1738
1739
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. */
1743 static void
1744 gen_sizeof (struct expression *exp, union exp_element **pc,
1745 struct agent_expr *ax, struct axs_value *value,
1746 struct type *size_type)
1747 {
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;
1754
1755 gen_expr (exp, pc, ax, value);
1756
1757 /* Throw away the code we just generated. */
1758 ax->len = start;
1759
1760 ax_const_l (ax, TYPE_LENGTH (value->type));
1761 value->kind = axs_rvalue;
1762 value->type = size_type;
1763 }
1764
1765
1766 /* Generate bytecode for a cast to TO_TYPE. Advance *PC over the
1767 subexpression. */
1768
1769 static void
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)
1773 {
1774 enum exp_opcode op = (*pc)[0].opcode;
1775
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)
1780 {
1781 if (op == OP_VAR_VALUE)
1782 {
1783 gen_var_ref (ax, value, (*pc)[2].symbol);
1784
1785 if (value->optimized_out)
1786 error (_("`%s' has been optimized out, cannot use"),
1787 SYMBOL_PRINT_NAME ((*pc)[2].symbol));
1788 }
1789 else
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;
1793 (*pc) += 4;
1794 }
1795 else
1796 gen_expr (exp, pc, ax, value);
1797 gen_cast (ax, value, to_type);
1798 }
1799
1800 /* Generating bytecode from GDB expressions: general recursive thingy */
1801
1802 /* XXX: i18n */
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. */
1805 void
1806 gen_expr (struct expression *exp, union exp_element **pc,
1807 struct agent_expr *ax, struct axs_value *value)
1808 {
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;
1814
1815 /* If we're looking at a constant expression, just push its value. */
1816 {
1817 struct value *v = maybe_const_expr (pc);
1818
1819 if (v)
1820 {
1821 ax_const_l (ax, value_as_long (v));
1822 value->kind = axs_rvalue;
1823 value->type = check_typedef (value_type (v));
1824 return;
1825 }
1826 }
1827
1828 /* Otherwise, go ahead and generate code for it. */
1829 switch (op)
1830 {
1831 /* Binary arithmetic operators. */
1832 case BINOP_ADD:
1833 case BINOP_SUB:
1834 case BINOP_MUL:
1835 case BINOP_DIV:
1836 case BINOP_REM:
1837 case BINOP_LSH:
1838 case BINOP_RSH:
1839 case BINOP_SUBSCRIPT:
1840 case BINOP_BITWISE_AND:
1841 case BINOP_BITWISE_IOR:
1842 case BINOP_BITWISE_XOR:
1843 case BINOP_EQUAL:
1844 case BINOP_NOTEQUAL:
1845 case BINOP_LESS:
1846 case BINOP_GTR:
1847 case BINOP_LEQ:
1848 case BINOP_GEQ:
1849 (*pc)++;
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);
1853 break;
1854
1855 case BINOP_LOGICAL_AND:
1856 (*pc)++;
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);
1868 ax_const_l (ax, 1);
1869 end = ax_goto (ax, aop_goto);
1870 ax_label (ax, go1, ax->len);
1871 ax_label (ax, go2, ax->len);
1872 ax_const_l (ax, 0);
1873 ax_label (ax, end, ax->len);
1874 value->kind = axs_rvalue;
1875 value->type = int_type;
1876 break;
1877
1878 case BINOP_LOGICAL_OR:
1879 (*pc)++;
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);
1887 ax_const_l (ax, 0);
1888 end = ax_goto (ax, aop_goto);
1889 ax_label (ax, if1, ax->len);
1890 ax_label (ax, if2, ax->len);
1891 ax_const_l (ax, 1);
1892 ax_label (ax, end, ax->len);
1893 value->kind = axs_rvalue;
1894 value->type = int_type;
1895 break;
1896
1897 case TERNOP_COND:
1898 (*pc)++;
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
1904 jump to do C. */
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;
1917 break;
1918
1919 case BINOP_ASSIGN:
1920 (*pc)++;
1921 if ((*pc)[0].opcode == OP_INTERNALVAR)
1922 {
1923 char *name = internalvar_name ((*pc)[1].internalvar);
1924 struct trace_state_variable *tsv;
1925
1926 (*pc) += 3;
1927 gen_expr (exp, pc, ax, value);
1928 tsv = find_trace_state_variable (name);
1929 if (tsv)
1930 {
1931 ax_tsv (ax, aop_setv, tsv->number);
1932 if (ax->tracing)
1933 ax_tsv (ax, aop_tracev, tsv->number);
1934 }
1935 else
1936 error (_("$%s is not a trace state variable, "
1937 "may not assign to it"), name);
1938 }
1939 else
1940 error (_("May only assign to trace state variables"));
1941 break;
1942
1943 case BINOP_ASSIGN_MODIFY:
1944 (*pc)++;
1945 op2 = (*pc)[0].opcode;
1946 (*pc)++;
1947 (*pc)++;
1948 if ((*pc)[0].opcode == OP_INTERNALVAR)
1949 {
1950 char *name = internalvar_name ((*pc)[1].internalvar);
1951 struct trace_state_variable *tsv;
1952
1953 (*pc) += 3;
1954 tsv = find_trace_state_variable (name);
1955 if (tsv)
1956 {
1957 /* The tsv will be the left half of the binary operation. */
1958 ax_tsv (ax, aop_getv, tsv->number);
1959 if (ax->tracing)
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);
1968 if (ax->tracing)
1969 ax_tsv (ax, aop_tracev, tsv->number);
1970 }
1971 else
1972 error (_("$%s is not a trace state variable, "
1973 "may not assign to it"), name);
1974 }
1975 else
1976 error (_("May only assign to trace state variables"));
1977 break;
1978
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. */
1985 case BINOP_COMMA:
1986 (*pc)++;
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
1990 lvalue. */
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. */
1994 break;
1995
1996 case OP_LONG: /* some integer constant */
1997 {
1998 struct type *type = (*pc)[1].type;
1999 LONGEST k = (*pc)[2].longconst;
2000
2001 (*pc) += 4;
2002 gen_int_literal (ax, value, k, type);
2003 }
2004 break;
2005
2006 case OP_VAR_VALUE:
2007 gen_var_ref (ax, value, (*pc)[2].symbol);
2008
2009 if (value->optimized_out)
2010 error (_("`%s' has been optimized out, cannot use"),
2011 SYMBOL_PRINT_NAME ((*pc)[2].symbol));
2012
2013 if (TYPE_CODE (value->type) == TYPE_CODE_ERROR)
2014 error_unknown_type (SYMBOL_PRINT_NAME ((*pc)[2].symbol));
2015
2016 (*pc) += 4;
2017 break;
2018
2019 case OP_VAR_MSYM_VALUE:
2020 gen_msym_var_ref (ax, value, (*pc)[2].msymbol, (*pc)[1].objfile);
2021
2022 if (TYPE_CODE (value->type) == TYPE_CODE_ERROR)
2023 error_unknown_type (MSYMBOL_PRINT_NAME ((*pc)[2].msymbol));
2024
2025 (*pc) += 4;
2026 break;
2027
2028 case OP_REGISTER:
2029 {
2030 const char *name = &(*pc)[2].string;
2031 int reg;
2032
2033 (*pc) += 4 + BYTES_TO_EXP_ELEM ((*pc)[1].longconst + 1);
2034 reg = user_reg_map_name_to_regnum (ax->gdbarch, name, strlen (name));
2035 if (reg == -1)
2036 internal_error (__FILE__, __LINE__,
2037 _("Register $%s not available"), name);
2038 /* No support for tracing user registers yet. */
2039 if (reg >= gdbarch_num_regs (ax->gdbarch)
2040 + gdbarch_num_pseudo_regs (ax->gdbarch))
2041 error (_("'%s' is a user-register; "
2042 "GDB cannot yet trace user-register contents."),
2043 name);
2044 value->kind = axs_lvalue_register;
2045 value->u.reg = reg;
2046 value->type = register_type (ax->gdbarch, reg);
2047 }
2048 break;
2049
2050 case OP_INTERNALVAR:
2051 {
2052 struct internalvar *var = (*pc)[1].internalvar;
2053 const char *name = internalvar_name (var);
2054 struct trace_state_variable *tsv;
2055
2056 (*pc) += 3;
2057 tsv = find_trace_state_variable (name);
2058 if (tsv)
2059 {
2060 ax_tsv (ax, aop_getv, tsv->number);
2061 if (ax->tracing)
2062 ax_tsv (ax, aop_tracev, tsv->number);
2063 /* Trace state variables are always 64-bit integers. */
2064 value->kind = axs_rvalue;
2065 value->type = builtin_type (ax->gdbarch)->builtin_long_long;
2066 }
2067 else if (! compile_internalvar_to_ax (var, ax, value))
2068 error (_("$%s is not a trace state variable; GDB agent "
2069 "expressions cannot use convenience variables."), name);
2070 }
2071 break;
2072
2073 /* Weirdo operator: see comments for gen_repeat for details. */
2074 case BINOP_REPEAT:
2075 /* Note that gen_repeat handles its own argument evaluation. */
2076 (*pc)++;
2077 gen_repeat (exp, pc, ax, value);
2078 break;
2079
2080 case UNOP_CAST:
2081 {
2082 struct type *type = (*pc)[1].type;
2083
2084 (*pc) += 3;
2085 gen_expr_for_cast (exp, pc, ax, value, type);
2086 }
2087 break;
2088
2089 case UNOP_CAST_TYPE:
2090 {
2091 int offset;
2092 struct value *val;
2093 struct type *type;
2094
2095 ++*pc;
2096 offset = *pc - exp->elts;
2097 val = evaluate_subexp (NULL, exp, &offset, EVAL_AVOID_SIDE_EFFECTS);
2098 type = value_type (val);
2099 *pc = &exp->elts[offset];
2100 gen_expr_for_cast (exp, pc, ax, value, type);
2101 }
2102 break;
2103
2104 case UNOP_MEMVAL:
2105 {
2106 struct type *type = check_typedef ((*pc)[1].type);
2107
2108 (*pc) += 3;
2109 gen_expr (exp, pc, ax, value);
2110
2111 /* If we have an axs_rvalue or an axs_lvalue_memory, then we
2112 already have the right value on the stack. For
2113 axs_lvalue_register, we must convert. */
2114 if (value->kind == axs_lvalue_register)
2115 require_rvalue (ax, value);
2116
2117 value->type = type;
2118 value->kind = axs_lvalue_memory;
2119 }
2120 break;
2121
2122 case UNOP_MEMVAL_TYPE:
2123 {
2124 int offset;
2125 struct value *val;
2126 struct type *type;
2127
2128 ++*pc;
2129 offset = *pc - exp->elts;
2130 val = evaluate_subexp (NULL, exp, &offset, EVAL_AVOID_SIDE_EFFECTS);
2131 type = value_type (val);
2132 *pc = &exp->elts[offset];
2133
2134 gen_expr (exp, pc, ax, value);
2135
2136 /* If we have an axs_rvalue or an axs_lvalue_memory, then we
2137 already have the right value on the stack. For
2138 axs_lvalue_register, we must convert. */
2139 if (value->kind == axs_lvalue_register)
2140 require_rvalue (ax, value);
2141
2142 value->type = type;
2143 value->kind = axs_lvalue_memory;
2144 }
2145 break;
2146
2147 case UNOP_PLUS:
2148 (*pc)++;
2149 /* + FOO is equivalent to 0 + FOO, which can be optimized. */
2150 gen_expr (exp, pc, ax, value);
2151 gen_usual_unary (ax, value);
2152 break;
2153
2154 case UNOP_NEG:
2155 (*pc)++;
2156 /* -FOO is equivalent to 0 - FOO. */
2157 gen_int_literal (ax, &value1, 0,
2158 builtin_type (ax->gdbarch)->builtin_int);
2159 gen_usual_unary (ax, &value1); /* shouldn't do much */
2160 gen_expr (exp, pc, ax, &value2);
2161 gen_usual_unary (ax, &value2);
2162 gen_usual_arithmetic (ax, &value1, &value2);
2163 gen_binop (ax, value, &value1, &value2, aop_sub, aop_sub, 1, "negation");
2164 break;
2165
2166 case UNOP_LOGICAL_NOT:
2167 (*pc)++;
2168 gen_expr (exp, pc, ax, value);
2169 gen_usual_unary (ax, value);
2170 gen_logical_not (ax, value, int_type);
2171 break;
2172
2173 case UNOP_COMPLEMENT:
2174 (*pc)++;
2175 gen_expr (exp, pc, ax, value);
2176 gen_usual_unary (ax, value);
2177 gen_integral_promotions (ax, value);
2178 gen_complement (ax, value);
2179 break;
2180
2181 case UNOP_IND:
2182 (*pc)++;
2183 gen_expr (exp, pc, ax, value);
2184 gen_usual_unary (ax, value);
2185 if (!pointer_type (value->type))
2186 error (_("Argument of unary `*' is not a pointer."));
2187 gen_deref (value);
2188 break;
2189
2190 case UNOP_ADDR:
2191 (*pc)++;
2192 gen_expr (exp, pc, ax, value);
2193 gen_address_of (value);
2194 break;
2195
2196 case UNOP_SIZEOF:
2197 (*pc)++;
2198 /* Notice that gen_sizeof handles its own operand, unlike most
2199 of the other unary operator functions. This is because we
2200 have to throw away the code we generate. */
2201 gen_sizeof (exp, pc, ax, value,
2202 builtin_type (ax->gdbarch)->builtin_int);
2203 break;
2204
2205 case STRUCTOP_STRUCT:
2206 case STRUCTOP_PTR:
2207 {
2208 int length = (*pc)[1].longconst;
2209 char *name = &(*pc)[2].string;
2210
2211 (*pc) += 4 + BYTES_TO_EXP_ELEM (length + 1);
2212 gen_expr (exp, pc, ax, value);
2213 if (op == STRUCTOP_STRUCT)
2214 gen_struct_ref (ax, value, name, ".", "structure or union");
2215 else if (op == STRUCTOP_PTR)
2216 gen_struct_ref (ax, value, name, "->",
2217 "pointer to a structure or union");
2218 else
2219 /* If this `if' chain doesn't handle it, then the case list
2220 shouldn't mention it, and we shouldn't be here. */
2221 internal_error (__FILE__, __LINE__,
2222 _("gen_expr: unhandled struct case"));
2223 }
2224 break;
2225
2226 case OP_THIS:
2227 {
2228 struct symbol *sym, *func;
2229 const struct block *b;
2230 const struct language_defn *lang;
2231
2232 b = block_for_pc (ax->scope);
2233 func = block_linkage_function (b);
2234 lang = language_def (SYMBOL_LANGUAGE (func));
2235
2236 sym = lookup_language_this (lang, b).symbol;
2237 if (!sym)
2238 error (_("no `%s' found"), lang->la_name_of_this);
2239
2240 gen_var_ref (ax, value, sym);
2241
2242 if (value->optimized_out)
2243 error (_("`%s' has been optimized out, cannot use"),
2244 SYMBOL_PRINT_NAME (sym));
2245
2246 (*pc) += 2;
2247 }
2248 break;
2249
2250 case OP_SCOPE:
2251 {
2252 struct type *type = (*pc)[1].type;
2253 int length = longest_to_int ((*pc)[2].longconst);
2254 char *name = &(*pc)[3].string;
2255 int found;
2256
2257 found = gen_aggregate_elt_ref (ax, value, type, name);
2258 if (!found)
2259 error (_("There is no field named %s"), name);
2260 (*pc) += 5 + BYTES_TO_EXP_ELEM (length + 1);
2261 }
2262 break;
2263
2264 case OP_TYPE:
2265 case OP_TYPEOF:
2266 case OP_DECLTYPE:
2267 error (_("Attempt to use a type name as an expression."));
2268
2269 default:
2270 error (_("Unsupported operator %s (%d) in expression."),
2271 op_name (exp, op), op);
2272 }
2273 }
2274
2275 /* This handles the middle-to-right-side of code generation for binary
2276 expressions, which is shared between regular binary operations and
2277 assign-modify (+= and friends) expressions. */
2278
2279 static void
2280 gen_expr_binop_rest (struct expression *exp,
2281 enum exp_opcode op, union exp_element **pc,
2282 struct agent_expr *ax, struct axs_value *value,
2283 struct axs_value *value1, struct axs_value *value2)
2284 {
2285 struct type *int_type = builtin_type (ax->gdbarch)->builtin_int;
2286
2287 gen_expr (exp, pc, ax, value2);
2288 gen_usual_unary (ax, value2);
2289 gen_usual_arithmetic (ax, value1, value2);
2290 switch (op)
2291 {
2292 case BINOP_ADD:
2293 if (TYPE_CODE (value1->type) == TYPE_CODE_INT
2294 && pointer_type (value2->type))
2295 {
2296 /* Swap the values and proceed normally. */
2297 ax_simple (ax, aop_swap);
2298 gen_ptradd (ax, value, value2, value1);
2299 }
2300 else if (pointer_type (value1->type)
2301 && TYPE_CODE (value2->type) == TYPE_CODE_INT)
2302 gen_ptradd (ax, value, value1, value2);
2303 else
2304 gen_binop (ax, value, value1, value2,
2305 aop_add, aop_add, 1, "addition");
2306 break;
2307 case BINOP_SUB:
2308 if (pointer_type (value1->type)
2309 && TYPE_CODE (value2->type) == TYPE_CODE_INT)
2310 gen_ptrsub (ax,value, value1, value2);
2311 else if (pointer_type (value1->type)
2312 && pointer_type (value2->type))
2313 /* FIXME --- result type should be ptrdiff_t */
2314 gen_ptrdiff (ax, value, value1, value2,
2315 builtin_type (ax->gdbarch)->builtin_long);
2316 else
2317 gen_binop (ax, value, value1, value2,
2318 aop_sub, aop_sub, 1, "subtraction");
2319 break;
2320 case BINOP_MUL:
2321 gen_binop (ax, value, value1, value2,
2322 aop_mul, aop_mul, 1, "multiplication");
2323 break;
2324 case BINOP_DIV:
2325 gen_binop (ax, value, value1, value2,
2326 aop_div_signed, aop_div_unsigned, 1, "division");
2327 break;
2328 case BINOP_REM:
2329 gen_binop (ax, value, value1, value2,
2330 aop_rem_signed, aop_rem_unsigned, 1, "remainder");
2331 break;
2332 case BINOP_LSH:
2333 gen_binop (ax, value, value1, value2,
2334 aop_lsh, aop_lsh, 1, "left shift");
2335 break;
2336 case BINOP_RSH:
2337 gen_binop (ax, value, value1, value2,
2338 aop_rsh_signed, aop_rsh_unsigned, 1, "right shift");
2339 break;
2340 case BINOP_SUBSCRIPT:
2341 {
2342 struct type *type;
2343
2344 if (binop_types_user_defined_p (op, value1->type, value2->type))
2345 {
2346 error (_("cannot subscript requested type: "
2347 "cannot call user defined functions"));
2348 }
2349 else
2350 {
2351 /* If the user attempts to subscript something that is not
2352 an array or pointer type (like a plain int variable for
2353 example), then report this as an error. */
2354 type = check_typedef (value1->type);
2355 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2356 && TYPE_CODE (type) != TYPE_CODE_PTR)
2357 {
2358 if (TYPE_NAME (type))
2359 error (_("cannot subscript something of type `%s'"),
2360 TYPE_NAME (type));
2361 else
2362 error (_("cannot subscript requested type"));
2363 }
2364 }
2365
2366 if (!is_integral_type (value2->type))
2367 error (_("Argument to arithmetic operation "
2368 "not a number or boolean."));
2369
2370 gen_ptradd (ax, value, value1, value2);
2371 gen_deref (value);
2372 break;
2373 }
2374 case BINOP_BITWISE_AND:
2375 gen_binop (ax, value, value1, value2,
2376 aop_bit_and, aop_bit_and, 0, "bitwise and");
2377 break;
2378
2379 case BINOP_BITWISE_IOR:
2380 gen_binop (ax, value, value1, value2,
2381 aop_bit_or, aop_bit_or, 0, "bitwise or");
2382 break;
2383
2384 case BINOP_BITWISE_XOR:
2385 gen_binop (ax, value, value1, value2,
2386 aop_bit_xor, aop_bit_xor, 0, "bitwise exclusive-or");
2387 break;
2388
2389 case BINOP_EQUAL:
2390 gen_equal (ax, value, value1, value2, int_type);
2391 break;
2392
2393 case BINOP_NOTEQUAL:
2394 gen_equal (ax, value, value1, value2, int_type);
2395 gen_logical_not (ax, value, int_type);
2396 break;
2397
2398 case BINOP_LESS:
2399 gen_less (ax, value, value1, value2, int_type);
2400 break;
2401
2402 case BINOP_GTR:
2403 ax_simple (ax, aop_swap);
2404 gen_less (ax, value, value1, value2, int_type);
2405 break;
2406
2407 case BINOP_LEQ:
2408 ax_simple (ax, aop_swap);
2409 gen_less (ax, value, value1, value2, int_type);
2410 gen_logical_not (ax, value, int_type);
2411 break;
2412
2413 case BINOP_GEQ:
2414 gen_less (ax, value, value1, value2, int_type);
2415 gen_logical_not (ax, value, int_type);
2416 break;
2417
2418 default:
2419 /* We should only list operators in the outer case statement
2420 that we actually handle in the inner case statement. */
2421 internal_error (__FILE__, __LINE__,
2422 _("gen_expr: op case sets don't match"));
2423 }
2424 }
2425
2426
2427 /* Given a single variable and a scope, generate bytecodes to trace
2428 its value. This is for use in situations where we have only a
2429 variable's name, and no parsed expression; for instance, when the
2430 name comes from a list of local variables of a function. */
2431
2432 agent_expr_up
2433 gen_trace_for_var (CORE_ADDR scope, struct gdbarch *gdbarch,
2434 struct symbol *var, int trace_string)
2435 {
2436 agent_expr_up ax (new agent_expr (gdbarch, scope));
2437 struct axs_value value;
2438
2439 ax->tracing = 1;
2440 ax->trace_string = trace_string;
2441 gen_var_ref (ax.get (), &value, var);
2442
2443 /* If there is no actual variable to trace, flag it by returning
2444 an empty agent expression. */
2445 if (value.optimized_out)
2446 return agent_expr_up ();
2447
2448 /* Make sure we record the final object, and get rid of it. */
2449 gen_traced_pop (ax.get (), &value);
2450
2451 /* Oh, and terminate. */
2452 ax_simple (ax.get (), aop_end);
2453
2454 return ax;
2455 }
2456
2457 /* Generating bytecode from GDB expressions: driver */
2458
2459 /* Given a GDB expression EXPR, return bytecode to trace its value.
2460 The result will use the `trace' and `trace_quick' bytecodes to
2461 record the value of all memory touched by the expression. The
2462 caller can then use the ax_reqs function to discover which
2463 registers it relies upon. */
2464
2465 agent_expr_up
2466 gen_trace_for_expr (CORE_ADDR scope, struct expression *expr,
2467 int trace_string)
2468 {
2469 agent_expr_up ax (new agent_expr (expr->gdbarch, scope));
2470 union exp_element *pc;
2471 struct axs_value value;
2472
2473 pc = expr->elts;
2474 ax->tracing = 1;
2475 ax->trace_string = trace_string;
2476 value.optimized_out = 0;
2477 gen_expr (expr, &pc, ax.get (), &value);
2478
2479 /* Make sure we record the final object, and get rid of it. */
2480 gen_traced_pop (ax.get (), &value);
2481
2482 /* Oh, and terminate. */
2483 ax_simple (ax.get (), aop_end);
2484
2485 return ax;
2486 }
2487
2488 /* Given a GDB expression EXPR, return a bytecode sequence that will
2489 evaluate and return a result. The bytecodes will do a direct
2490 evaluation, using the current data on the target, rather than
2491 recording blocks of memory and registers for later use, as
2492 gen_trace_for_expr does. The generated bytecode sequence leaves
2493 the result of expression evaluation on the top of the stack. */
2494
2495 agent_expr_up
2496 gen_eval_for_expr (CORE_ADDR scope, struct expression *expr)
2497 {
2498 agent_expr_up ax (new agent_expr (expr->gdbarch, scope));
2499 union exp_element *pc;
2500 struct axs_value value;
2501
2502 pc = expr->elts;
2503 ax->tracing = 0;
2504 value.optimized_out = 0;
2505 gen_expr (expr, &pc, ax.get (), &value);
2506
2507 require_rvalue (ax.get (), &value);
2508
2509 /* Oh, and terminate. */
2510 ax_simple (ax.get (), aop_end);
2511
2512 return ax;
2513 }
2514
2515 agent_expr_up
2516 gen_trace_for_return_address (CORE_ADDR scope, struct gdbarch *gdbarch,
2517 int trace_string)
2518 {
2519 agent_expr_up ax (new agent_expr (gdbarch, scope));
2520 struct axs_value value;
2521
2522 ax->tracing = 1;
2523 ax->trace_string = trace_string;
2524
2525 gdbarch_gen_return_address (gdbarch, ax.get (), &value, scope);
2526
2527 /* Make sure we record the final object, and get rid of it. */
2528 gen_traced_pop (ax.get (), &value);
2529
2530 /* Oh, and terminate. */
2531 ax_simple (ax.get (), aop_end);
2532
2533 return ax;
2534 }
2535
2536 /* Given a collection of printf-style arguments, generate code to
2537 evaluate the arguments and pass everything to a special
2538 bytecode. */
2539
2540 agent_expr_up
2541 gen_printf (CORE_ADDR scope, struct gdbarch *gdbarch,
2542 CORE_ADDR function, LONGEST channel,
2543 const char *format, int fmtlen,
2544 int nargs, struct expression **exprs)
2545 {
2546 agent_expr_up ax (new agent_expr (gdbarch, scope));
2547 union exp_element *pc;
2548 struct axs_value value;
2549 int tem;
2550
2551 /* We're computing values, not doing side effects. */
2552 ax->tracing = 0;
2553
2554 /* Evaluate and push the args on the stack in reverse order,
2555 for simplicity of collecting them on the target side. */
2556 for (tem = nargs - 1; tem >= 0; --tem)
2557 {
2558 pc = exprs[tem]->elts;
2559 value.optimized_out = 0;
2560 gen_expr (exprs[tem], &pc, ax.get (), &value);
2561 require_rvalue (ax.get (), &value);
2562 }
2563
2564 /* Push function and channel. */
2565 ax_const_l (ax.get (), channel);
2566 ax_const_l (ax.get (), function);
2567
2568 /* Issue the printf bytecode proper. */
2569 ax_simple (ax.get (), aop_printf);
2570 ax_raw_byte (ax.get (), nargs);
2571 ax_string (ax.get (), format, fmtlen);
2572
2573 /* And terminate. */
2574 ax_simple (ax.get (), aop_end);
2575
2576 return ax;
2577 }
2578
2579 static void
2580 agent_eval_command_one (const char *exp, int eval, CORE_ADDR pc)
2581 {
2582 const char *arg;
2583 int trace_string = 0;
2584
2585 if (!eval)
2586 {
2587 if (*exp == '/')
2588 exp = decode_agent_options (exp, &trace_string);
2589 }
2590
2591 agent_expr_up agent;
2592
2593 arg = exp;
2594 if (!eval && strcmp (arg, "$_ret") == 0)
2595 {
2596 agent = gen_trace_for_return_address (pc, get_current_arch (),
2597 trace_string);
2598 }
2599 else
2600 {
2601 expression_up expr = parse_exp_1 (&arg, pc, block_for_pc (pc), 0);
2602
2603 if (eval)
2604 {
2605 gdb_assert (trace_string == 0);
2606 agent = gen_eval_for_expr (pc, expr.get ());
2607 }
2608 else
2609 agent = gen_trace_for_expr (pc, expr.get (), trace_string);
2610 }
2611
2612 ax_reqs (agent.get ());
2613 ax_print (gdb_stdout, agent.get ());
2614
2615 /* It would be nice to call ax_reqs here to gather some general info
2616 about the expression, and then print out the result. */
2617
2618 dont_repeat ();
2619 }
2620
2621 static void
2622 agent_command_1 (const char *exp, int eval)
2623 {
2624 /* We don't deal with overlay debugging at the moment. We need to
2625 think more carefully about this. If you copy this code into
2626 another command, change the error message; the user shouldn't
2627 have to know anything about agent expressions. */
2628 if (overlay_debugging)
2629 error (_("GDB can't do agent expression translation with overlays."));
2630
2631 if (exp == 0)
2632 error_no_arg (_("expression to translate"));
2633
2634 if (check_for_argument (&exp, "-at", sizeof ("-at") - 1))
2635 {
2636 struct linespec_result canonical;
2637
2638 exp = skip_spaces (exp);
2639
2640 event_location_up location
2641 = new_linespec_location (&exp, symbol_name_match_type::WILD);
2642 decode_line_full (location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
2643 (struct symtab *) NULL, 0, &canonical,
2644 NULL, NULL);
2645 exp = skip_spaces (exp);
2646 if (exp[0] == ',')
2647 {
2648 exp++;
2649 exp = skip_spaces (exp);
2650 }
2651 for (const auto &lsal : canonical.lsals)
2652 for (const auto &sal : lsal.sals)
2653 agent_eval_command_one (exp, eval, sal.pc);
2654 }
2655 else
2656 agent_eval_command_one (exp, eval, get_frame_pc (get_current_frame ()));
2657
2658 dont_repeat ();
2659 }
2660
2661 static void
2662 agent_command (const char *exp, int from_tty)
2663 {
2664 agent_command_1 (exp, 0);
2665 }
2666
2667 /* Parse the given expression, compile it into an agent expression
2668 that does direct evaluation, and display the resulting
2669 expression. */
2670
2671 static void
2672 agent_eval_command (const char *exp, int from_tty)
2673 {
2674 agent_command_1 (exp, 1);
2675 }
2676
2677 /* Parse the given expression, compile it into an agent expression
2678 that does a printf, and display the resulting expression. */
2679
2680 static void
2681 maint_agent_printf_command (const char *cmdrest, int from_tty)
2682 {
2683 struct frame_info *fi = get_current_frame (); /* need current scope */
2684 const char *format_start, *format_end;
2685
2686 /* We don't deal with overlay debugging at the moment. We need to
2687 think more carefully about this. If you copy this code into
2688 another command, change the error message; the user shouldn't
2689 have to know anything about agent expressions. */
2690 if (overlay_debugging)
2691 error (_("GDB can't do agent expression translation with overlays."));
2692
2693 if (cmdrest == 0)
2694 error_no_arg (_("expression to translate"));
2695
2696 cmdrest = skip_spaces (cmdrest);
2697
2698 if (*cmdrest++ != '"')
2699 error (_("Must start with a format string."));
2700
2701 format_start = cmdrest;
2702
2703 format_pieces fpieces (&cmdrest);
2704
2705 format_end = cmdrest;
2706
2707 if (*cmdrest++ != '"')
2708 error (_("Bad format string, non-terminated '\"'."));
2709
2710 cmdrest = skip_spaces (cmdrest);
2711
2712 if (*cmdrest != ',' && *cmdrest != 0)
2713 error (_("Invalid argument syntax"));
2714
2715 if (*cmdrest == ',')
2716 cmdrest++;
2717 cmdrest = skip_spaces (cmdrest);
2718
2719 std::vector<struct expression *> argvec;
2720 while (*cmdrest != '\0')
2721 {
2722 const char *cmd1;
2723
2724 cmd1 = cmdrest;
2725 expression_up expr = parse_exp_1 (&cmd1, 0, (struct block *) 0, 1);
2726 argvec.push_back (expr.release ());
2727 cmdrest = cmd1;
2728 if (*cmdrest == ',')
2729 ++cmdrest;
2730 /* else complain? */
2731 }
2732
2733
2734 agent_expr_up agent = gen_printf (get_frame_pc (fi), get_current_arch (),
2735 0, 0,
2736 format_start, format_end - format_start,
2737 argvec.size (), argvec.data ());
2738 ax_reqs (agent.get ());
2739 ax_print (gdb_stdout, agent.get ());
2740
2741 /* It would be nice to call ax_reqs here to gather some general info
2742 about the expression, and then print out the result. */
2743
2744 dont_repeat ();
2745 }
2746
2747 /* Initialization code. */
2748
2749 void
2750 _initialize_ax_gdb (void)
2751 {
2752 add_cmd ("agent", class_maintenance, agent_command,
2753 _("\
2754 Translate an expression into remote agent bytecode for tracing.\n\
2755 Usage: maint agent [-at location,] EXPRESSION\n\
2756 If -at is given, generate remote agent bytecode for this location.\n\
2757 If not, generate remote agent bytecode for current frame pc address."),
2758 &maintenancelist);
2759
2760 add_cmd ("agent-eval", class_maintenance, agent_eval_command,
2761 _("\
2762 Translate an expression into remote agent bytecode for evaluation.\n\
2763 Usage: maint agent-eval [-at location,] EXPRESSION\n\
2764 If -at is given, generate remote agent bytecode for this location.\n\
2765 If not, generate remote agent bytecode for current frame pc address."),
2766 &maintenancelist);
2767
2768 add_cmd ("agent-printf", class_maintenance, maint_agent_printf_command,
2769 _("Translate an expression into remote "
2770 "agent bytecode for evaluation and display the bytecodes."),
2771 &maintenancelist);
2772 }
TYPE_CODE_NAMESPACE
Definition: gdbtypes.h:171
error_no_arg
void error_no_arg(const char *why)
Definition: cli-cmds.c:185
agent_command_1
static void agent_command_1(const char *exp, int eval)
Definition: ax-gdb.c:2622
gdbarch
Definition: gdbarch.c:127
type::length
unsigned int length
Definition: gdbtypes.h:803
TYPE_FIELD_STATIC_PHYSNAME
#define TYPE_FIELD_STATIC_PHYSNAME(thistype, n)
Definition: gdbtypes.h:1376
gen_logical_not
static void gen_logical_not(struct agent_expr *ax, struct axs_value *value, struct type *result_type)
Definition: ax-gdb.c:1175
expression::elts
union exp_element elts[1]
Definition: expression.h:84
TYPE_CODE_BOOL
Definition: gdbtypes.h:164
axs_value
Definition: ax-gdb.h:77
TYPE_CODE_ARRAY
Definition: gdbtypes.h:104
gen_conversion
static void gen_conversion(struct agent_expr *ax, struct type *from, struct type *to)
Definition: ax-gdb.c:889
lookup_array_range_type
struct type * lookup_array_range_type(struct type *element_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:1232
ax_goto
int ax_goto(struct agent_expr *x, enum agent_op op)
Definition: ax-general.c:200
TYPE_CODE_ENUM
Definition: gdbtypes.h:108
op_name
const char * op_name(struct expression *exp, enum exp_opcode opcode)
Definition: expprint.c:686
gen_extend
static void gen_extend(struct agent_expr *, struct type *)
Definition: ax-gdb.c:456
gen_var_ref
static void gen_var_ref(struct agent_expr *ax, struct axs_value *value, struct symbol *var)
Definition: ax-gdb.c:618
get_frame_pc
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2376
SYMBOL_PRINT_NAME
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:542
agent_expr_up
std::unique_ptr< agent_expr > agent_expr_up
Definition: ax.h:159
get_current_frame
struct frame_info * get_current_frame(void)
Definition: frame.c:1563
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
ax_reqs
void ax_reqs(struct agent_expr *ax)
Definition: ax-general.c:468
value::type
struct type * type
Definition: value.c:266
TYPE_FIELD_NAME
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1372
gen_ptradd
static void gen_ptradd(struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2)
Definition: ax-gdb.c:1069
builtin_type::builtin_unsigned_int
struct type * builtin_unsigned_int
Definition: gdbtypes.h:1508
TYPE_N_BASECLASSES
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:1331
command.h
expression_up
gdb::unique_xmalloc_ptr< expression > expression_up
Definition: expression.h:87
ax_reg_mask
void ax_reg_mask(struct agent_expr *ax, int reg)
Definition: ax-general.c:425
FIELD_LOC_KIND_PHYSADDR
Definition: gdbtypes.h:456
LOC_BLOCK
Definition: symtab.h:854
pointer_type
int pointer_type(struct type *type)
Definition: language.c:415
value_as_long
LONGEST value_as_long(struct value *val)
Definition: value.c:2749
gen_less
static void gen_less(struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2, struct type *result_type)
Definition: ax-gdb.c:1135
func
void(* func)(char *)
Definition: remote-fileio.c:1104
BMSYMBOL_VALUE_ADDRESS
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:691
decode_agent_options
const char * decode_agent_options(const char *exp, int *trace_string)
Definition: tracepoint.c:555
TYPE_NAME
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1224
compile_internalvar_to_ax
int compile_internalvar_to_ax(struct internalvar *var, struct agent_expr *expr, struct axs_value *value)
Definition: value.c:2192
new_linespec_location
event_location_up new_linespec_location(const char **linespec, symbol_name_match_type match_type)
Definition: location.c:88
gen_frame_args_address
static void gen_frame_args_address(struct agent_expr *)
Definition: ax-gdb.c:553
cp_lookup_symbol_namespace
struct block_symbol cp_lookup_symbol_namespace(const char *scope, const char *name, const struct block *block, const domain_enum domain)
Definition: cp-namespace.c:632
TYPE_CODE_RANGE
Definition: gdbtypes.h:127
builtin_type
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:5217
gen_namespace_elt
static int gen_namespace_elt(struct agent_expr *ax, struct axs_value *value, const struct type *curtype, char *name)
Definition: ax-gdb.c:1625
TYPE_CODE_INT
Definition: gdbtypes.h:111
SYMBOL_CLASS
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:1155
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
gen_maybe_namespace_elt
static int gen_maybe_namespace_elt(struct agent_expr *ax, struct axs_value *value, const struct type *curtype, char *name)
Definition: ax-gdb.c:1644
binop_types_user_defined_p
int binop_types_user_defined_p(enum exp_opcode op, struct type *type1, struct type *type2)
Definition: valarith.c:224
ax-gdb.h
gen_offset
static void gen_offset(struct agent_expr *ax, int offset)
Definition: ax-gdb.c:586
language_def
const struct language_defn * language_def(enum language lang)
Definition: language.c:494
agent_eval_command_one
static void agent_eval_command_one(const char *exp, int eval, CORE_ADDR pc)
Definition: ax-gdb.c:2580
gen_sym_offset
static void gen_sym_offset(struct agent_expr *, struct symbol *)
Definition: ax-gdb.c:608
add_cmd
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:262
block_linkage_function
struct symbol * block_linkage_function(const struct block *bl)
Definition: block.c:100
agent_expr
Definition: ax.h:83
frame_info
Definition: frame.c:85
parse_exp_1
expression_up parse_exp_1(const char **, CORE_ADDR pc, const struct block *, int)
Definition: parse.c:1089
cp-support.h
LOC_TYPEDEF
Definition: symtab.h:844
lookup_symbol
struct block_symbol lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1893
ax_reg
void ax_reg(struct agent_expr *x, int reg)
Definition: ax-general.c:274
gdbarch_num_regs
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:2039
agent_expr::gdbarch
struct gdbarch * gdbarch
Definition: ax.h:100
skip_spaces
char * skip_spaces(char *chp)
Definition: common-utils.c:337
gen_fetch
static void gen_fetch(struct agent_expr *, struct type *)
Definition: ax-gdb.c:469
_
#define _(String)
Definition: gdb_locale.h:35
linespec_result::location
event_location_up location
Definition: linespec.h:76
axs_lvalue_memory
Definition: ax-gdb.h:63
TYPE_CODE_RVALUE_REF
Definition: gdbtypes.h:158
defs.h
TYPE_FIELD
#define TYPE_FIELD(thistype, n)
Definition: gdbtypes.h:1370
builtin_type
Definition: gdbtypes.h:1495
gen_printf
agent_expr_up gen_printf(CORE_ADDR scope, struct gdbarch *gdbarch, CORE_ADDR function, LONGEST channel, const char *format, int fmtlen, int nargs, struct expression **exprs)
Definition: ax-gdb.c:2541
BLOCK_START
#define BLOCK_START(bl)
Definition: block.h:105
bits
#define bits(obj, st, fn)
Definition: aarch64-tdep.c:64
LOC_ARG
Definition: symtab.h:823
internalvar
Definition: value.c:2070
gen_primitive_field
static void gen_primitive_field(struct agent_expr *ax, struct axs_value *value, int offset, int fieldno, struct type *type)
Definition: ax-gdb.c:1415
BYTES_TO_EXP_ELEM
#define BYTES_TO_EXP_ELEM(bytes)
Definition: expression.h:94
DECODE_LINE_FUNFIRSTLINE
Definition: linespec.h:31
TYPE_FIELD_TYPE
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1371
trace_state_variable::number
int number
Definition: tracepoint.h:56
axs_value::type
struct type * type
Definition: ax-gdb.h:84
error_unknown_type
void error_unknown_type(const char *sym_print_name)
Definition: typeprint.c:396
ax.h
block_for_pc
const struct block * block_for_pc(CORE_ADDR pc)
Definition: block.c:282
agent_expr::trace_string
int trace_string
Definition: ax.h:155
LOC_LOCAL
Definition: symtab.h:839
ax_tsv
void ax_tsv(struct agent_expr *x, enum agent_op op, int num)
Definition: ax-general.c:307
language_defn::la_name_of_this
const char * la_name_of_this
Definition: language.h:265
longest_to_int
int longest_to_int(LONGEST)
Definition: valprint.c:1341
objfiles.h
maybe_const_expr
static struct value * maybe_const_expr(union exp_element **pc)
Definition: ax-gdb.c:250
arch-utils.h
language_defn
Definition: language.h:132
LOC_REGISTER
Definition: symtab.h:819
gen_ptrsub
static void gen_ptrsub(struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2)
Definition: ax-gdb.c:1085
gdbarch_num_pseudo_regs
int gdbarch_num_pseudo_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:2057
TYPE_CODE_VOID
Definition: gdbtypes.h:124
symtab.h
MSYMBOL_PRINT_NAME
#define MSYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:708
gen_struct_ref_recursive
static int gen_struct_ref_recursive(struct agent_expr *ax, struct axs_value *value, const char *field, int offset, struct type *type)
Definition: ax-gdb.c:1439
format.h
name
const char *const name
Definition: aarch64-tdep.c:76
gen_trace_static_fields
static void gen_trace_static_fields(struct agent_expr *ax, struct type *type)
Definition: ax-gdb.c:311
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
SYMBOL_VALUE_ADDRESS
#define SYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:464
find_minsym_type_and_address
type * find_minsym_type_and_address(minimal_symbol *msymbol, objfile *objf, CORE_ADDR *address_p)
Definition: parse.c:444
LOC_CONST_BYTES
Definition: symtab.h:859
LOC_COMPUTED
Definition: symtab.h:892
TYPE_CODE_CHAR
Definition: gdbtypes.h:160
is_nontrivial_conversion
static int is_nontrivial_conversion(struct type *from, struct type *to)
Definition: ax-gdb.c:919
gen_equal
static void gen_equal(struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2, struct type *result_type)
Definition: ax-gdb.c:1121
max_type
static struct type * max_type(struct type *type1, struct type *type2)
Definition: ax-gdb.c:881
agent_command
static void agent_command(const char *exp, int from_tty)
Definition: ax-gdb.c:2662
gen_expr_for_cast
static void gen_expr_for_cast(struct expression *exp, union exp_element **pc, struct agent_expr *ax, struct axs_value *value, struct type *to_type)
Definition: ax-gdb.c:1770
field_is_static
int field_is_static(struct field *f)
Definition: gdbtypes.c:4224
value::reg
struct value::@186::@187 reg
agent_expr::tracing
unsigned int tracing
Definition: ax.h:149
gen_address_of
static void gen_address_of(struct axs_value *)
Definition: ax-gdb.c:1226
regcache.h
bound_minimal_symbol
Definition: minsyms.h:29
gdbarch_gen_return_address
void gdbarch_gen_return_address(struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope)
Definition: gdbarch.c:4754
register_type
struct type * register_type(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:152
cli-utils.h
expression
Definition: expression.h:78
block_symbol
Definition: symtab.h:1133
frame.h
expression.h
gdb_assert_not_reached
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:55
is_integral_type
int is_integral_type(struct type *t)
Definition: gdbtypes.c:3027
gen_static_field
static void gen_static_field(struct agent_expr *ax, struct axs_value *value, struct type *type, int fieldno)
Definition: ax-gdb.c:1547
SYMBOL_REGISTER_OPS
#define SYMBOL_REGISTER_OPS(symbol)
Definition: symtab.h:1165
SYMBOL_COMPUTED_OPS
#define SYMBOL_COMPUTED_OPS(symbol)
Definition: symtab.h:1163
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
gen_aggregate_elt_ref
static int gen_aggregate_elt_ref(struct agent_expr *ax, struct axs_value *value, struct type *type, char *field)
Definition: ax-gdb.c:1668
internalvar_name
char * internalvar_name(const struct internalvar *var)
Definition: value.c:2502
TYPE_CODE_UNION
Definition: gdbtypes.h:107
TARGET_CHAR_BIT
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
ax_ext
void ax_ext(struct agent_expr *x, int n)
Definition: ax-general.c:164
type
Definition: gdbtypes.h:749
gen_scale
static void gen_scale(struct agent_expr *ax, enum agent_op op, struct type *type)
Definition: ax-gdb.c:1055
language.h
tracepoint.h
ax_string
void ax_string(struct agent_expr *x, const char *str, int slen)
Definition: ax-general.c:328
ax_label
void ax_label(struct agent_expr *x, int patch, int target)
Definition: ax-general.c:215
LOC_CONST
Definition: symtab.h:801
LOC_UNRESOLVED
Definition: symtab.h:883
const_var_ref
static struct value * const_var_ref(struct symbol *var)
Definition: ax-gdb.c:184
agent_op
agent_op
Definition: ax.h:163
get_current_arch
struct gdbarch * get_current_arch(void)
Definition: arch-utils.c:798
type
static const char * type
Definition: language.c:113
gen_deref
static void gen_deref(struct axs_value *)
Definition: ax-gdb.c:1203
gen_struct_elt_for_reference
static int gen_struct_elt_for_reference(struct agent_expr *ax, struct axs_value *value, struct type *type, char *fieldname)
Definition: ax-gdb.c:1580
axs_rvalue
Definition: ax-gdb.h:58
EVAL_AVOID_SIDE_EFFECTS
Definition: expression.h:127
field
Definition: gdbtypes.h:517
value_from_longest
struct value * value_from_longest(struct type *type, LONGEST num)
Definition: value.c:3534
SYMBOL_LINKAGE_NAME
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:523
ax_simple
void ax_simple(struct agent_expr *x, enum agent_op op)
Definition: ax-general.c:125
decode_line_full
void decode_line_full(const struct event_location *location, int flags, struct program_space *search_pspace, struct symtab *default_symtab, int default_line, struct linespec_result *canonical, const char *select_mode, const char *filter)
Definition: linespec.c:3270
builtin_type::builtin_long
struct type * builtin_long
Definition: gdbtypes.h:1504
linespec.h
LOC_STATIC
Definition: symtab.h:805
event_location_up
std::unique_ptr< event_location, event_location_deleter > event_location_up
Definition: location.h:140
gen_integral_promotions
static void gen_integral_promotions(struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:979
gen_left_shift
static void gen_left_shift(struct agent_expr *, int)
Definition: ax-gdb.c:532
TYPE_BASECLASS
#define TYPE_BASECLASS(thistype, index)
Definition: gdbtypes.h:1330
breakpoint.h
TYPE_FIELD_PACKED
#define TYPE_FIELD_PACKED(thistype, n)
Definition: gdbtypes.h:1381
const_expr
static struct value * const_expr(union exp_element **pc)
Definition: ax-gdb.c:207
symtab
Definition: symtab.h:1291
linespec_result::lsals
std::vector< linespec_sals > lsals
Definition: linespec.h:79
LOC_REGPARM_ADDR
Definition: symtab.h:835
user_reg_map_name_to_regnum
int user_reg_map_name_to_regnum(struct gdbarch *gdbarch, const char *name, int len)
Definition: user-regs.c:130
namespace_name
static const char * namespace_name(struct die_info *die, int *is_anonymous, struct dwarf2_cu *)
Definition: dwarf2read.c:16796
gen_trace_for_expr
agent_expr_up gen_trace_for_expr(CORE_ADDR scope, struct expression *expr, int trace_string)
Definition: ax-gdb.c:2466
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
TYPE_FIELD_BITSIZE
#define TYPE_FIELD_BITSIZE(thistype, n)
Definition: gdbtypes.h:1380
TYPE_CODE_ERROR
Definition: gdbtypes.h:138
TYPE_CODE_REF
Definition: gdbtypes.h:156
TYPE_CODE_FUNC
Definition: gdbtypes.h:110
TYPE_FIELD_BITPOS
#define TYPE_FIELD_BITPOS(thistype, n)
Definition: gdbtypes.h:1374
gen_expr
void gen_expr(struct expression *exp, union exp_element **pc, struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:1806
TYPE_UNSIGNED
#define TYPE_UNSIGNED(t)
Definition: gdbtypes.h:205
block_symbol::symbol
struct symbol * symbol
Definition: symtab.h:1136
SYMBOL_VALUE
#define SYMBOL_VALUE(symbol)
Definition: symtab.h:463
reg
Definition: regdef.h:22
user-regs.h
LOC_REF_ARG
Definition: symtab.h:827
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
block
Definition: block.h:60
value
Definition: value.c:169
gen_trace_for_return_address
agent_expr_up gen_trace_for_return_address(CORE_ADDR scope, struct gdbarch *gdbarch, int trace_string)
Definition: ax-gdb.c:2516
gen_binop
static void gen_binop(struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2, enum agent_op op, enum agent_op op_unsigned, int may_carry, const char *name)
Definition: ax-gdb.c:1155
gen_complement
static void gen_complement(struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:1188
ax_print
void ax_print(struct ui_file *f, struct agent_expr *x)
Definition: ax-general.c:363
objfile
Definition: objfiles.h:286
TYPE_CODE_PTR
Definition: gdbtypes.h:84
gen_msym_var_ref
static void gen_msym_var_ref(agent_expr *ax, axs_value *value, minimal_symbol *msymbol, objfile *objf)
Definition: ax-gdb.c:740
gen_sign_extend
static void gen_sign_extend(struct agent_expr *, struct type *)
Definition: ax-gdb.c:444
value_from_pointer
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
Definition: value.c:3560
exp_element
Definition: expression.h:62
TYPE_TARGET_TYPE
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1226
value_neg
struct value * value_neg(struct value *arg1)
Definition: valarith.c:1640
gen_usual_arithmetic
static void gen_usual_arithmetic(struct agent_expr *ax, struct axs_value *value1, struct axs_value *value2)
Definition: ax-gdb.c:942
gen_cast
static void gen_cast(struct agent_expr *ax, struct axs_value *value, struct type *type)
Definition: ax-gdb.c:998
axs_lvalue_register
Definition: ax-gdb.h:70
gen_trace_for_var
agent_expr_up gen_trace_for_var(CORE_ADDR scope, struct gdbarch *gdbarch, struct symbol *var, int trace_string)
Definition: ax-gdb.c:2433
SYMBOL_BLOCK_VALUE
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:467
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
agent_expr::len
int len
Definition: ax.h:94
_initialize_ax_gdb
void _initialize_ax_gdb(void)
Definition: ax-gdb.c:2750
c-lang.h
builtin_type::builtin_data_ptr
struct type * builtin_data_ptr
Definition: gdbtypes.h:1554
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
linespec_result
Definition: linespec.h:56
trace_state_variable
Definition: tracepoint.h:49
offset
int offset
Definition: agent.c:65
TYPE_NFIELDS
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1239
evaluate_subexp
struct value * evaluate_subexp(struct type *expect_type, struct expression *exp, int *pos, enum noside noside)
Definition: eval.c:69
SYMBOL_LANGUAGE
#define SYMBOL_LANGUAGE(symbol)
Definition: symtab.h:469
exp_opcode
exp_opcode
Definition: expression.h:42
LOC_LABEL
Definition: symtab.h:848
target.h
VAR_DOMAIN
Definition: symtab.h:739
require_rvalue
void require_rvalue(struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:773
gen_int_literal
static void gen_int_literal(struct agent_expr *ax, struct axs_value *value, LONGEST k, struct type *type)
Definition: ax-gdb.c:757
value.h
type_wider_than
static int type_wider_than(struct type *type1, struct type *type2)
Definition: ax-gdb.c:870
location.h
c_textual_element_type
int c_textual_element_type(struct type *, char)
Definition: c-valprint.c:57
gen_traced_pop
static void gen_traced_pop(struct agent_expr *, struct axs_value *)
Definition: ax-gdb.c:361
gen_struct_ref
static void gen_struct_ref(struct agent_expr *ax, struct axs_value *value, const char *field, const char *operator_name, const char *operand_name)
Definition: ax-gdb.c:1503
TYPE_TAG_NAME
#define TYPE_TAG_NAME(type)
Definition: gdbtypes.h:1225
gdbarch::data
void ** data
Definition: gdbarch.c:148
lookup_language_this
struct block_symbol lookup_language_this(const struct language_defn *lang, const struct block *block)
Definition: symtab.c:1915
ax_trace_quick
void ax_trace_quick(struct agent_expr *x, int n)
Definition: ax-general.c:180
ax_const_l
void ax_const_l(struct agent_expr *x, LONGEST l)
Definition: ax-general.c:229
overlay_debugging
enum overlay_debugging_state overlay_debugging
Definition: symfile.c:2970
gdbtypes.h
typeprint.h
gen_ptrdiff
static void gen_ptrdiff(struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2, struct type *result_type)
Definition: ax-gdb.c:1101
gen_frame_locals_address
static void gen_frame_locals_address(struct agent_expr *)
Definition: ax-gdb.c:568
builtin_type::builtin_long_long
struct type * builtin_long_long
Definition: gdbtypes.h:1517
gen_sizeof
static void gen_sizeof(struct expression *exp, union exp_element **pc, struct agent_expr *ax, struct axs_value *value, struct type *size_type)
Definition: ax-gdb.c:1744
gen_bitfield_ref
static void gen_bitfield_ref(struct agent_expr *ax, struct axs_value *value, struct type *type, int start, int end)
Definition: ax-gdb.c:1256
expression::gdbarch
struct gdbarch * gdbarch
Definition: expression.h:82
find_trace_state_variable
struct trace_state_variable * find_trace_state_variable(const char *name)
Definition: tracepoint.c:281
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
SYMBOL_TYPE
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:1161
maint_agent_printf_command
static void maint_agent_printf_command(const char *cmdrest, int from_tty)
Definition: ax-gdb.c:2681
symbol
Definition: symtab.h:1049
maintenancelist
struct cmd_list_element * maintenancelist
Definition: cli-cmds.c:135
LOC_OPTIMIZED_OUT
Definition: symtab.h:888
gen_eval_for_expr
agent_expr_up gen_eval_for_expr(CORE_ADDR scope, struct expression *expr)
Definition: ax-gdb.c:2496
TYPE_FIELD_STATIC_PHYSADDR
#define TYPE_FIELD_STATIC_PHYSADDR(thistype, n)
Definition: gdbtypes.h:1377
ax_zero_ext
void ax_zero_ext(struct agent_expr *x, int n)
Definition: ax-general.c:172
agent_eval_command
static void agent_eval_command(const char *exp, int from_tty)
Definition: ax-gdb.c:2672
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
minimal_symbol
Definition: symtab.h:623
TYPE_BASECLASS_BITPOS
#define TYPE_BASECLASS_BITPOS(thistype, index)
Definition: gdbtypes.h:1333
dont_repeat
void dont_repeat(void)
Definition: top.c:695
class_maintenance
Definition: command.h:43
TYPE_FIELD_LOC_KIND
#define TYPE_FIELD_LOC_KIND(thistype, n)
Definition: gdbtypes.h:1373
valprint.h
gen_repeat
static void gen_repeat(struct expression *exp, union exp_element **pc, struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:1700
lookup_minimal_symbol
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:311
axs_value::kind
enum axs_lvalue_kind kind
Definition: ax-gdb.h:79
gdbcmd.h
format_pieces
Definition: format.h:61
gdbarch_virtual_frame_pointer
void gdbarch_virtual_frame_pointer(struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
Definition: gdbarch.c:1950
gen_expr_binop_rest
static void gen_expr_binop_rest(struct expression *exp, enum exp_opcode op, union exp_element **pc, struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2)
Definition: ax-gdb.c:2280
error
void error(const char *fmt,...)
Definition: errors.c:38
ax_raw_byte
void ax_raw_byte(struct agent_expr *x, gdb_byte byte)
Definition: ax-general.c:117
check_for_argument
int check_for_argument(const char **str, const char *arg, int arg_len)
Definition: cli-utils.c:297
lookup_pointer_type
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:381
dictionary.h
symbol_name_match_type::WILD
block.h
LONGEST
long long LONGEST
Definition: common-types.h:52
symfile.h
gen_usual_unary
static void gen_usual_unary(struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:827
agent_expr::scope
CORE_ADDR scope
Definition: ax.h:103
gdb_stdout
#define gdb_stdout
Definition: utils.h:340
builtin_type::builtin_int
struct type * builtin_int
Definition: gdbtypes.h:1503