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