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