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