gdb/ax-gdb.c

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