GDB (xrefs)
/tmp/gdb-7.10/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-2015 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 "objfiles.h"
44 
45 #include "valprint.h"
46 #include "c-lang.h"
47 
48 #include "format.h"
49 
50 /* To make sense of this file, you should read doc/agentexpr.texi.
51  Then look at the types and enums in ax-gdb.h. For the code itself,
52  look at gen_expr, towards the bottom; that's the main function that
53  looks at the GDB expressions and calls everything else to generate
54  code.
55 
56  I'm beginning to wonder whether it wouldn't be nicer to internally
57  generate trees, with types, and then spit out the bytecode in
58  linear form afterwards; we could generate fewer `swap', `ext', and
59  `zero_ext' bytecodes that way; it would make good constant folding
60  easier, too. But at the moment, I think we should be willing to
61  pay for the simplicity of this code with less-than-optimal bytecode
62  strings.
63 
64  Remember, "GBD" stands for "Great Britain, Dammit!" So be careful. */
65 
66 
67 
68 /* Prototypes for local functions. */
69 
70 /* There's a standard order to the arguments of these functions:
71  union exp_element ** --- pointer into expression
72  struct agent_expr * --- agent expression buffer to generate code into
73  struct axs_value * --- describes value left on top of stack */
74 
75 static struct value *const_var_ref (struct symbol *var);
76 static struct value *const_expr (union exp_element **pc);
77 static struct value *maybe_const_expr (union exp_element **pc);
78 
79 static void gen_traced_pop (struct gdbarch *, struct agent_expr *,
80  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 gdbarch *, struct agent_expr *);
89 static void gen_frame_locals_address (struct gdbarch *, 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 gdbarch *, struct agent_expr *ax,
93  struct axs_value *value, 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 expression *exp, struct agent_expr *ax,
101  struct axs_value *value);
102 static int type_wider_than (struct type *type1, struct type *type2);
103 static struct type *max_type (struct type *type1, struct type *type2);
104 static void gen_conversion (struct agent_expr *ax,
105  struct type *from, struct type *to);
106 static int is_nontrivial_conversion (struct type *from, struct type *to);
107 static void gen_usual_arithmetic (struct expression *exp,
108  struct agent_expr *ax,
109  struct axs_value *value1,
110  struct axs_value *value2);
111 static void gen_integral_promotions (struct expression *exp,
112  struct agent_expr *ax,
113  struct axs_value *value);
114 static void gen_cast (struct agent_expr *ax,
115  struct axs_value *value, struct type *type);
116 static void gen_scale (struct agent_expr *ax,
117  enum agent_op op, struct type *type);
118 static void gen_ptradd (struct agent_expr *ax, struct axs_value *value,
119  struct axs_value *value1, struct axs_value *value2);
120 static void gen_ptrsub (struct agent_expr *ax, struct axs_value *value,
121  struct axs_value *value1, struct axs_value *value2);
122 static void gen_ptrdiff (struct agent_expr *ax, struct axs_value *value,
123  struct axs_value *value1, struct axs_value *value2,
124  struct type *result_type);
125 static void gen_binop (struct agent_expr *ax,
126  struct axs_value *value,
127  struct axs_value *value1,
128  struct axs_value *value2,
129  enum agent_op op,
130  enum agent_op op_unsigned, int may_carry, char *name);
131 static void gen_logical_not (struct agent_expr *ax, struct axs_value *value,
132  struct type *result_type);
133 static void gen_complement (struct agent_expr *ax, struct axs_value *value);
134 static void gen_deref (struct agent_expr *, struct axs_value *);
135 static void gen_address_of (struct agent_expr *, struct axs_value *);
136 static void gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
137  struct axs_value *value,
138  struct type *type, int start, int end);
139 static void gen_primitive_field (struct expression *exp,
140  struct agent_expr *ax,
141  struct axs_value *value,
142  int offset, int fieldno, struct type *type);
143 static int gen_struct_ref_recursive (struct expression *exp,
144  struct agent_expr *ax,
145  struct axs_value *value,
146  char *field, int offset,
147  struct type *type);
148 static void gen_struct_ref (struct expression *exp, struct agent_expr *ax,
149  struct axs_value *value,
150  char *field,
151  char *operator_name, char *operand_name);
152 static void gen_static_field (struct gdbarch *gdbarch,
153  struct agent_expr *ax, struct axs_value *value,
154  struct type *type, int fieldno);
155 static void gen_repeat (struct expression *exp, union exp_element **pc,
156  struct agent_expr *ax, struct axs_value *value);
157 static void gen_sizeof (struct expression *exp, union exp_element **pc,
158  struct agent_expr *ax, struct axs_value *value,
159  struct type *size_type);
160 static void gen_expr_binop_rest (struct expression *exp,
161  enum exp_opcode op, union exp_element **pc,
162  struct agent_expr *ax,
163  struct axs_value *value,
164  struct axs_value *value1,
165  struct axs_value *value2);
166 
167 static void agent_command (char *exp, int from_tty);
168 
169 
170 /* Detecting constant expressions. */
171 
172 /* If the variable reference at *PC is a constant, return its value.
173  Otherwise, return zero.
174 
175  Hey, Wally! How can a variable reference be a constant?
176 
177  Well, Beav, this function really handles the OP_VAR_VALUE operator,
178  not specifically variable references. GDB uses OP_VAR_VALUE to
179  refer to any kind of symbolic reference: function names, enum
180  elements, and goto labels are all handled through the OP_VAR_VALUE
181  operator, even though they're constants. It makes sense given the
182  situation.
183 
184  Gee, Wally, don'cha wonder sometimes if data representations that
185  subvert commonly accepted definitions of terms in favor of heavily
186  context-specific interpretations are really just a tool of the
187  programming hegemony to preserve their power and exclude the
188  proletariat? */
189 
190 static struct value *
191 const_var_ref (struct symbol *var)
192 {
193  struct type *type = SYMBOL_TYPE (var);
194 
195  switch (SYMBOL_CLASS (var))
196  {
197  case LOC_CONST:
198  return value_from_longest (type, (LONGEST) SYMBOL_VALUE (var));
199 
200  case LOC_LABEL:
201  return value_from_pointer (type, (CORE_ADDR) SYMBOL_VALUE_ADDRESS (var));
202 
203  default:
204  return 0;
205  }
206 }
207 
208 
209 /* If the expression starting at *PC has a constant value, return it.
210  Otherwise, return zero. If we return a value, then *PC will be
211  advanced to the end of it. If we return zero, *PC could be
212  anywhere. */
213 static struct value *
215 {
216  enum exp_opcode op = (*pc)->opcode;
217  struct value *v1;
218 
219  switch (op)
220  {
221  case OP_LONG:
222  {
223  struct type *type = (*pc)[1].type;
224  LONGEST k = (*pc)[2].longconst;
225 
226  (*pc) += 4;
227  return value_from_longest (type, k);
228  }
229 
230  case OP_VAR_VALUE:
231  {
232  struct value *v = const_var_ref ((*pc)[2].symbol);
233 
234  (*pc) += 4;
235  return v;
236  }
237 
238  /* We could add more operators in here. */
239 
240  case UNOP_NEG:
241  (*pc)++;
242  v1 = const_expr (pc);
243  if (v1)
244  return value_neg (v1);
245  else
246  return 0;
247 
248  default:
249  return 0;
250  }
251 }
252 
253 
254 /* Like const_expr, but guarantee also that *PC is undisturbed if the
255  expression is not constant. */
256 static struct value *
258 {
259  union exp_element *tentative_pc = *pc;
260  struct value *v = const_expr (&tentative_pc);
261 
262  /* If we got a value, then update the real PC. */
263  if (v)
264  *pc = tentative_pc;
265 
266  return v;
267 }
268 
269 
270 /* Generating bytecode from GDB expressions: general assumptions */
271 
272 /* Here are a few general assumptions made throughout the code; if you
273  want to make a change that contradicts one of these, then you'd
274  better scan things pretty thoroughly.
275 
276  - We assume that all values occupy one stack element. For example,
277  sometimes we'll swap to get at the left argument to a binary
278  operator. If we decide that void values should occupy no stack
279  elements, or that synthetic arrays (whose size is determined at
280  run time, created by the `@' operator) should occupy two stack
281  elements (address and length), then this will cause trouble.
282 
283  - We assume the stack elements are infinitely wide, and that we
284  don't have to worry what happens if the user requests an
285  operation that is wider than the actual interpreter's stack.
286  That is, it's up to the interpreter to handle directly all the
287  integer widths the user has access to. (Woe betide the language
288  with bignums!)
289 
290  - We don't support side effects. Thus, we don't have to worry about
291  GCC's generalized lvalues, function calls, etc.
292 
293  - We don't support floating point. Many places where we switch on
294  some type don't bother to include cases for floating point; there
295  may be even more subtle ways this assumption exists. For
296  example, the arguments to % must be integers.
297 
298  - We assume all subexpressions have a static, unchanging type. If
299  we tried to support convenience variables, this would be a
300  problem.
301 
302  - All values on the stack should always be fully zero- or
303  sign-extended.
304 
305  (I wasn't sure whether to choose this or its opposite --- that
306  only addresses are assumed extended --- but it turns out that
307  neither convention completely eliminates spurious extend
308  operations (if everything is always extended, then you have to
309  extend after add, because it could overflow; if nothing is
310  extended, then you end up producing extends whenever you change
311  sizes), and this is simpler.) */
312 
313 
314 /* Scan for all static fields in the given class, including any base
315  classes, and generate tracing bytecodes for each. */
316 
317 static void
319  struct agent_expr *ax,
320  struct type *type)
321 {
322  int i, nbases = TYPE_N_BASECLASSES (type);
323  struct axs_value value;
324 
325  CHECK_TYPEDEF (type);
326 
327  for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
328  {
329  if (field_is_static (&TYPE_FIELD (type, i)))
330  {
331  gen_static_field (gdbarch, ax, &value, type, i);
332  if (value.optimized_out)
333  continue;
334  switch (value.kind)
335  {
336  case axs_lvalue_memory:
337  {
338  /* Initialize the TYPE_LENGTH if it is a typedef. */
339  check_typedef (value.type);
340  ax_const_l (ax, TYPE_LENGTH (value.type));
341  ax_simple (ax, aop_trace);
342  }
343  break;
344 
345  case axs_lvalue_register:
346  /* We don't actually need the register's value to be pushed,
347  just note that we need it to be collected. */
348  ax_reg_mask (ax, value.u.reg);
349 
350  default:
351  break;
352  }
353  }
354  }
355 
356  /* Now scan through base classes recursively. */
357  for (i = 0; i < nbases; i++)
358  {
359  struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
360 
361  gen_trace_static_fields (gdbarch, ax, basetype);
362  }
363 }
364 
365 /* Trace the lvalue on the stack, if it needs it. In either case, pop
366  the value. Useful on the left side of a comma, and at the end of
367  an expression being used for tracing. */
368 static void
370  struct agent_expr *ax, struct axs_value *value)
371 {
372  int string_trace = 0;
373  if (ax->trace_string
374  && TYPE_CODE (value->type) == TYPE_CODE_PTR
376  's'))
377  string_trace = 1;
378 
379  if (ax->tracing)
380  switch (value->kind)
381  {
382  case axs_rvalue:
383  if (string_trace)
384  {
385  ax_const_l (ax, ax->trace_string);
386  ax_simple (ax, aop_tracenz);
387  }
388  else
389  /* We don't trace rvalues, just the lvalues necessary to
390  produce them. So just dispose of this value. */
391  ax_simple (ax, aop_pop);
392  break;
393 
394  case axs_lvalue_memory:
395  {
396  if (string_trace)
397  ax_simple (ax, aop_dup);
398 
399  /* Initialize the TYPE_LENGTH if it is a typedef. */
400  check_typedef (value->type);
401 
402  /* There's no point in trying to use a trace_quick bytecode
403  here, since "trace_quick SIZE pop" is three bytes, whereas
404  "const8 SIZE trace" is also three bytes, does the same
405  thing, and the simplest code which generates that will also
406  work correctly for objects with large sizes. */
407  ax_const_l (ax, TYPE_LENGTH (value->type));
408  ax_simple (ax, aop_trace);
409 
410  if (string_trace)
411  {
412  ax_simple (ax, aop_ref32);
413  ax_const_l (ax, ax->trace_string);
414  ax_simple (ax, aop_tracenz);
415  }
416  }
417  break;
418 
419  case axs_lvalue_register:
420  /* We don't actually need the register's value to be on the
421  stack, and the target will get heartburn if the register is
422  larger than will fit in a stack, so just mark it for
423  collection and be done with it. */
424  ax_reg_mask (ax, value->u.reg);
425 
426  /* But if the register points to a string, assume the value
427  will fit on the stack and push it anyway. */
428  if (string_trace)
429  {
430  ax_reg (ax, value->u.reg);
431  ax_const_l (ax, ax->trace_string);
432  ax_simple (ax, aop_tracenz);
433  }
434  break;
435  }
436  else
437  /* If we're not tracing, just pop the value. */
438  ax_simple (ax, aop_pop);
439 
440  /* To trace C++ classes with static fields stored elsewhere. */
441  if (ax->tracing
442  && (TYPE_CODE (value->type) == TYPE_CODE_STRUCT
443  || TYPE_CODE (value->type) == TYPE_CODE_UNION))
444  gen_trace_static_fields (gdbarch, ax, value->type);
445 }
446 
447 
448 
449 /* Generating bytecode from GDB expressions: helper functions */
450 
451 /* Assume that the lower bits of the top of the stack is a value of
452  type TYPE, and the upper bits are zero. Sign-extend if necessary. */
453 static void
454 gen_sign_extend (struct agent_expr *ax, struct type *type)
455 {
456  /* Do we need to sign-extend this? */
457  if (!TYPE_UNSIGNED (type))
458  ax_ext (ax, TYPE_LENGTH (type) * TARGET_CHAR_BIT);
459 }
460 
461 
462 /* Assume the lower bits of the top of the stack hold a value of type
463  TYPE, and the upper bits are garbage. Sign-extend or truncate as
464  needed. */
465 static void
466 gen_extend (struct agent_expr *ax, struct type *type)
467 {
468  int bits = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
469 
470  /* I just had to. */
471  ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, bits));
472 }
473 
474 
475 /* Assume that the top of the stack contains a value of type "pointer
476  to TYPE"; generate code to fetch its value. Note that TYPE is the
477  target type, not the pointer type. */
478 static void
479 gen_fetch (struct agent_expr *ax, struct type *type)
480 {
481  if (ax->tracing)
482  {
483  /* Record the area of memory we're about to fetch. */
484  ax_trace_quick (ax, TYPE_LENGTH (type));
485  }
486 
487  if (TYPE_CODE (type) == TYPE_CODE_RANGE)
488  type = TYPE_TARGET_TYPE (type);
489 
490  switch (TYPE_CODE (type))
491  {
492  case TYPE_CODE_PTR:
493  case TYPE_CODE_REF:
494  case TYPE_CODE_ENUM:
495  case TYPE_CODE_INT:
496  case TYPE_CODE_CHAR:
497  case TYPE_CODE_BOOL:
498  /* It's a scalar value, so we know how to dereference it. How
499  many bytes long is it? */
500  switch (TYPE_LENGTH (type))
501  {
502  case 8 / TARGET_CHAR_BIT:
503  ax_simple (ax, aop_ref8);
504  break;
505  case 16 / TARGET_CHAR_BIT:
506  ax_simple (ax, aop_ref16);
507  break;
508  case 32 / TARGET_CHAR_BIT:
509  ax_simple (ax, aop_ref32);
510  break;
511  case 64 / TARGET_CHAR_BIT:
512  ax_simple (ax, aop_ref64);
513  break;
514 
515  /* Either our caller shouldn't have asked us to dereference
516  that pointer (other code's fault), or we're not
517  implementing something we should be (this code's fault).
518  In any case, it's a bug the user shouldn't see. */
519  default:
520  internal_error (__FILE__, __LINE__,
521  _("gen_fetch: strange size"));
522  }
523 
524  gen_sign_extend (ax, type);
525  break;
526 
527  default:
528  /* Our caller requested us to dereference a pointer from an unsupported
529  type. Error out and give callers a chance to handle the failure
530  gracefully. */
531  error (_("gen_fetch: Unsupported type code `%s'."),
532  TYPE_NAME (type));
533  }
534 }
535 
536 
537 /* Generate code to left shift the top of the stack by DISTANCE bits, or
538  right shift it by -DISTANCE bits if DISTANCE < 0. This generates
539  unsigned (logical) right shifts. */
540 static void
541 gen_left_shift (struct agent_expr *ax, int distance)
542 {
543  if (distance > 0)
544  {
545  ax_const_l (ax, distance);
546  ax_simple (ax, aop_lsh);
547  }
548  else if (distance < 0)
549  {
550  ax_const_l (ax, -distance);
551  ax_simple (ax, aop_rsh_unsigned);
552  }
553 }
554 
555 
556 
557 /* Generating bytecode from GDB expressions: symbol references */
558 
559 /* Generate code to push the base address of the argument portion of
560  the top stack frame. */
561 static void
563 {
564  int frame_reg;
565  LONGEST frame_offset;
566 
568  ax->scope, &frame_reg, &frame_offset);
569  ax_reg (ax, frame_reg);
570  gen_offset (ax, frame_offset);
571 }
572 
573 
574 /* Generate code to push the base address of the locals portion of the
575  top stack frame. */
576 static void
578 {
579  int frame_reg;
580  LONGEST frame_offset;
581 
583  ax->scope, &frame_reg, &frame_offset);
584  ax_reg (ax, frame_reg);
585  gen_offset (ax, frame_offset);
586 }
587 
588 
589 /* Generate code to add OFFSET to the top of the stack. Try to
590  generate short and readable code. We use this for getting to
591  variables on the stack, and structure members. If we were
592  programming in ML, it would be clearer why these are the same
593  thing. */
594 static void
595 gen_offset (struct agent_expr *ax, int offset)
596 {
597  /* It would suffice to simply push the offset and add it, but this
598  makes it easier to read positive and negative offsets in the
599  bytecode. */
600  if (offset > 0)
601  {
602  ax_const_l (ax, offset);
603  ax_simple (ax, aop_add);
604  }
605  else if (offset < 0)
606  {
607  ax_const_l (ax, -offset);
608  ax_simple (ax, aop_sub);
609  }
610 }
611 
612 
613 /* In many cases, a symbol's value is the offset from some other
614  address (stack frame, base register, etc.) Generate code to add
615  VAR's value to the top of the stack. */
616 static void
617 gen_sym_offset (struct agent_expr *ax, struct symbol *var)
618 {
619  gen_offset (ax, SYMBOL_VALUE (var));
620 }
621 
622 
623 /* Generate code for a variable reference to AX. The variable is the
624  symbol VAR. Set VALUE to describe the result. */
625 
626 static void
627 gen_var_ref (struct gdbarch *gdbarch, struct agent_expr *ax,
628  struct axs_value *value, struct symbol *var)
629 {
630  /* Dereference any typedefs. */
631  value->type = check_typedef (SYMBOL_TYPE (var));
632  value->optimized_out = 0;
633 
634  if (SYMBOL_COMPUTED_OPS (var) != NULL)
635  {
636  SYMBOL_COMPUTED_OPS (var)->tracepoint_var_ref (var, gdbarch, ax, value);
637  return;
638  }
639 
640  /* I'm imitating the code in read_var_value. */
641  switch (SYMBOL_CLASS (var))
642  {
643  case LOC_CONST: /* A constant, like an enum value. */
644  ax_const_l (ax, (LONGEST) SYMBOL_VALUE (var));
645  value->kind = axs_rvalue;
646  break;
647 
648  case LOC_LABEL: /* A goto label, being used as a value. */
650  value->kind = axs_rvalue;
651  break;
652 
653  case LOC_CONST_BYTES:
654  internal_error (__FILE__, __LINE__,
655  _("gen_var_ref: LOC_CONST_BYTES "
656  "symbols are not supported"));
657 
658  /* Variable at a fixed location in memory. Easy. */
659  case LOC_STATIC:
660  /* Push the address of the variable. */
661  ax_const_l (ax, SYMBOL_VALUE_ADDRESS (var));
662  value->kind = axs_lvalue_memory;
663  break;
664 
665  case LOC_ARG: /* var lives in argument area of frame */
666  gen_frame_args_address (gdbarch, ax);
667  gen_sym_offset (ax, var);
668  value->kind = axs_lvalue_memory;
669  break;
670 
671  case LOC_REF_ARG: /* As above, but the frame slot really
672  holds the address of the variable. */
673  gen_frame_args_address (gdbarch, ax);
674  gen_sym_offset (ax, var);
675  /* Don't assume any particular pointer size. */
676  gen_fetch (ax, builtin_type (gdbarch)->builtin_data_ptr);
677  value->kind = axs_lvalue_memory;
678  break;
679 
680  case LOC_LOCAL: /* var lives in locals area of frame */
681  gen_frame_locals_address (gdbarch, ax);
682  gen_sym_offset (ax, var);
683  value->kind = axs_lvalue_memory;
684  break;
685 
686  case LOC_TYPEDEF:
687  error (_("Cannot compute value of typedef `%s'."),
688  SYMBOL_PRINT_NAME (var));
689  break;
690 
691  case LOC_BLOCK:
693  value->kind = axs_rvalue;
694  break;
695 
696  case LOC_REGISTER:
697  /* Don't generate any code at all; in the process of treating
698  this as an lvalue or rvalue, the caller will generate the
699  right code. */
700  value->kind = axs_lvalue_register;
701  value->u.reg = SYMBOL_REGISTER_OPS (var)->register_number (var, gdbarch);
702  break;
703 
704  /* A lot like LOC_REF_ARG, but the pointer lives directly in a
705  register, not on the stack. Simpler than LOC_REGISTER
706  because it's just like any other case where the thing
707  has a real address. */
708  case LOC_REGPARM_ADDR:
709  ax_reg (ax, SYMBOL_REGISTER_OPS (var)->register_number (var, gdbarch));
710  value->kind = axs_lvalue_memory;
711  break;
712 
713  case LOC_UNRESOLVED:
714  {
715  struct bound_minimal_symbol msym
716  = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL);
717 
718  if (!msym.minsym)
719  error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var));
720 
721  /* Push the address of the variable. */
722  ax_const_l (ax, BMSYMBOL_VALUE_ADDRESS (msym));
723  value->kind = axs_lvalue_memory;
724  }
725  break;
726 
727  case LOC_COMPUTED:
728  gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
729 
730  case LOC_OPTIMIZED_OUT:
731  /* Flag this, but don't say anything; leave it up to callers to
732  warn the user. */
733  value->optimized_out = 1;
734  break;
735 
736  default:
737  error (_("Cannot find value of botched symbol `%s'."),
738  SYMBOL_PRINT_NAME (var));
739  break;
740  }
741 }
742 
743 
744 
745 /* Generating bytecode from GDB expressions: literals */
746 
747 static void
749  struct type *type)
750 {
751  ax_const_l (ax, k);
752  value->kind = axs_rvalue;
753  value->type = check_typedef (type);
754 }
755 
756 
757 
758 /* Generating bytecode from GDB expressions: unary conversions, casts */
759 
760 /* Take what's on the top of the stack (as described by VALUE), and
761  try to make an rvalue out of it. Signal an error if we can't do
762  that. */
763 void
765 {
766  /* Only deal with scalars, structs and such may be too large
767  to fit in a stack entry. */
768  value->type = check_typedef (value->type);
769  if (TYPE_CODE (value->type) == TYPE_CODE_ARRAY
770  || TYPE_CODE (value->type) == TYPE_CODE_STRUCT
771  || TYPE_CODE (value->type) == TYPE_CODE_UNION
772  || TYPE_CODE (value->type) == TYPE_CODE_FUNC)
773  error (_("Value not scalar: cannot be an rvalue."));
774 
775  switch (value->kind)
776  {
777  case axs_rvalue:
778  /* It's already an rvalue. */
779  break;
780 
781  case axs_lvalue_memory:
782  /* The top of stack is the address of the object. Dereference. */
783  gen_fetch (ax, value->type);
784  break;
785 
786  case axs_lvalue_register:
787  /* There's nothing on the stack, but value->u.reg is the
788  register number containing the value.
789 
790  When we add floating-point support, this is going to have to
791  change. What about SPARC register pairs, for example? */
792  ax_reg (ax, value->u.reg);
793  gen_extend (ax, value->type);
794  break;
795  }
796 
797  value->kind = axs_rvalue;
798 }
799 
800 
801 /* Assume the top of the stack is described by VALUE, and perform the
802  usual unary conversions. This is motivated by ANSI 6.2.2, but of
803  course GDB expressions are not ANSI; they're the mishmash union of
804  a bunch of languages. Rah.
805 
806  NOTE! This function promises to produce an rvalue only when the
807  incoming value is of an appropriate type. In other words, the
808  consumer of the value this function produces may assume the value
809  is an rvalue only after checking its type.
810 
811  The immediate issue is that if the user tries to use a structure or
812  union as an operand of, say, the `+' operator, we don't want to try
813  to convert that structure to an rvalue; require_rvalue will bomb on
814  structs and unions. Rather, we want to simply pass the struct
815  lvalue through unchanged, and let `+' raise an error. */
816 
817 static void
818 gen_usual_unary (struct expression *exp, struct agent_expr *ax,
819  struct axs_value *value)
820 {
821  /* We don't have to generate any code for the usual integral
822  conversions, since values are always represented as full-width on
823  the stack. Should we tweak the type? */
824 
825  /* Some types require special handling. */
826  switch (TYPE_CODE (value->type))
827  {
828  /* Functions get converted to a pointer to the function. */
829  case TYPE_CODE_FUNC:
830  value->type = lookup_pointer_type (value->type);
831  value->kind = axs_rvalue; /* Should always be true, but just in case. */
832  break;
833 
834  /* Arrays get converted to a pointer to their first element, and
835  are no longer an lvalue. */
836  case TYPE_CODE_ARRAY:
837  {
838  struct type *elements = TYPE_TARGET_TYPE (value->type);
839 
840  value->type = lookup_pointer_type (elements);
841  value->kind = axs_rvalue;
842  /* We don't need to generate any code; the address of the array
843  is also the address of its first element. */
844  }
845  break;
846 
847  /* Don't try to convert structures and unions to rvalues. Let the
848  consumer signal an error. */
849  case TYPE_CODE_STRUCT:
850  case TYPE_CODE_UNION:
851  return;
852  }
853 
854  /* If the value is an lvalue, dereference it. */
855  require_rvalue (ax, value);
856 }
857 
858 
859 /* Return non-zero iff the type TYPE1 is considered "wider" than the
860  type TYPE2, according to the rules described in gen_usual_arithmetic. */
861 static int
862 type_wider_than (struct type *type1, struct type *type2)
863 {
864  return (TYPE_LENGTH (type1) > TYPE_LENGTH (type2)
865  || (TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
866  && TYPE_UNSIGNED (type1)
867  && !TYPE_UNSIGNED (type2)));
868 }
869 
870 
871 /* Return the "wider" of the two types TYPE1 and TYPE2. */
872 static struct type *
873 max_type (struct type *type1, struct type *type2)
874 {
875  return type_wider_than (type1, type2) ? type1 : type2;
876 }
877 
878 
879 /* Generate code to convert a scalar value of type FROM to type TO. */
880 static void
881 gen_conversion (struct agent_expr *ax, struct type *from, struct type *to)
882 {
883  /* Perhaps there is a more graceful way to state these rules. */
884 
885  /* If we're converting to a narrower type, then we need to clear out
886  the upper bits. */
887  if (TYPE_LENGTH (to) < TYPE_LENGTH (from))
888  gen_extend (ax, to);
889 
890  /* If the two values have equal width, but different signednesses,
891  then we need to extend. */
892  else if (TYPE_LENGTH (to) == TYPE_LENGTH (from))
893  {
894  if (TYPE_UNSIGNED (from) != TYPE_UNSIGNED (to))
895  gen_extend (ax, to);
896  }
897 
898  /* If we're converting to a wider type, and becoming unsigned, then
899  we need to zero out any possible sign bits. */
900  else if (TYPE_LENGTH (to) > TYPE_LENGTH (from))
901  {
902  if (TYPE_UNSIGNED (to))
903  gen_extend (ax, to);
904  }
905 }
906 
907 
908 /* Return non-zero iff the type FROM will require any bytecodes to be
909  emitted to be converted to the type TO. */
910 static int
912 {
913  struct agent_expr *ax = new_agent_expr (NULL, 0);
914  int nontrivial;
915 
916  /* Actually generate the code, and see if anything came out. At the
917  moment, it would be trivial to replicate the code in
918  gen_conversion here, but in the future, when we're supporting
919  floating point and the like, it may not be. Doing things this
920  way allows this function to be independent of the logic in
921  gen_conversion. */
922  gen_conversion (ax, from, to);
923  nontrivial = ax->len > 0;
924  free_agent_expr (ax);
925  return nontrivial;
926 }
927 
928 
929 /* Generate code to perform the "usual arithmetic conversions" (ANSI C
930  6.2.1.5) for the two operands of an arithmetic operator. This
931  effectively finds a "least upper bound" type for the two arguments,
932  and promotes each argument to that type. *VALUE1 and *VALUE2
933  describe the values as they are passed in, and as they are left. */
934 static void
935 gen_usual_arithmetic (struct expression *exp, struct agent_expr *ax,
936  struct axs_value *value1, struct axs_value *value2)
937 {
938  /* Do the usual binary conversions. */
939  if (TYPE_CODE (value1->type) == TYPE_CODE_INT
940  && TYPE_CODE (value2->type) == TYPE_CODE_INT)
941  {
942  /* The ANSI integral promotions seem to work this way: Order the
943  integer types by size, and then by signedness: an n-bit
944  unsigned type is considered "wider" than an n-bit signed
945  type. Promote to the "wider" of the two types, and always
946  promote at least to int. */
947  struct type *target = max_type (builtin_type (exp->gdbarch)->builtin_int,
948  max_type (value1->type, value2->type));
949 
950  /* Deal with value2, on the top of the stack. */
951  gen_conversion (ax, value2->type, target);
952 
953  /* Deal with value1, not on the top of the stack. Don't
954  generate the `swap' instructions if we're not actually going
955  to do anything. */
956  if (is_nontrivial_conversion (value1->type, target))
957  {
958  ax_simple (ax, aop_swap);
959  gen_conversion (ax, value1->type, target);
960  ax_simple (ax, aop_swap);
961  }
962 
963  value1->type = value2->type = check_typedef (target);
964  }
965 }
966 
967 
968 /* Generate code to perform the integral promotions (ANSI 6.2.1.1) on
969  the value on the top of the stack, as described by VALUE. Assume
970  the value has integral type. */
971 static void
973  struct axs_value *value)
974 {
975  const struct builtin_type *builtin = builtin_type (exp->gdbarch);
976 
977  if (!type_wider_than (value->type, builtin->builtin_int))
978  {
979  gen_conversion (ax, value->type, builtin->builtin_int);
980  value->type = builtin->builtin_int;
981  }
982  else if (!type_wider_than (value->type, builtin->builtin_unsigned_int))
983  {
984  gen_conversion (ax, value->type, builtin->builtin_unsigned_int);
985  value->type = builtin->builtin_unsigned_int;
986  }
987 }
988 
989 
990 /* Generate code for a cast to TYPE. */
991 static void
992 gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type)
993 {
994  /* GCC does allow casts to yield lvalues, so this should be fixed
995  before merging these changes into the trunk. */
996  require_rvalue (ax, value);
997  /* Dereference typedefs. */
998  type = check_typedef (type);
999 
1000  switch (TYPE_CODE (type))
1001  {
1002  case TYPE_CODE_PTR:
1003  case TYPE_CODE_REF:
1004  /* It's implementation-defined, and I'll bet this is what GCC
1005  does. */
1006  break;
1007 
1008  case TYPE_CODE_ARRAY:
1009  case TYPE_CODE_STRUCT:
1010  case TYPE_CODE_UNION:
1011  case TYPE_CODE_FUNC:
1012  error (_("Invalid type cast: intended type must be scalar."));
1013 
1014  case TYPE_CODE_ENUM:
1015  case TYPE_CODE_BOOL:
1016  /* We don't have to worry about the size of the value, because
1017  all our integral values are fully sign-extended, and when
1018  casting pointers we can do anything we like. Is there any
1019  way for us to know what GCC actually does with a cast like
1020  this? */
1021  break;
1022 
1023  case TYPE_CODE_INT:
1024  gen_conversion (ax, value->type, type);
1025  break;
1026 
1027  case TYPE_CODE_VOID:
1028  /* We could pop the value, and rely on everyone else to check
1029  the type and notice that this value doesn't occupy a stack
1030  slot. But for now, leave the value on the stack, and
1031  preserve the "value == stack element" assumption. */
1032  break;
1033 
1034  default:
1035  error (_("Casts to requested type are not yet implemented."));
1036  }
1037 
1038  value->type = type;
1039 }
1040 
1041 
1042 
1043 /* Generating bytecode from GDB expressions: arithmetic */
1044 
1045 /* Scale the integer on the top of the stack by the size of the target
1046  of the pointer type TYPE. */
1047 static void
1048 gen_scale (struct agent_expr *ax, enum agent_op op, struct type *type)
1049 {
1050  struct type *element = TYPE_TARGET_TYPE (type);
1051 
1052  if (TYPE_LENGTH (element) != 1)
1053  {
1054  ax_const_l (ax, TYPE_LENGTH (element));
1055  ax_simple (ax, op);
1056  }
1057 }
1058 
1059 
1060 /* Generate code for pointer arithmetic PTR + INT. */
1061 static void
1062 gen_ptradd (struct agent_expr *ax, struct axs_value *value,
1063  struct axs_value *value1, struct axs_value *value2)
1064 {
1065  gdb_assert (pointer_type (value1->type));
1066  gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_INT);
1067 
1068  gen_scale (ax, aop_mul, value1->type);
1069  ax_simple (ax, aop_add);
1070  gen_extend (ax, value1->type); /* Catch overflow. */
1071  value->type = value1->type;
1072  value->kind = axs_rvalue;
1073 }
1074 
1075 
1076 /* Generate code for pointer arithmetic PTR - INT. */
1077 static void
1078 gen_ptrsub (struct agent_expr *ax, struct axs_value *value,
1079  struct axs_value *value1, struct axs_value *value2)
1080 {
1081  gdb_assert (pointer_type (value1->type));
1082  gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_INT);
1083 
1084  gen_scale (ax, aop_mul, value1->type);
1085  ax_simple (ax, aop_sub);
1086  gen_extend (ax, value1->type); /* Catch overflow. */
1087  value->type = value1->type;
1088  value->kind = axs_rvalue;
1089 }
1090 
1091 
1092 /* Generate code for pointer arithmetic PTR - PTR. */
1093 static void
1094 gen_ptrdiff (struct agent_expr *ax, struct axs_value *value,
1095  struct axs_value *value1, struct axs_value *value2,
1096  struct type *result_type)
1097 {
1098  gdb_assert (pointer_type (value1->type));
1099  gdb_assert (pointer_type (value2->type));
1100 
1101  if (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type))
1102  != TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type)))
1103  error (_("\
1104 First argument of `-' is a pointer, but second argument is neither\n\
1105 an integer nor a pointer of the same type."));
1106 
1107  ax_simple (ax, aop_sub);
1108  gen_scale (ax, aop_div_unsigned, value1->type);
1109  value->type = result_type;
1110  value->kind = axs_rvalue;
1111 }
1112 
1113 static void
1114 gen_equal (struct agent_expr *ax, struct axs_value *value,
1115  struct axs_value *value1, struct axs_value *value2,
1116  struct type *result_type)
1117 {
1118  if (pointer_type (value1->type) || pointer_type (value2->type))
1119  ax_simple (ax, aop_equal);
1120  else
1121  gen_binop (ax, value, value1, value2,
1122  aop_equal, aop_equal, 0, "equal");
1123  value->type = result_type;
1124  value->kind = axs_rvalue;
1125 }
1126 
1127 static void
1128 gen_less (struct agent_expr *ax, struct axs_value *value,
1129  struct axs_value *value1, struct axs_value *value2,
1130  struct type *result_type)
1131 {
1132  if (pointer_type (value1->type) || pointer_type (value2->type))
1133  ax_simple (ax, aop_less_unsigned);
1134  else
1135  gen_binop (ax, value, value1, value2,
1136  aop_less_signed, aop_less_unsigned, 0, "less than");
1137  value->type = result_type;
1138  value->kind = axs_rvalue;
1139 }
1140 
1141 /* Generate code for a binary operator that doesn't do pointer magic.
1142  We set VALUE to describe the result value; we assume VALUE1 and
1143  VALUE2 describe the two operands, and that they've undergone the
1144  usual binary conversions. MAY_CARRY should be non-zero iff the
1145  result needs to be extended. NAME is the English name of the
1146  operator, used in error messages */
1147 static void
1148 gen_binop (struct agent_expr *ax, struct axs_value *value,
1149  struct axs_value *value1, struct axs_value *value2,
1150  enum agent_op op, enum agent_op op_unsigned,
1151  int may_carry, char *name)
1152 {
1153  /* We only handle INT op INT. */
1154  if ((TYPE_CODE (value1->type) != TYPE_CODE_INT)
1155  || (TYPE_CODE (value2->type) != TYPE_CODE_INT))
1156  error (_("Invalid combination of types in %s."), name);
1157 
1158  ax_simple (ax,
1159  TYPE_UNSIGNED (value1->type) ? op_unsigned : op);
1160  if (may_carry)
1161  gen_extend (ax, value1->type); /* catch overflow */
1162  value->type = value1->type;
1163  value->kind = axs_rvalue;
1164 }
1165 
1166 
1167 static void
1169  struct type *result_type)
1170 {
1171  if (TYPE_CODE (value->type) != TYPE_CODE_INT
1172  && TYPE_CODE (value->type) != TYPE_CODE_PTR)
1173  error (_("Invalid type of operand to `!'."));
1174 
1175  ax_simple (ax, aop_log_not);
1176  value->type = result_type;
1177 }
1178 
1179 
1180 static void
1182 {
1183  if (TYPE_CODE (value->type) != TYPE_CODE_INT)
1184  error (_("Invalid type of operand to `~'."));
1185 
1186  ax_simple (ax, aop_bit_not);
1187  gen_extend (ax, value->type);
1188 }
1189 
1190 
1191 
1192 /* Generating bytecode from GDB expressions: * & . -> @ sizeof */
1193 
1194 /* Dereference the value on the top of the stack. */
1195 static void
1196 gen_deref (struct agent_expr *ax, struct axs_value *value)
1197 {
1198  /* The caller should check the type, because several operators use
1199  this, and we don't know what error message to generate. */
1200  if (!pointer_type (value->type))
1201  internal_error (__FILE__, __LINE__,
1202  _("gen_deref: expected a pointer"));
1203 
1204  /* We've got an rvalue now, which is a pointer. We want to yield an
1205  lvalue, whose address is exactly that pointer. So we don't
1206  actually emit any code; we just change the type from "Pointer to
1207  T" to "T", and mark the value as an lvalue in memory. Leave it
1208  to the consumer to actually dereference it. */
1209  value->type = check_typedef (TYPE_TARGET_TYPE (value->type));
1210  if (TYPE_CODE (value->type) == TYPE_CODE_VOID)
1211  error (_("Attempt to dereference a generic pointer."));
1212  value->kind = ((TYPE_CODE (value->type) == TYPE_CODE_FUNC)
1214 }
1215 
1216 
1217 /* Produce the address of the lvalue on the top of the stack. */
1218 static void
1220 {
1221  /* Special case for taking the address of a function. The ANSI
1222  standard describes this as a special case, too, so this
1223  arrangement is not without motivation. */
1224  if (TYPE_CODE (value->type) == TYPE_CODE_FUNC)
1225  /* The value's already an rvalue on the stack, so we just need to
1226  change the type. */
1227  value->type = lookup_pointer_type (value->type);
1228  else
1229  switch (value->kind)
1230  {
1231  case axs_rvalue:
1232  error (_("Operand of `&' is an rvalue, which has no address."));
1233 
1234  case axs_lvalue_register:
1235  error (_("Operand of `&' is in a register, and has no address."));
1236 
1237  case axs_lvalue_memory:
1238  value->kind = axs_rvalue;
1239  value->type = lookup_pointer_type (value->type);
1240  break;
1241  }
1242 }
1243 
1244 /* Generate code to push the value of a bitfield of a structure whose
1245  address is on the top of the stack. START and END give the
1246  starting and one-past-ending *bit* numbers of the field within the
1247  structure. */
1248 static void
1249 gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
1250  struct axs_value *value, struct type *type,
1251  int start, int end)
1252 {
1253  /* Note that ops[i] fetches 8 << i bits. */
1254  static enum agent_op ops[]
1255  = {aop_ref8, aop_ref16, aop_ref32, aop_ref64};
1256  static int num_ops = (sizeof (ops) / sizeof (ops[0]));
1257 
1258  /* We don't want to touch any byte that the bitfield doesn't
1259  actually occupy; we shouldn't make any accesses we're not
1260  explicitly permitted to. We rely here on the fact that the
1261  bytecode `ref' operators work on unaligned addresses.
1262 
1263  It takes some fancy footwork to get the stack to work the way
1264  we'd like. Say we're retrieving a bitfield that requires three
1265  fetches. Initially, the stack just contains the address:
1266  addr
1267  For the first fetch, we duplicate the address
1268  addr addr
1269  then add the byte offset, do the fetch, and shift and mask as
1270  needed, yielding a fragment of the value, properly aligned for
1271  the final bitwise or:
1272  addr frag1
1273  then we swap, and repeat the process:
1274  frag1 addr --- address on top
1275  frag1 addr addr --- duplicate it
1276  frag1 addr frag2 --- get second fragment
1277  frag1 frag2 addr --- swap again
1278  frag1 frag2 frag3 --- get third fragment
1279  Notice that, since the third fragment is the last one, we don't
1280  bother duplicating the address this time. Now we have all the
1281  fragments on the stack, and we can simply `or' them together,
1282  yielding the final value of the bitfield. */
1283 
1284  /* The first and one-after-last bits in the field, but rounded down
1285  and up to byte boundaries. */
1286  int bound_start = (start / TARGET_CHAR_BIT) * TARGET_CHAR_BIT;
1287  int bound_end = (((end + TARGET_CHAR_BIT - 1)
1288  / TARGET_CHAR_BIT)
1289  * TARGET_CHAR_BIT);
1290 
1291  /* current bit offset within the structure */
1292  int offset;
1293 
1294  /* The index in ops of the opcode we're considering. */
1295  int op;
1296 
1297  /* The number of fragments we generated in the process. Probably
1298  equal to the number of `one' bits in bytesize, but who cares? */
1299  int fragment_count;
1300 
1301  /* Dereference any typedefs. */
1302  type = check_typedef (type);
1303 
1304  /* Can we fetch the number of bits requested at all? */
1305  if ((end - start) > ((1 << num_ops) * 8))
1306  internal_error (__FILE__, __LINE__,
1307  _("gen_bitfield_ref: bitfield too wide"));
1308 
1309  /* Note that we know here that we only need to try each opcode once.
1310  That may not be true on machines with weird byte sizes. */
1311  offset = bound_start;
1312  fragment_count = 0;
1313  for (op = num_ops - 1; op >= 0; op--)
1314  {
1315  /* number of bits that ops[op] would fetch */
1316  int op_size = 8 << op;
1317 
1318  /* The stack at this point, from bottom to top, contains zero or
1319  more fragments, then the address. */
1320 
1321  /* Does this fetch fit within the bitfield? */
1322  if (offset + op_size <= bound_end)
1323  {
1324  /* Is this the last fragment? */
1325  int last_frag = (offset + op_size == bound_end);
1326 
1327  if (!last_frag)
1328  ax_simple (ax, aop_dup); /* keep a copy of the address */
1329 
1330  /* Add the offset. */
1331  gen_offset (ax, offset / TARGET_CHAR_BIT);
1332 
1333  if (ax->tracing)
1334  {
1335  /* Record the area of memory we're about to fetch. */
1336  ax_trace_quick (ax, op_size / TARGET_CHAR_BIT);
1337  }
1338 
1339  /* Perform the fetch. */
1340  ax_simple (ax, ops[op]);
1341 
1342  /* Shift the bits we have to their proper position.
1343  gen_left_shift will generate right shifts when the operand
1344  is negative.
1345 
1346  A big-endian field diagram to ponder:
1347  byte 0 byte 1 byte 2 byte 3 byte 4 byte 5 byte 6 byte 7
1348  +------++------++------++------++------++------++------++------+
1349  xxxxAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCxxxxxxxxxxx
1350  ^ ^ ^ ^
1351  bit number 16 32 48 53
1352  These are bit numbers as supplied by GDB. Note that the
1353  bit numbers run from right to left once you've fetched the
1354  value!
1355 
1356  A little-endian field diagram to ponder:
1357  byte 7 byte 6 byte 5 byte 4 byte 3 byte 2 byte 1 byte 0
1358  +------++------++------++------++------++------++------++------+
1359  xxxxxxxxxxxAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCxxxx
1360  ^ ^ ^ ^ ^
1361  bit number 48 32 16 4 0
1362 
1363  In both cases, the most significant end is on the left
1364  (i.e. normal numeric writing order), which means that you
1365  don't go crazy thinking about `left' and `right' shifts.
1366 
1367  We don't have to worry about masking yet:
1368  - If they contain garbage off the least significant end, then we
1369  must be looking at the low end of the field, and the right
1370  shift will wipe them out.
1371  - If they contain garbage off the most significant end, then we
1372  must be looking at the most significant end of the word, and
1373  the sign/zero extension will wipe them out.
1374  - If we're in the interior of the word, then there is no garbage
1375  on either end, because the ref operators zero-extend. */
1376  if (gdbarch_byte_order (exp->gdbarch) == BFD_ENDIAN_BIG)
1377  gen_left_shift (ax, end - (offset + op_size));
1378  else
1379  gen_left_shift (ax, offset - start);
1380 
1381  if (!last_frag)
1382  /* Bring the copy of the address up to the top. */
1383  ax_simple (ax, aop_swap);
1384 
1385  offset += op_size;
1386  fragment_count++;
1387  }
1388  }
1389 
1390  /* Generate enough bitwise `or' operations to combine all the
1391  fragments we left on the stack. */
1392  while (fragment_count-- > 1)
1393  ax_simple (ax, aop_bit_or);
1394 
1395  /* Sign- or zero-extend the value as appropriate. */
1396  ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, end - start));
1397 
1398  /* This is *not* an lvalue. Ugh. */
1399  value->kind = axs_rvalue;
1400  value->type = type;
1401 }
1402 
1403 /* Generate bytecodes for field number FIELDNO of type TYPE. OFFSET
1404  is an accumulated offset (in bytes), will be nonzero for objects
1405  embedded in other objects, like C++ base classes. Behavior should
1406  generally follow value_primitive_field. */
1407 
1408 static void
1410  struct agent_expr *ax, struct axs_value *value,
1411  int offset, int fieldno, struct type *type)
1412 {
1413  /* Is this a bitfield? */
1414  if (TYPE_FIELD_PACKED (type, fieldno))
1415  gen_bitfield_ref (exp, ax, value, TYPE_FIELD_TYPE (type, fieldno),
1416  (offset * TARGET_CHAR_BIT
1417  + TYPE_FIELD_BITPOS (type, fieldno)),
1418  (offset * TARGET_CHAR_BIT
1419  + TYPE_FIELD_BITPOS (type, fieldno)
1420  + TYPE_FIELD_BITSIZE (type, fieldno)));
1421  else
1422  {
1423  gen_offset (ax, offset
1424  + TYPE_FIELD_BITPOS (type, fieldno) / TARGET_CHAR_BIT);
1425  value->kind = axs_lvalue_memory;
1426  value->type = TYPE_FIELD_TYPE (type, fieldno);
1427  }
1428 }
1429 
1430 /* Search for the given field in either the given type or one of its
1431  base classes. Return 1 if found, 0 if not. */
1432 
1433 static int
1435  struct axs_value *value,
1436  char *field, int offset, struct type *type)
1437 {
1438  int i, rslt;
1439  int nbases = TYPE_N_BASECLASSES (type);
1440 
1441  CHECK_TYPEDEF (type);
1442 
1443  for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
1444  {
1445  const char *this_name = TYPE_FIELD_NAME (type, i);
1446 
1447  if (this_name)
1448  {
1449  if (strcmp (field, this_name) == 0)
1450  {
1451  /* Note that bytecodes for the struct's base (aka
1452  "this") will have been generated already, which will
1453  be unnecessary but not harmful if the static field is
1454  being handled as a global. */
1455  if (field_is_static (&TYPE_FIELD (type, i)))
1456  {
1457  gen_static_field (exp->gdbarch, ax, value, type, i);
1458  if (value->optimized_out)
1459  error (_("static field `%s' has been "
1460  "optimized out, cannot use"),
1461  field);
1462  return 1;
1463  }
1464 
1465  gen_primitive_field (exp, ax, value, offset, i, type);
1466  return 1;
1467  }
1468 #if 0 /* is this right? */
1469  if (this_name[0] == '\0')
1470  internal_error (__FILE__, __LINE__,
1471  _("find_field: anonymous unions not supported"));
1472 #endif
1473  }
1474  }
1475 
1476  /* Now scan through base classes recursively. */
1477  for (i = 0; i < nbases; i++)
1478  {
1479  struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
1480 
1481  rslt = gen_struct_ref_recursive (exp, ax, value, field,
1482  offset + TYPE_BASECLASS_BITPOS (type, i)
1483  / TARGET_CHAR_BIT,
1484  basetype);
1485  if (rslt)
1486  return 1;
1487  }
1488 
1489  /* Not found anywhere, flag so caller can complain. */
1490  return 0;
1491 }
1492 
1493 /* Generate code to reference the member named FIELD of a structure or
1494  union. The top of the stack, as described by VALUE, should have
1495  type (pointer to a)* struct/union. OPERATOR_NAME is the name of
1496  the operator being compiled, and OPERAND_NAME is the kind of thing
1497  it operates on; we use them in error messages. */
1498 static void
1499 gen_struct_ref (struct expression *exp, struct agent_expr *ax,
1500  struct axs_value *value, char *field,
1501  char *operator_name, char *operand_name)
1502 {
1503  struct type *type;
1504  int found;
1505 
1506  /* Follow pointers until we reach a non-pointer. These aren't the C
1507  semantics, but they're what the normal GDB evaluator does, so we
1508  should at least be consistent. */
1509  while (pointer_type (value->type))
1510  {
1511  require_rvalue (ax, value);
1512  gen_deref (ax, value);
1513  }
1514  type = check_typedef (value->type);
1515 
1516  /* This must yield a structure or a union. */
1517  if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1518  && TYPE_CODE (type) != TYPE_CODE_UNION)
1519  error (_("The left operand of `%s' is not a %s."),
1520  operator_name, operand_name);
1521 
1522  /* And it must be in memory; we don't deal with structure rvalues,
1523  or structures living in registers. */
1524  if (value->kind != axs_lvalue_memory)
1525  error (_("Structure does not live in memory."));
1526 
1527  /* Search through fields and base classes recursively. */
1528  found = gen_struct_ref_recursive (exp, ax, value, field, 0, type);
1529 
1530  if (!found)
1531  error (_("Couldn't find member named `%s' in struct/union/class `%s'"),
1532  field, TYPE_TAG_NAME (type));
1533 }
1534 
1535 static int
1536 gen_namespace_elt (struct expression *exp,
1537  struct agent_expr *ax, struct axs_value *value,
1538  const struct type *curtype, char *name);
1539 static int
1540 gen_maybe_namespace_elt (struct expression *exp,
1541  struct agent_expr *ax, struct axs_value *value,
1542  const struct type *curtype, char *name);
1543 
1544 static void
1546  struct agent_expr *ax, struct axs_value *value,
1547  struct type *type, int fieldno)
1548 {
1549  if (TYPE_FIELD_LOC_KIND (type, fieldno) == FIELD_LOC_KIND_PHYSADDR)
1550  {
1551  ax_const_l (ax, TYPE_FIELD_STATIC_PHYSADDR (type, fieldno));
1552  value->kind = axs_lvalue_memory;
1553  value->type = TYPE_FIELD_TYPE (type, fieldno);
1554  value->optimized_out = 0;
1555  }
1556  else
1557  {
1558  const char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
1559  struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0);
1560 
1561  if (sym)
1562  {
1563  gen_var_ref (gdbarch, ax, value, sym);
1564 
1565  /* Don't error if the value was optimized out, we may be
1566  scanning all static fields and just want to pass over this
1567  and continue with the rest. */
1568  }
1569  else
1570  {
1571  /* Silently assume this was optimized out; class printing
1572  will let the user know why the data is missing. */
1573  value->optimized_out = 1;
1574  }
1575  }
1576 }
1577 
1578 static int
1580  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 (exp->gdbarch, 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 (exp, 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
1626  struct agent_expr *ax, struct axs_value *value,
1627  const struct type *curtype, char *name)
1628 {
1629  int found = gen_maybe_namespace_elt (exp, ax, value, curtype, name);
1630 
1631  if (!found)
1632  error (_("No symbol \"%s\" in namespace \"%s\"."),
1633  name, TYPE_TAG_NAME (curtype));
1634 
1635  return found;
1636 }
1637 
1638 /* A helper function used by value_namespace_elt and
1639  value_struct_elt_for_reference. It looks up NAME inside the
1640  context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
1641  is a class and NAME refers to a type in CURTYPE itself (as opposed
1642  to, say, some base class of CURTYPE). */
1643 
1644 static int
1646  struct agent_expr *ax, struct axs_value *value,
1647  const struct type *curtype, char *name)
1648 {
1649  const char *namespace_name = TYPE_TAG_NAME (curtype);
1650  struct symbol *sym;
1651 
1652  sym = cp_lookup_symbol_namespace (namespace_name, name,
1653  block_for_pc (ax->scope),
1654  VAR_DOMAIN);
1655 
1656  if (sym == NULL)
1657  return 0;
1658 
1659  gen_var_ref (exp->gdbarch, ax, value, sym);
1660 
1661  if (value->optimized_out)
1662  error (_("`%s' has been optimized out, cannot use"),
1663  SYMBOL_PRINT_NAME (sym));
1664 
1665  return 1;
1666 }
1667 
1668 
1669 static int
1671  struct agent_expr *ax, struct axs_value *value,
1672  struct type *type, char *field,
1673  char *operator_name, char *operand_name)
1674 {
1675  switch (TYPE_CODE (type))
1676  {
1677  case TYPE_CODE_STRUCT:
1678  case TYPE_CODE_UNION:
1679  return gen_struct_elt_for_reference (exp, ax, value, type, field);
1680  break;
1681  case TYPE_CODE_NAMESPACE:
1682  return gen_namespace_elt (exp, ax, value, type, field);
1683  break;
1684  default:
1685  internal_error (__FILE__, __LINE__,
1686  _("non-aggregate type in gen_aggregate_elt_ref"));
1687  }
1688 
1689  return 0;
1690 }
1691 
1692 /* Generate code for GDB's magical `repeat' operator.
1693  LVALUE @ INT creates an array INT elements long, and whose elements
1694  have the same type as LVALUE, located in memory so that LVALUE is
1695  its first element. For example, argv[0]@argc gives you the array
1696  of command-line arguments.
1697 
1698  Unfortunately, because we have to know the types before we actually
1699  have a value for the expression, we can't implement this perfectly
1700  without changing the type system, having values that occupy two
1701  stack slots, doing weird things with sizeof, etc. So we require
1702  the right operand to be a constant expression. */
1703 static void
1704 gen_repeat (struct expression *exp, union exp_element **pc,
1705  struct agent_expr *ax, struct axs_value *value)
1706 {
1707  struct axs_value value1;
1708 
1709  /* We don't want to turn this into an rvalue, so no conversions
1710  here. */
1711  gen_expr (exp, pc, ax, &value1);
1712  if (value1.kind != axs_lvalue_memory)
1713  error (_("Left operand of `@' must be an object in memory."));
1714 
1715  /* Evaluate the length; it had better be a constant. */
1716  {
1717  struct value *v = const_expr (pc);
1718  int length;
1719 
1720  if (!v)
1721  error (_("Right operand of `@' must be a "
1722  "constant, in agent expressions."));
1723  if (TYPE_CODE (value_type (v)) != TYPE_CODE_INT)
1724  error (_("Right operand of `@' must be an integer."));
1725  length = value_as_long (v);
1726  if (length <= 0)
1727  error (_("Right operand of `@' must be positive."));
1728 
1729  /* The top of the stack is already the address of the object, so
1730  all we need to do is frob the type of the lvalue. */
1731  {
1732  /* FIXME-type-allocation: need a way to free this type when we are
1733  done with it. */
1734  struct type *array
1735  = lookup_array_range_type (value1.type, 0, length - 1);
1736 
1737  value->kind = axs_lvalue_memory;
1738  value->type = array;
1739  }
1740  }
1741 }
1742 
1743 
1744 /* Emit code for the `sizeof' operator.
1745  *PC should point at the start of the operand expression; we advance it
1746  to the first instruction after the operand. */
1747 static void
1748 gen_sizeof (struct expression *exp, union exp_element **pc,
1749  struct agent_expr *ax, struct axs_value *value,
1750  struct type *size_type)
1751 {
1752  /* We don't care about the value of the operand expression; we only
1753  care about its type. However, in the current arrangement, the
1754  only way to find an expression's type is to generate code for it.
1755  So we generate code for the operand, and then throw it away,
1756  replacing it with code that simply pushes its size. */
1757  int start = ax->len;
1758 
1759  gen_expr (exp, pc, ax, value);
1760 
1761  /* Throw away the code we just generated. */
1762  ax->len = start;
1763 
1764  ax_const_l (ax, TYPE_LENGTH (value->type));
1765  value->kind = axs_rvalue;
1766  value->type = size_type;
1767 }
1768 
1769 
1770 /* Generating bytecode from GDB expressions: general recursive thingy */
1771 
1772 /* XXX: i18n */
1773 /* A gen_expr function written by a Gen-X'er guy.
1774  Append code for the subexpression of EXPR starting at *POS_P to AX. */
1775 void
1776 gen_expr (struct expression *exp, union exp_element **pc,
1777  struct agent_expr *ax, struct axs_value *value)
1778 {
1779  /* Used to hold the descriptions of operand expressions. */
1780  struct axs_value value1, value2, value3;
1781  enum exp_opcode op = (*pc)[0].opcode, op2;
1782  int if1, go1, if2, go2, end;
1783  struct type *int_type = builtin_type (exp->gdbarch)->builtin_int;
1784 
1785  /* If we're looking at a constant expression, just push its value. */
1786  {
1787  struct value *v = maybe_const_expr (pc);
1788 
1789  if (v)
1790  {
1791  ax_const_l (ax, value_as_long (v));
1792  value->kind = axs_rvalue;
1793  value->type = check_typedef (value_type (v));
1794  return;
1795  }
1796  }
1797 
1798  /* Otherwise, go ahead and generate code for it. */
1799  switch (op)
1800  {
1801  /* Binary arithmetic operators. */
1802  case BINOP_ADD:
1803  case BINOP_SUB:
1804  case BINOP_MUL:
1805  case BINOP_DIV:
1806  case BINOP_REM:
1807  case BINOP_LSH:
1808  case BINOP_RSH:
1809  case BINOP_SUBSCRIPT:
1810  case BINOP_BITWISE_AND:
1811  case BINOP_BITWISE_IOR:
1812  case BINOP_BITWISE_XOR:
1813  case BINOP_EQUAL:
1814  case BINOP_NOTEQUAL:
1815  case BINOP_LESS:
1816  case BINOP_GTR:
1817  case BINOP_LEQ:
1818  case BINOP_GEQ:
1819  (*pc)++;
1820  gen_expr (exp, pc, ax, &value1);
1821  gen_usual_unary (exp, ax, &value1);
1822  gen_expr_binop_rest (exp, op, pc, ax, value, &value1, &value2);
1823  break;
1824 
1825  case BINOP_LOGICAL_AND:
1826  (*pc)++;
1827  /* Generate the obvious sequence of tests and jumps. */
1828  gen_expr (exp, pc, ax, &value1);
1829  gen_usual_unary (exp, ax, &value1);
1830  if1 = ax_goto (ax, aop_if_goto);
1831  go1 = ax_goto (ax, aop_goto);
1832  ax_label (ax, if1, ax->len);
1833  gen_expr (exp, pc, ax, &value2);
1834  gen_usual_unary (exp, ax, &value2);
1835  if2 = ax_goto (ax, aop_if_goto);
1836  go2 = ax_goto (ax, aop_goto);
1837  ax_label (ax, if2, ax->len);
1838  ax_const_l (ax, 1);
1839  end = ax_goto (ax, aop_goto);
1840  ax_label (ax, go1, ax->len);
1841  ax_label (ax, go2, ax->len);
1842  ax_const_l (ax, 0);
1843  ax_label (ax, end, ax->len);
1844  value->kind = axs_rvalue;
1845  value->type = int_type;
1846  break;
1847 
1848  case BINOP_LOGICAL_OR:
1849  (*pc)++;
1850  /* Generate the obvious sequence of tests and jumps. */
1851  gen_expr (exp, pc, ax, &value1);
1852  gen_usual_unary (exp, ax, &value1);
1853  if1 = ax_goto (ax, aop_if_goto);
1854  gen_expr (exp, pc, ax, &value2);
1855  gen_usual_unary (exp, ax, &value2);
1856  if2 = ax_goto (ax, aop_if_goto);
1857  ax_const_l (ax, 0);
1858  end = ax_goto (ax, aop_goto);
1859  ax_label (ax, if1, ax->len);
1860  ax_label (ax, if2, ax->len);
1861  ax_const_l (ax, 1);
1862  ax_label (ax, end, ax->len);
1863  value->kind = axs_rvalue;
1864  value->type = int_type;
1865  break;
1866 
1867  case TERNOP_COND:
1868  (*pc)++;
1869  gen_expr (exp, pc, ax, &value1);
1870  gen_usual_unary (exp, ax, &value1);
1871  /* For (A ? B : C), it's easiest to generate subexpression
1872  bytecodes in order, but if_goto jumps on true, so we invert
1873  the sense of A. Then we can do B by dropping through, and
1874  jump to do C. */
1875  gen_logical_not (ax, &value1, int_type);
1876  if1 = ax_goto (ax, aop_if_goto);
1877  gen_expr (exp, pc, ax, &value2);
1878  gen_usual_unary (exp, ax, &value2);
1879  end = ax_goto (ax, aop_goto);
1880  ax_label (ax, if1, ax->len);
1881  gen_expr (exp, pc, ax, &value3);
1882  gen_usual_unary (exp, ax, &value3);
1883  ax_label (ax, end, ax->len);
1884  /* This is arbitary - what if B and C are incompatible types? */
1885  value->type = value2.type;
1886  value->kind = value2.kind;
1887  break;
1888 
1889  case BINOP_ASSIGN:
1890  (*pc)++;
1891  if ((*pc)[0].opcode == OP_INTERNALVAR)
1892  {
1893  char *name = internalvar_name ((*pc)[1].internalvar);
1894  struct trace_state_variable *tsv;
1895 
1896  (*pc) += 3;
1897  gen_expr (exp, pc, ax, value);
1898  tsv = find_trace_state_variable (name);
1899  if (tsv)
1900  {
1901  ax_tsv (ax, aop_setv, tsv->number);
1902  if (ax->tracing)
1903  ax_tsv (ax, aop_tracev, tsv->number);
1904  }
1905  else
1906  error (_("$%s is not a trace state variable, "
1907  "may not assign to it"), name);
1908  }
1909  else
1910  error (_("May only assign to trace state variables"));
1911  break;
1912 
1913  case BINOP_ASSIGN_MODIFY:
1914  (*pc)++;
1915  op2 = (*pc)[0].opcode;
1916  (*pc)++;
1917  (*pc)++;
1918  if ((*pc)[0].opcode == OP_INTERNALVAR)
1919  {
1920  char *name = internalvar_name ((*pc)[1].internalvar);
1921  struct trace_state_variable *tsv;
1922 
1923  (*pc) += 3;
1924  tsv = find_trace_state_variable (name);
1925  if (tsv)
1926  {
1927  /* The tsv will be the left half of the binary operation. */
1928  ax_tsv (ax, aop_getv, tsv->number);
1929  if (ax->tracing)
1930  ax_tsv (ax, aop_tracev, tsv->number);
1931  /* Trace state variables are always 64-bit integers. */
1932  value1.kind = axs_rvalue;
1933  value1.type = builtin_type (exp->gdbarch)->builtin_long_long;
1934  /* Now do right half of expression. */
1935  gen_expr_binop_rest (exp, op2, pc, ax, value, &value1, &value2);
1936  /* We have a result of the binary op, set the tsv. */
1937  ax_tsv (ax, aop_setv, tsv->number);
1938  if (ax->tracing)
1939  ax_tsv (ax, aop_tracev, tsv->number);
1940  }
1941  else
1942  error (_("$%s is not a trace state variable, "
1943  "may not assign to it"), name);
1944  }
1945  else
1946  error (_("May only assign to trace state variables"));
1947  break;
1948 
1949  /* Note that we need to be a little subtle about generating code
1950  for comma. In C, we can do some optimizations here because
1951  we know the left operand is only being evaluated for effect.
1952  However, if the tracing kludge is in effect, then we always
1953  need to evaluate the left hand side fully, so that all the
1954  variables it mentions get traced. */
1955  case BINOP_COMMA:
1956  (*pc)++;
1957  gen_expr (exp, pc, ax, &value1);
1958  /* Don't just dispose of the left operand. We might be tracing,
1959  in which case we want to emit code to trace it if it's an
1960  lvalue. */
1961  gen_traced_pop (exp->gdbarch, ax, &value1);
1962  gen_expr (exp, pc, ax, value);
1963  /* It's the consumer's responsibility to trace the right operand. */
1964  break;
1965 
1966  case OP_LONG: /* some integer constant */
1967  {
1968  struct type *type = (*pc)[1].type;
1969  LONGEST k = (*pc)[2].longconst;
1970 
1971  (*pc) += 4;
1972  gen_int_literal (ax, value, k, type);
1973  }
1974  break;
1975 
1976  case OP_VAR_VALUE:
1977  gen_var_ref (exp->gdbarch, ax, value, (*pc)[2].symbol);
1978 
1979  if (value->optimized_out)
1980  error (_("`%s' has been optimized out, cannot use"),
1981  SYMBOL_PRINT_NAME ((*pc)[2].symbol));
1982 
1983  (*pc) += 4;
1984  break;
1985 
1986  case OP_REGISTER:
1987  {
1988  const char *name = &(*pc)[2].string;
1989  int reg;
1990 
1991  (*pc) += 4 + BYTES_TO_EXP_ELEM ((*pc)[1].longconst + 1);
1992  reg = user_reg_map_name_to_regnum (exp->gdbarch, name, strlen (name));
1993  if (reg == -1)
1994  internal_error (__FILE__, __LINE__,
1995  _("Register $%s not available"), name);
1996  /* No support for tracing user registers yet. */
1997  if (reg >= gdbarch_num_regs (exp->gdbarch)
1999  error (_("'%s' is a user-register; "
2000  "GDB cannot yet trace user-register contents."),
2001  name);
2002  value->kind = axs_lvalue_register;
2003  value->u.reg = reg;
2004  value->type = register_type (exp->gdbarch, reg);
2005  }
2006  break;
2007 
2008  case OP_INTERNALVAR:
2009  {
2010  struct internalvar *var = (*pc)[1].internalvar;
2011  const char *name = internalvar_name (var);
2012  struct trace_state_variable *tsv;
2013 
2014  (*pc) += 3;
2015  tsv = find_trace_state_variable (name);
2016  if (tsv)
2017  {
2018  ax_tsv (ax, aop_getv, tsv->number);
2019  if (ax->tracing)
2020  ax_tsv (ax, aop_tracev, tsv->number);
2021  /* Trace state variables are always 64-bit integers. */
2022  value->kind = axs_rvalue;
2023  value->type = builtin_type (exp->gdbarch)->builtin_long_long;
2024  }
2025  else if (! compile_internalvar_to_ax (var, ax, value))
2026  error (_("$%s is not a trace state variable; GDB agent "
2027  "expressions cannot use convenience variables."), name);
2028  }
2029  break;
2030 
2031  /* Weirdo operator: see comments for gen_repeat for details. */
2032  case BINOP_REPEAT:
2033  /* Note that gen_repeat handles its own argument evaluation. */
2034  (*pc)++;
2035  gen_repeat (exp, pc, ax, value);
2036  break;
2037 
2038  case UNOP_CAST:
2039  {
2040  struct type *type = (*pc)[1].type;
2041 
2042  (*pc) += 3;
2043  gen_expr (exp, pc, ax, value);
2044  gen_cast (ax, value, type);
2045  }
2046  break;
2047 
2048  case UNOP_CAST_TYPE:
2049  {
2050  int offset;
2051  struct value *val;
2052  struct type *type;
2053 
2054  ++*pc;
2055  offset = *pc - exp->elts;
2056  val = evaluate_subexp (NULL, exp, &offset, EVAL_AVOID_SIDE_EFFECTS);
2057  type = value_type (val);
2058  *pc = &exp->elts[offset];
2059 
2060  gen_expr (exp, pc, ax, value);
2061  gen_cast (ax, value, type);
2062  }
2063  break;
2064 
2065  case UNOP_MEMVAL:
2066  {
2067  struct type *type = check_typedef ((*pc)[1].type);
2068 
2069  (*pc) += 3;
2070  gen_expr (exp, pc, ax, value);
2071 
2072  /* If we have an axs_rvalue or an axs_lvalue_memory, then we
2073  already have the right value on the stack. For
2074  axs_lvalue_register, we must convert. */
2075  if (value->kind == axs_lvalue_register)
2076  require_rvalue (ax, value);
2077 
2078  value->type = type;
2079  value->kind = axs_lvalue_memory;
2080  }
2081  break;
2082 
2083  case UNOP_MEMVAL_TYPE:
2084  {
2085  int offset;
2086  struct value *val;
2087  struct type *type;
2088 
2089  ++*pc;
2090  offset = *pc - exp->elts;
2091  val = evaluate_subexp (NULL, exp, &offset, EVAL_AVOID_SIDE_EFFECTS);
2092  type = value_type (val);
2093  *pc = &exp->elts[offset];
2094 
2095  gen_expr (exp, pc, ax, value);
2096 
2097  /* If we have an axs_rvalue or an axs_lvalue_memory, then we
2098  already have the right value on the stack. For
2099  axs_lvalue_register, we must convert. */
2100  if (value->kind == axs_lvalue_register)
2101  require_rvalue (ax, value);
2102 
2103  value->type = type;
2104  value->kind = axs_lvalue_memory;
2105  }
2106  break;
2107 
2108  case UNOP_PLUS:
2109  (*pc)++;
2110  /* + FOO is equivalent to 0 + FOO, which can be optimized. */
2111  gen_expr (exp, pc, ax, value);
2112  gen_usual_unary (exp, ax, value);
2113  break;
2114 
2115  case UNOP_NEG:
2116  (*pc)++;
2117  /* -FOO is equivalent to 0 - FOO. */
2118  gen_int_literal (ax, &value1, 0,
2119  builtin_type (exp->gdbarch)->builtin_int);
2120  gen_usual_unary (exp, ax, &value1); /* shouldn't do much */
2121  gen_expr (exp, pc, ax, &value2);
2122  gen_usual_unary (exp, ax, &value2);
2123  gen_usual_arithmetic (exp, ax, &value1, &value2);
2124  gen_binop (ax, value, &value1, &value2, aop_sub, aop_sub, 1, "negation");
2125  break;
2126 
2127  case UNOP_LOGICAL_NOT:
2128  (*pc)++;
2129  gen_expr (exp, pc, ax, value);
2130  gen_usual_unary (exp, ax, value);
2131  gen_logical_not (ax, value, int_type);
2132  break;
2133 
2134  case UNOP_COMPLEMENT:
2135  (*pc)++;
2136  gen_expr (exp, pc, ax, value);
2137  gen_usual_unary (exp, ax, value);
2138  gen_integral_promotions (exp, ax, value);
2139  gen_complement (ax, value);
2140  break;
2141 
2142  case UNOP_IND:
2143  (*pc)++;
2144  gen_expr (exp, pc, ax, value);
2145  gen_usual_unary (exp, ax, value);
2146  if (!pointer_type (value->type))
2147  error (_("Argument of unary `*' is not a pointer."));
2148  gen_deref (ax, value);
2149  break;
2150 
2151  case UNOP_ADDR:
2152  (*pc)++;
2153  gen_expr (exp, pc, ax, value);
2154  gen_address_of (ax, value);
2155  break;
2156 
2157  case UNOP_SIZEOF:
2158  (*pc)++;
2159  /* Notice that gen_sizeof handles its own operand, unlike most
2160  of the other unary operator functions. This is because we
2161  have to throw away the code we generate. */
2162  gen_sizeof (exp, pc, ax, value,
2163  builtin_type (exp->gdbarch)->builtin_int);
2164  break;
2165 
2166  case STRUCTOP_STRUCT:
2167  case STRUCTOP_PTR:
2168  {
2169  int length = (*pc)[1].longconst;
2170  char *name = &(*pc)[2].string;
2171 
2172  (*pc) += 4 + BYTES_TO_EXP_ELEM (length + 1);
2173  gen_expr (exp, pc, ax, value);
2174  if (op == STRUCTOP_STRUCT)
2175  gen_struct_ref (exp, ax, value, name, ".", "structure or union");
2176  else if (op == STRUCTOP_PTR)
2177  gen_struct_ref (exp, ax, value, name, "->",
2178  "pointer to a structure or union");
2179  else
2180  /* If this `if' chain doesn't handle it, then the case list
2181  shouldn't mention it, and we shouldn't be here. */
2182  internal_error (__FILE__, __LINE__,
2183  _("gen_expr: unhandled struct case"));
2184  }
2185  break;
2186 
2187  case OP_THIS:
2188  {
2189  struct symbol *sym, *func;
2190  const struct block *b;
2191  const struct language_defn *lang;
2192 
2193  b = block_for_pc (ax->scope);
2194  func = block_linkage_function (b);
2195  lang = language_def (SYMBOL_LANGUAGE (func));
2196 
2197  sym = lookup_language_this (lang, b);
2198  if (!sym)
2199  error (_("no `%s' found"), lang->la_name_of_this);
2200 
2201  gen_var_ref (exp->gdbarch, ax, value, sym);
2202 
2203  if (value->optimized_out)
2204  error (_("`%s' has been optimized out, cannot use"),
2205  SYMBOL_PRINT_NAME (sym));
2206 
2207  (*pc) += 2;
2208  }
2209  break;
2210 
2211  case OP_SCOPE:
2212  {
2213  struct type *type = (*pc)[1].type;
2214  int length = longest_to_int ((*pc)[2].longconst);
2215  char *name = &(*pc)[3].string;
2216  int found;
2217 
2218  found = gen_aggregate_elt_ref (exp, ax, value, type, name,
2219  "?", "??");
2220  if (!found)
2221  error (_("There is no field named %s"), name);
2222  (*pc) += 5 + BYTES_TO_EXP_ELEM (length + 1);
2223  }
2224  break;
2225 
2226  case OP_TYPE:
2227  case OP_TYPEOF:
2228  case OP_DECLTYPE:
2229  error (_("Attempt to use a type name as an expression."));
2230 
2231  default:
2232  error (_("Unsupported operator %s (%d) in expression."),
2233  op_name (exp, op), op);
2234  }
2235 }
2236 
2237 /* This handles the middle-to-right-side of code generation for binary
2238  expressions, which is shared between regular binary operations and
2239  assign-modify (+= and friends) expressions. */
2240 
2241 static void
2243  enum exp_opcode op, union exp_element **pc,
2244  struct agent_expr *ax, struct axs_value *value,
2245  struct axs_value *value1, struct axs_value *value2)
2246 {
2247  struct type *int_type = builtin_type (exp->gdbarch)->builtin_int;
2248 
2249  gen_expr (exp, pc, ax, value2);
2250  gen_usual_unary (exp, ax, value2);
2251  gen_usual_arithmetic (exp, ax, value1, value2);
2252  switch (op)
2253  {
2254  case BINOP_ADD:
2255  if (TYPE_CODE (value1->type) == TYPE_CODE_INT
2256  && pointer_type (value2->type))
2257  {
2258  /* Swap the values and proceed normally. */
2259  ax_simple (ax, aop_swap);
2260  gen_ptradd (ax, value, value2, value1);
2261  }
2262  else if (pointer_type (value1->type)
2263  && TYPE_CODE (value2->type) == TYPE_CODE_INT)
2264  gen_ptradd (ax, value, value1, value2);
2265  else
2266  gen_binop (ax, value, value1, value2,
2267  aop_add, aop_add, 1, "addition");
2268  break;
2269  case BINOP_SUB:
2270  if (pointer_type (value1->type)
2271  && TYPE_CODE (value2->type) == TYPE_CODE_INT)
2272  gen_ptrsub (ax,value, value1, value2);
2273  else if (pointer_type (value1->type)
2274  && pointer_type (value2->type))
2275  /* FIXME --- result type should be ptrdiff_t */
2276  gen_ptrdiff (ax, value, value1, value2,
2278  else
2279  gen_binop (ax, value, value1, value2,
2280  aop_sub, aop_sub, 1, "subtraction");
2281  break;
2282  case BINOP_MUL:
2283  gen_binop (ax, value, value1, value2,
2284  aop_mul, aop_mul, 1, "multiplication");
2285  break;
2286  case BINOP_DIV:
2287  gen_binop (ax, value, value1, value2,
2288  aop_div_signed, aop_div_unsigned, 1, "division");
2289  break;
2290  case BINOP_REM:
2291  gen_binop (ax, value, value1, value2,
2292  aop_rem_signed, aop_rem_unsigned, 1, "remainder");
2293  break;
2294  case BINOP_LSH:
2295  gen_binop (ax, value, value1, value2,
2296  aop_lsh, aop_lsh, 1, "left shift");
2297  break;
2298  case BINOP_RSH:
2299  gen_binop (ax, value, value1, value2,
2300  aop_rsh_signed, aop_rsh_unsigned, 1, "right shift");
2301  break;
2302  case BINOP_SUBSCRIPT:
2303  {
2304  struct type *type;
2305 
2306  if (binop_types_user_defined_p (op, value1->type, value2->type))
2307  {
2308  error (_("cannot subscript requested type: "
2309  "cannot call user defined functions"));
2310  }
2311  else
2312  {
2313  /* If the user attempts to subscript something that is not
2314  an array or pointer type (like a plain int variable for
2315  example), then report this as an error. */
2316  type = check_typedef (value1->type);
2317  if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2318  && TYPE_CODE (type) != TYPE_CODE_PTR)
2319  {
2320  if (TYPE_NAME (type))
2321  error (_("cannot subscript something of type `%s'"),
2322  TYPE_NAME (type));
2323  else
2324  error (_("cannot subscript requested type"));
2325  }
2326  }
2327 
2328  if (!is_integral_type (value2->type))
2329  error (_("Argument to arithmetic operation "
2330  "not a number or boolean."));
2331 
2332  gen_ptradd (ax, value, value1, value2);
2333  gen_deref (ax, value);
2334  break;
2335  }
2336  case BINOP_BITWISE_AND:
2337  gen_binop (ax, value, value1, value2,
2338  aop_bit_and, aop_bit_and, 0, "bitwise and");
2339  break;
2340 
2341  case BINOP_BITWISE_IOR:
2342  gen_binop (ax, value, value1, value2,
2343  aop_bit_or, aop_bit_or, 0, "bitwise or");
2344  break;
2345 
2346  case BINOP_BITWISE_XOR:
2347  gen_binop (ax, value, value1, value2,
2348  aop_bit_xor, aop_bit_xor, 0, "bitwise exclusive-or");
2349  break;
2350 
2351  case BINOP_EQUAL:
2352  gen_equal (ax, value, value1, value2, int_type);
2353  break;
2354 
2355  case BINOP_NOTEQUAL:
2356  gen_equal (ax, value, value1, value2, int_type);
2357  gen_logical_not (ax, value, int_type);
2358  break;
2359 
2360  case BINOP_LESS:
2361  gen_less (ax, value, value1, value2, int_type);
2362  break;
2363 
2364  case BINOP_GTR:
2365  ax_simple (ax, aop_swap);
2366  gen_less (ax, value, value1, value2, int_type);
2367  break;
2368 
2369  case BINOP_LEQ:
2370  ax_simple (ax, aop_swap);
2371  gen_less (ax, value, value1, value2, int_type);
2372  gen_logical_not (ax, value, int_type);
2373  break;
2374 
2375  case BINOP_GEQ:
2376  gen_less (ax, value, value1, value2, int_type);
2377  gen_logical_not (ax, value, int_type);
2378  break;
2379 
2380  default:
2381  /* We should only list operators in the outer case statement
2382  that we actually handle in the inner case statement. */
2383  internal_error (__FILE__, __LINE__,
2384  _("gen_expr: op case sets don't match"));
2385  }
2386 }
2387 
2388 
2389 /* Given a single variable and a scope, generate bytecodes to trace
2390  its value. This is for use in situations where we have only a
2391  variable's name, and no parsed expression; for instance, when the
2392  name comes from a list of local variables of a function. */
2393 
2394 struct agent_expr *
2396  struct symbol *var, int trace_string)
2397 {
2398  struct cleanup *old_chain = 0;
2399  struct agent_expr *ax = new_agent_expr (gdbarch, scope);
2400  struct axs_value value;
2401 
2402  old_chain = make_cleanup_free_agent_expr (ax);
2403 
2404  ax->tracing = 1;
2405  ax->trace_string = trace_string;
2406  gen_var_ref (gdbarch, ax, &value, var);
2407 
2408  /* If there is no actual variable to trace, flag it by returning
2409  an empty agent expression. */
2410  if (value.optimized_out)
2411  {
2412  do_cleanups (old_chain);
2413  return NULL;
2414  }
2415 
2416  /* Make sure we record the final object, and get rid of it. */
2417  gen_traced_pop (gdbarch, ax, &value);
2418 
2419  /* Oh, and terminate. */
2420  ax_simple (ax, aop_end);
2421 
2422  /* We have successfully built the agent expr, so cancel the cleanup
2423  request. If we add more cleanups that we always want done, this
2424  will have to get more complicated. */
2425  discard_cleanups (old_chain);
2426  return ax;
2427 }
2428 
2429 /* Generating bytecode from GDB expressions: driver */
2430 
2431 /* Given a GDB expression EXPR, return bytecode to trace its value.
2432  The result will use the `trace' and `trace_quick' bytecodes to
2433  record the value of all memory touched by the expression. The
2434  caller can then use the ax_reqs function to discover which
2435  registers it relies upon. */
2436 struct agent_expr *
2438  int trace_string)
2439 {
2440  struct cleanup *old_chain = 0;
2441  struct agent_expr *ax = new_agent_expr (expr->gdbarch, scope);
2442  union exp_element *pc;
2443  struct axs_value value;
2444 
2445  old_chain = make_cleanup_free_agent_expr (ax);
2446 
2447  pc = expr->elts;
2448  ax->tracing = 1;
2449  ax->trace_string = trace_string;
2450  value.optimized_out = 0;
2451  gen_expr (expr, &pc, ax, &value);
2452 
2453  /* Make sure we record the final object, and get rid of it. */
2454  gen_traced_pop (expr->gdbarch, ax, &value);
2455 
2456  /* Oh, and terminate. */
2457  ax_simple (ax, aop_end);
2458 
2459  /* We have successfully built the agent expr, so cancel the cleanup
2460  request. If we add more cleanups that we always want done, this
2461  will have to get more complicated. */
2462  discard_cleanups (old_chain);
2463  return ax;
2464 }
2465 
2466 /* Given a GDB expression EXPR, return a bytecode sequence that will
2467  evaluate and return a result. The bytecodes will do a direct
2468  evaluation, using the current data on the target, rather than
2469  recording blocks of memory and registers for later use, as
2470  gen_trace_for_expr does. The generated bytecode sequence leaves
2471  the result of expression evaluation on the top of the stack. */
2472 
2473 struct agent_expr *
2475 {
2476  struct cleanup *old_chain = 0;
2477  struct agent_expr *ax = new_agent_expr (expr->gdbarch, scope);
2478  union exp_element *pc;
2479  struct axs_value value;
2480 
2481  old_chain = make_cleanup_free_agent_expr (ax);
2482 
2483  pc = expr->elts;
2484  ax->tracing = 0;
2485  value.optimized_out = 0;
2486  gen_expr (expr, &pc, ax, &value);
2487 
2488  require_rvalue (ax, &value);
2489 
2490  /* Oh, and terminate. */
2491  ax_simple (ax, aop_end);
2492 
2493  /* We have successfully built the agent expr, so cancel the cleanup
2494  request. If we add more cleanups that we always want done, this
2495  will have to get more complicated. */
2496  discard_cleanups (old_chain);
2497  return ax;
2498 }
2499 
2500 struct agent_expr *
2502  int trace_string)
2503 {
2504  struct cleanup *old_chain = 0;
2505  struct agent_expr *ax = new_agent_expr (gdbarch, scope);
2506  struct axs_value value;
2507 
2508  old_chain = make_cleanup_free_agent_expr (ax);
2509 
2510  ax->tracing = 1;
2511  ax->trace_string = trace_string;
2512 
2513  gdbarch_gen_return_address (gdbarch, ax, &value, scope);
2514 
2515  /* Make sure we record the final object, and get rid of it. */
2516  gen_traced_pop (gdbarch, ax, &value);
2517 
2518  /* Oh, and terminate. */
2519  ax_simple (ax, aop_end);
2520 
2521  /* We have successfully built the agent expr, so cancel the cleanup
2522  request. If we add more cleanups that we always want done, this
2523  will have to get more complicated. */
2524  discard_cleanups (old_chain);
2525  return ax;
2526 }
2527 
2528 /* Given a collection of printf-style arguments, generate code to
2529  evaluate the arguments and pass everything to a special
2530  bytecode. */
2531 
2532 struct agent_expr *
2534  CORE_ADDR function, LONGEST channel,
2535  const char *format, int fmtlen,
2536  struct format_piece *frags,
2537  int nargs, struct expression **exprs)
2538 {
2539  struct cleanup *old_chain = 0;
2540  struct agent_expr *ax = new_agent_expr (gdbarch, scope);
2541  union exp_element *pc;
2542  struct axs_value value;
2543  int tem;
2544 
2545  old_chain = make_cleanup_free_agent_expr (ax);
2546 
2547  /* We're computing values, not doing side effects. */
2548  ax->tracing = 0;
2549 
2550  /* Evaluate and push the args on the stack in reverse order,
2551  for simplicity of collecting them on the target side. */
2552  for (tem = nargs - 1; tem >= 0; --tem)
2553  {
2554  pc = exprs[tem]->elts;
2555  value.optimized_out = 0;
2556  gen_expr (exprs[tem], &pc, ax, &value);
2557  require_rvalue (ax, &value);
2558  }
2559 
2560  /* Push function and channel. */
2561  ax_const_l (ax, channel);
2562  ax_const_l (ax, function);
2563 
2564  /* Issue the printf bytecode proper. */
2565  ax_simple (ax, aop_printf);
2566  ax_simple (ax, nargs);
2567  ax_string (ax, format, fmtlen);
2568 
2569  /* And terminate. */
2570  ax_simple (ax, aop_end);
2571 
2572  /* We have successfully built the agent expr, so cancel the cleanup
2573  request. If we add more cleanups that we always want done, this
2574  will have to get more complicated. */
2575  discard_cleanups (old_chain);
2576 
2577  return ax;
2578 }
2579 
2580 static void
2581 agent_eval_command_one (const char *exp, int eval, CORE_ADDR pc)
2582 {
2583  struct cleanup *old_chain = 0;
2584  struct expression *expr;
2585  struct agent_expr *agent;
2586  const char *arg;
2587  int trace_string = 0;
2588 
2589  if (!eval)
2590  {
2591  if (*exp == '/')
2592  exp = decode_agent_options (exp, &trace_string);
2593  }
2594 
2595  arg = exp;
2596  if (!eval && strcmp (arg, "$_ret") == 0)
2597  {
2599  trace_string);
2600  old_chain = make_cleanup_free_agent_expr (agent);
2601  }
2602  else
2603  {
2604  expr = parse_exp_1 (&arg, pc, block_for_pc (pc), 0);
2605  old_chain = make_cleanup (free_current_contents, &expr);
2606  if (eval)
2607  {
2608  gdb_assert (trace_string == 0);
2609  agent = gen_eval_for_expr (pc, expr);
2610  }
2611  else
2612  agent = gen_trace_for_expr (pc, expr, trace_string);
2614  }
2615 
2616  ax_reqs (agent);
2617  ax_print (gdb_stdout, agent);
2618 
2619  /* It would be nice to call ax_reqs here to gather some general info
2620  about the expression, and then print out the result. */
2621 
2622  do_cleanups (old_chain);
2623  dont_repeat ();
2624 }
2625 
2626 static void
2627 agent_command_1 (char *exp, int eval)
2628 {
2629  /* We don't deal with overlay debugging at the moment. We need to
2630  think more carefully about this. If you copy this code into
2631  another command, change the error message; the user shouldn't
2632  have to know anything about agent expressions. */
2633  if (overlay_debugging)
2634  error (_("GDB can't do agent expression translation with overlays."));
2635 
2636  if (exp == 0)
2637  error_no_arg (_("expression to translate"));
2638 
2639  if (check_for_argument (&exp, "-at", sizeof ("-at") - 1))
2640  {
2641  struct linespec_result canonical;
2642  int ix;
2643  struct linespec_sals *iter;
2644  struct cleanup *old_chain;
2645 
2646  exp = skip_spaces (exp);
2647  init_linespec_result (&canonical);
2649  (struct symtab *) NULL, 0, &canonical,
2650  NULL, NULL);
2651  old_chain = make_cleanup_destroy_linespec_result (&canonical);
2652  exp = skip_spaces (exp);
2653  if (exp[0] == ',')
2654  {
2655  exp++;
2656  exp = skip_spaces (exp);
2657  }
2658  for (ix = 0; VEC_iterate (linespec_sals, canonical.sals, ix, iter); ++ix)
2659  {
2660  int i;
2661 
2662  for (i = 0; i < iter->sals.nelts; i++)
2663  agent_eval_command_one (exp, eval, iter->sals.sals[i].pc);
2664  }
2665  do_cleanups (old_chain);
2666  }
2667  else
2669 
2670  dont_repeat ();
2671 }
2672 
2673 static void
2674 agent_command (char *exp, int from_tty)
2675 {
2676  agent_command_1 (exp, 0);
2677 }
2678 
2679 /* Parse the given expression, compile it into an agent expression
2680  that does direct evaluation, and display the resulting
2681  expression. */
2682 
2683 static void
2684 agent_eval_command (char *exp, int from_tty)
2685 {
2686  agent_command_1 (exp, 1);
2687 }
2688 
2689 /* Parse the given expression, compile it into an agent expression
2690  that does a printf, and display the resulting expression. */
2691 
2692 static void
2693 maint_agent_printf_command (char *exp, int from_tty)
2694 {
2695  struct cleanup *old_chain = 0;
2696  struct expression *expr;
2697  struct expression *argvec[100];
2698  struct agent_expr *agent;
2699  struct frame_info *fi = get_current_frame (); /* need current scope */
2700  const char *cmdrest;
2701  const char *format_start, *format_end;
2702  struct format_piece *fpieces;
2703  int nargs;
2704 
2705  /* We don't deal with overlay debugging at the moment. We need to
2706  think more carefully about this. If you copy this code into
2707  another command, change the error message; the user shouldn't
2708  have to know anything about agent expressions. */
2709  if (overlay_debugging)
2710  error (_("GDB can't do agent expression translation with overlays."));
2711 
2712  if (exp == 0)
2713  error_no_arg (_("expression to translate"));
2714 
2715  cmdrest = exp;
2716 
2717  cmdrest = skip_spaces_const (cmdrest);
2718 
2719  if (*cmdrest++ != '"')
2720  error (_("Must start with a format string."));
2721 
2722  format_start = cmdrest;
2723 
2724  fpieces = parse_format_string (&cmdrest);
2725 
2726  old_chain = make_cleanup (free_format_pieces_cleanup, &fpieces);
2727 
2728  format_end = cmdrest;
2729 
2730  if (*cmdrest++ != '"')
2731  error (_("Bad format string, non-terminated '\"'."));
2732 
2733  cmdrest = skip_spaces_const (cmdrest);
2734 
2735  if (*cmdrest != ',' && *cmdrest != 0)
2736  error (_("Invalid argument syntax"));
2737 
2738  if (*cmdrest == ',')
2739  cmdrest++;
2740  cmdrest = skip_spaces_const (cmdrest);
2741 
2742  nargs = 0;
2743  while (*cmdrest != '\0')
2744  {
2745  const char *cmd1;
2746 
2747  cmd1 = cmdrest;
2748  expr = parse_exp_1 (&cmd1, 0, (struct block *) 0, 1);
2749  argvec[nargs] = expr;
2750  ++nargs;
2751  cmdrest = cmd1;
2752  if (*cmdrest == ',')
2753  ++cmdrest;
2754  /* else complain? */
2755  }
2756 
2757 
2758  agent = gen_printf (get_frame_pc (fi), get_current_arch (), 0, 0,
2759  format_start, format_end - format_start,
2760  fpieces, nargs, argvec);
2762  ax_reqs (agent);
2763  ax_print (gdb_stdout, agent);
2764 
2765  /* It would be nice to call ax_reqs here to gather some general info
2766  about the expression, and then print out the result. */
2767 
2768  do_cleanups (old_chain);
2769  dont_repeat ();
2770 }
2771 
2772 
2773 /* Initialization code. */
2774 
2775 void _initialize_ax_gdb (void);
2776 void
2778 {
2780  _("\
2781 Translate an expression into remote agent bytecode for tracing.\n\
2782 Usage: maint agent [-at location,] EXPRESSION\n\
2783 If -at is given, generate remote agent bytecode for this location.\n\
2784 If not, generate remote agent bytecode for current frame pc address."),
2785  &maintenancelist);
2786 
2788  _("\
2789 Translate an expression into remote agent bytecode for evaluation.\n\
2790 Usage: maint agent-eval [-at location,] EXPRESSION\n\
2791 If -at is given, generate remote agent bytecode for this location.\n\
2792 If not, generate remote agent bytecode for current frame pc address."),
2793  &maintenancelist);
2794 
2796  _("Translate an expression into remote "
2797  "agent bytecode for evaluation and display the bytecodes."),
2798  &maintenancelist);
2799 }
void error_no_arg(const char *why)
Definition: cli-cmds.c:205
void free_agent_expr(struct agent_expr *x)
Definition: ax-general.c:67
#define TYPE_FIELD_STATIC_PHYSNAME(thistype, n)
Definition: gdbtypes.h:1373
struct cleanup * make_cleanup_free_agent_expr(struct agent_expr *x)
Definition: ax-general.c:81
static void gen_logical_not(struct agent_expr *ax, struct axs_value *value, struct type *result_type)
Definition: ax-gdb.c:1168
union exp_element elts[1]
Definition: expression.h:85
static void gen_var_ref(struct gdbarch *, struct agent_expr *ax, struct axs_value *value, struct symbol *var)
Definition: ax-gdb.c:627
static void gen_primitive_field(struct expression *exp, struct agent_expr *ax, struct axs_value *value, int offset, int fieldno, struct type *type)
Definition: ax-gdb.c:1409
static void gen_conversion(struct agent_expr *ax, struct type *from, struct type *to)
Definition: ax-gdb.c:881
struct type * lookup_array_range_type(struct type *element_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:1128
int ax_goto(struct agent_expr *x, enum agent_op op)
Definition: ax-general.c:216
static void gen_extend(struct agent_expr *, struct type *)
Definition: ax-gdb.c:466
static void agent_eval_command(char *exp, int from_tty)
Definition: ax-gdb.c:2684
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:260
struct frame_info * get_current_frame(void)
Definition: frame.c:1461
bfd_vma CORE_ADDR
Definition: common-types.h:41
void ax_reqs(struct agent_expr *ax)
Definition: ax-general.c:477
static void agent_command_1(char *exp, int eval)
Definition: ax-gdb.c:2627
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1369
static void gen_ptradd(struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2)
Definition: ax-gdb.c:1062
struct type * builtin_unsigned_int
Definition: gdbtypes.h:1488
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:1327
void ax_reg_mask(struct agent_expr *ax, int reg)
Definition: ax-general.c:438
struct symbol * cp_lookup_symbol_namespace(const char *scope, const char *name, const struct block *block, const domain_enum domain)
Definition: cp-namespace.c:739
int pointer_type(struct type *type)
Definition: language.c:392
LONGEST value_as_long(struct value *val)
Definition: value.c:2654
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:1128
void(* func)(char *)
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
const char * decode_agent_options(const char *exp, int *trace_string)
Definition: tracepoint.c:608
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1227
int compile_internalvar_to_ax(struct internalvar *var, struct agent_expr *expr, struct axs_value *value)
Definition: value.c:2111
struct ui_file * gdb_stdout
Definition: main.c:71
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:793
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
int binop_types_user_defined_p(enum exp_opcode op, struct type *type1, struct type *type2)
Definition: valarith.c:228
static void gen_offset(struct agent_expr *ax, int offset)
Definition: ax-gdb.c:595
const struct language_defn * language_def(enum language lang)
Definition: language.c:471
static void agent_eval_command_one(const char *exp, int eval, CORE_ADDR pc)
Definition: ax-gdb.c:2581
static void gen_sym_offset(struct agent_expr *, struct symbol *)
Definition: ax-gdb.c:617
struct symbol * block_linkage_function(const struct block *bl)
Definition: block.c:100
static void agent_command(char *exp, int from_tty)
Definition: ax-gdb.c:2674
Definition: ax.h:95
static void gen_frame_args_address(struct gdbarch *, struct agent_expr *)
Definition: ax-gdb.c:562
static int gen_namespace_elt(struct expression *exp, struct agent_expr *ax, struct axs_value *value, const struct type *curtype, char *name)
Definition: ax-gdb.c:1625
static void gen_deref(struct agent_expr *, struct axs_value *)
Definition: ax-gdb.c:1196
void ax_reg(struct agent_expr *x, int reg)
Definition: ax-general.c:290
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1898
char * skip_spaces(char *chp)
Definition: common-utils.c:259
static void gen_fetch(struct agent_expr *, struct type *)
Definition: ax-gdb.c:479
#define _(String)
Definition: gdb_locale.h:40
#define TYPE_FIELD(thistype, n)
Definition: gdbtypes.h:1367
#define BLOCK_START(bl)
Definition: block.h:116
#define bits(obj, st, fn)
struct symtabs_and_lines sals
Definition: linespec.h:50
#define BYTES_TO_EXP_ELEM(bytes)
Definition: expression.h:93
struct agent_expr * gen_trace_for_var(CORE_ADDR scope, struct gdbarch *gdbarch, struct symbol *var, int trace_string)
Definition: ax-gdb.c:2395
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1368
union axs_value::@27 u
struct type * type
Definition: ax-gdb.h:82
void free_format_pieces_cleanup(void *ptr)
Definition: format.c:383
const struct block * block_for_pc(CORE_ADDR pc)
Definition: block.c:282
int trace_string
Definition: ax.h:162
char optimized_out
Definition: ax-gdb.h:86
static void gen_trace_static_fields(struct gdbarch *gdbarch, struct agent_expr *ax, struct type *type)
Definition: ax-gdb.c:318
void ax_tsv(struct agent_expr *x, enum agent_op op, int num)
Definition: ax-general.c:320
int longest_to_int(LONGEST)
Definition: valprint.c:1054
static struct value * maybe_const_expr(union exp_element **pc)
Definition: ax-gdb.c:257
static void gen_struct_ref(struct expression *exp, struct agent_expr *ax, struct axs_value *value, char *field, char *operator_name, char *operand_name)
Definition: ax-gdb.c:1499
static void gen_ptrsub(struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2)
Definition: ax-gdb.c:1078
int gdbarch_num_pseudo_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1916
char * op_name(struct expression *exp, enum exp_opcode opcode)
Definition: expprint.c:653
const char *const name
Definition: aarch64-tdep.c:68
struct format_piece * parse_format_string(const char **arg)
Definition: format.c:24
int * from
Definition: varobj.h:282
int check_for_argument(char **str, char *arg, int arg_len)
Definition: cli-utils.c:277
#define VEC_iterate(T, V, I, P)
Definition: vec.h:165
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
#define SYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:182
static int is_nontrivial_conversion(struct type *from, struct type *to)
Definition: ax-gdb.c:911
static int gen_struct_ref_recursive(struct expression *exp, struct agent_expr *ax, struct axs_value *value, char *field, int offset, struct type *type)
Definition: ax-gdb.c:1434
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:1114
static struct type * max_type(struct type *type1, struct type *type2)
Definition: ax-gdb.c:873
int field_is_static(struct field *f)
Definition: gdbtypes.c:3797
int reg
Definition: ax-gdb.h:91
struct symbol * lookup_language_this(const struct language_defn *lang, const struct block *block)
Definition: symtab.c:1979
unsigned int tracing
Definition: ax.h:156
const char * skip_spaces_const(const char *chp)
Definition: common-utils.c:271
void gdbarch_gen_return_address(struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope)
Definition: gdbarch.c:4481
struct type * register_type(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:157
struct expression * parse_exp_1(const char **, CORE_ADDR pc, const struct block *, int)
Definition: parse.c:1109
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:56
int is_integral_type(struct type *t)
Definition: gdbtypes.c:2690
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
void free_current_contents(void *ptr)
Definition: utils.c:476
#define SYMBOL_REGISTER_OPS(symbol)
Definition: symtab.h:803
#define SYMBOL_COMPUTED_OPS(symbol)
Definition: symtab.h:801
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
void ax_ext(struct agent_expr *x, int n)
Definition: ax-general.c:180
Definition: gdbtypes.h:749
static void gen_scale(struct agent_expr *ax, enum agent_op op, struct type *type)
Definition: ax-gdb.c:1048
void init_linespec_result(struct linespec_result *lr)
Definition: linespec.c:3772
static void gen_static_field(struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, struct type *type, int fieldno)
Definition: ax-gdb.c:1545
void decode_line_full(char **argptr, int flags, struct symtab *default_symtab, int default_line, struct linespec_result *canonical, const char *select_mode, const char *filter)
Definition: linespec.c:2441
void ax_string(struct agent_expr *x, const char *str, int slen)
Definition: ax-general.c:341
void ax_label(struct agent_expr *x, int patch, int target)
Definition: ax-general.c:231
static struct value * const_var_ref(struct symbol *var)
Definition: ax-gdb.c:191
struct cleanup * make_cleanup_destroy_linespec_result(struct linespec_result *ls)
Definition: linespec.c:3805
agent_op
Definition: ax.h:173
struct gdbarch * get_current_arch(void)
Definition: arch-utils.c:781
char * internalvar_name(struct internalvar *var)
Definition: value.c:2407
static const char * type
Definition: language.c:103
#define gdb_assert(expr)
Definition: gdb_assert.h:33
struct agent_expr * gen_printf(CORE_ADDR scope, struct gdbarch *gdbarch, CORE_ADDR function, LONGEST channel, const char *format, int fmtlen, struct format_piece *frags, int nargs, struct expression **exprs)
Definition: ax-gdb.c:2533
struct value * value_from_longest(struct type *type, LONGEST num)
Definition: value.c:3464
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:241
void ax_simple(struct agent_expr *x, enum agent_op op)
Definition: ax-general.c:140
struct type * builtin_long
Definition: gdbtypes.h:1484
static void gen_usual_arithmetic(struct expression *exp, struct agent_expr *ax, struct axs_value *value1, struct axs_value *value2)
Definition: ax-gdb.c:935
static void maint_agent_printf_command(char *exp, int from_tty)
Definition: ax-gdb.c:2693
struct agent_expr * gen_eval_for_expr(CORE_ADDR scope, struct expression *expr)
Definition: ax-gdb.c:2474
static void gen_left_shift(struct agent_expr *, int)
Definition: ax-gdb.c:541
#define TYPE_BASECLASS(thistype, index)
Definition: gdbtypes.h:1326
#define TYPE_FIELD_PACKED(thistype, n)
Definition: gdbtypes.h:1378
static struct value * const_expr(union exp_element **pc)
Definition: ax-gdb.c:214
Definition: symtab.h:925
int user_reg_map_name_to_regnum(struct gdbarch *gdbarch, const char *name, int len)
Definition: user-regs.c:129
static const char * namespace_name(struct die_info *die, int *is_anonymous, struct dwarf2_cu *)
Definition: dwarf2read.c:14156
static void gen_usual_unary(struct expression *exp, struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:818
#define TYPE_FIELD_BITSIZE(thistype, n)
Definition: gdbtypes.h:1377
#define TYPE_FIELD_BITPOS(thistype, n)
Definition: gdbtypes.h:1371
static void gen_bitfield_ref(struct expression *exp, struct agent_expr *ax, struct axs_value *value, struct type *type, int start, int end)
Definition: ax-gdb.c:1249
void gen_expr(struct expression *exp, union exp_element **pc, struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:1776
#define TYPE_UNSIGNED(t)
Definition: gdbtypes.h:233
#define SYMBOL_VALUE(symbol)
Definition: symtab.h:181
Definition: regdef.h:22
Definition: block.h:60
static void gen_integral_promotions(struct expression *exp, struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:972
Definition: value.c:172
static void gen_complement(struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:1181
void ax_print(struct ui_file *f, struct agent_expr *x)
Definition: ax-general.c:376
static void gen_traced_pop(struct gdbarch *, struct agent_expr *, struct axs_value *)
Definition: ax-gdb.c:369
static int gen_aggregate_elt_ref(struct expression *exp, struct agent_expr *ax, struct axs_value *value, struct type *type, char *field, char *operator_name, char *operand_name)
Definition: ax-gdb.c:1670
static void gen_sign_extend(struct agent_expr *, struct type *)
Definition: ax-gdb.c:454
unsigned length
Definition: gdbtypes.h:807
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
Definition: value.c:3490
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
struct value * value_neg(struct value *arg1)
Definition: valarith.c:1767
static void gen_cast(struct agent_expr *ax, struct axs_value *value, struct type *type)
Definition: ax-gdb.c:992
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:185
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
int len
Definition: ax.h:101
void _initialize_ax_gdb(void)
Definition: ax-gdb.c:2777
struct minimal_symbol * minsym
Definition: minsyms.h:32
struct agent_expr * new_agent_expr(struct gdbarch *gdbarch, CORE_ADDR scope)
Definition: ax-general.c:42
struct 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:1967
int offset
Definition: agent.c:65
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1241
struct value * evaluate_subexp(struct type *expect_type, struct expression *exp, int *pos, enum noside noside)
Definition: eval.c:64
#define SYMBOL_LANGUAGE(symbol)
Definition: symtab.h:187
exp_opcode
Definition: expression.h:43
CORE_ADDR pc
Definition: symtab.h:1376
#define CHECK_TYPEDEF(TYPE)
Definition: gdbtypes.h:1817
void require_rvalue(struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:764
static void gen_int_literal(struct agent_expr *ax, struct axs_value *value, LONGEST k, struct type *type)
Definition: ax-gdb.c:748
static int type_wider_than(struct type *type1, struct type *type2)
Definition: ax-gdb.c:862
int c_textual_element_type(struct type *, char)
Definition: c-valprint.c:57
#define TYPE_TAG_NAME(type)
Definition: gdbtypes.h:1228
void ax_trace_quick(struct agent_expr *x, int n)
Definition: ax-general.c:196
void ax_const_l(struct agent_expr *x, LONGEST l)
Definition: ax-general.c:245
static int gen_struct_elt_for_reference(struct expression *exp, struct agent_expr *ax, struct axs_value *value, struct type *type, char *fieldname)
Definition: ax-gdb.c:1579
enum overlay_debugging_state overlay_debugging
Definition: symfile.c:3081
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:1094
struct type * builtin_long_long
Definition: gdbtypes.h:1497
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:1748
struct gdbarch * gdbarch
Definition: expression.h:83
struct trace_state_variable * find_trace_state_variable(const char *name)
Definition: tracepoint.c:313
struct type * value_type(const struct value *value)
Definition: value.c:1021
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
Definition: symtab.h:703
struct cmd_list_element * maintenancelist
Definition: cli-cmds.c:159
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, char *name)
Definition: ax-gdb.c:1148
static void gen_address_of(struct agent_expr *, struct axs_value *)
Definition: ax-gdb.c:1219
struct symtab_and_line * sals
Definition: symtab.h:1392
#define TYPE_FIELD_STATIC_PHYSADDR(thistype, n)
Definition: gdbtypes.h:1374
void ax_zero_ext(struct agent_expr *x, int n)
Definition: ax-general.c:188
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
int int * to
Definition: varobj.h:282
#define TYPE_BASECLASS_BITPOS(thistype, index)
Definition: gdbtypes.h:1329
void dont_repeat(void)
Definition: top.c:582
char * la_name_of_this
Definition: language.h:264
static int gen_maybe_namespace_elt(struct expression *exp, struct agent_expr *ax, struct axs_value *value, const struct type *curtype, char *name)
Definition: ax-gdb.c:1645
#define TYPE_FIELD_LOC_KIND(thistype, n)
Definition: gdbtypes.h:1370
static void gen_repeat(struct expression *exp, union exp_element **pc, struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:1704
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:163
enum axs_lvalue_kind kind
Definition: ax-gdb.h:77
void gdbarch_virtual_frame_pointer(struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
Definition: gdbarch.c:1809
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:2242
void error(const char *fmt,...)
Definition: errors.c:38
static void gen_frame_locals_address(struct gdbarch *, struct agent_expr *)
Definition: ax-gdb.c:577
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:368
struct agent_expr * gen_trace_for_return_address(CORE_ADDR scope, struct gdbarch *gdbarch, int trace_string)
Definition: ax-gdb.c:2501
long long LONGEST
Definition: common-types.h:52
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
struct agent_expr * gen_trace_for_expr(CORE_ADDR scope, struct expression *expr, int trace_string)
Definition: ax-gdb.c:2437
CORE_ADDR scope
Definition: ax.h:110
struct type * builtin_int
Definition: gdbtypes.h:1483