contrib/gdb-7/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         if (reg >= gdbarch_num_regs (exp->gdbarch))
1982           error (_("'%s' is a pseudo-register; "
1983                    "GDB cannot yet trace pseudoregister contents."),
1984                  name);
1985         value->kind = axs_lvalue_register;
1986         value->u.reg = reg;
1987         value->type = register_type (exp->gdbarch, reg);
1988       }
1989       break;
1990
1991     case OP_INTERNALVAR:
1992       {
1993         const char *name = internalvar_name ((*pc)[1].internalvar);
1994         struct trace_state_variable *tsv;
1995
1996         (*pc) += 3;
1997         tsv = find_trace_state_variable (name);
1998         if (tsv)
1999           {
2000             ax_tsv (ax, aop_getv, tsv->number);
2001             if (trace_kludge)
2002               ax_tsv (ax, aop_tracev, tsv->number);
2003             /* Trace state variables are always 64-bit integers.  */
2004             value->kind = axs_rvalue;
2005             value->type = builtin_type (exp->gdbarch)->builtin_long_long;
2006           }
2007         else
2008           error (_("$%s is not a trace state variable; GDB agent expressions cannot use convenience variables."), name);
2009       }
2010       break;
2011
2012       /* Weirdo operator: see comments for gen_repeat for details.  */
2013     case BINOP_REPEAT:
2014       /* Note that gen_repeat handles its own argument evaluation.  */
2015       (*pc)++;
2016       gen_repeat (exp, pc, ax, value);
2017       break;
2018
2019     case UNOP_CAST:
2020       {
2021         struct type *type = (*pc)[1].type;
2022
2023         (*pc) += 3;
2024         gen_expr (exp, pc, ax, value);
2025         gen_cast (ax, value, type);
2026       }
2027       break;
2028
2029     case UNOP_MEMVAL:
2030       {
2031         struct type *type = check_typedef ((*pc)[1].type);
2032
2033         (*pc) += 3;
2034         gen_expr (exp, pc, ax, value);
2035         /* I'm not sure I understand UNOP_MEMVAL entirely.  I think
2036            it's just a hack for dealing with minsyms; you take some
2037            integer constant, pretend it's the address of an lvalue of
2038            the given type, and dereference it.  */
2039         if (value->kind != axs_rvalue)
2040           /* This would be weird.  */
2041           internal_error (__FILE__, __LINE__,
2042                           _("gen_expr: OP_MEMVAL operand isn't an rvalue???"));
2043         value->type = type;
2044         value->kind = axs_lvalue_memory;
2045       }
2046       break;
2047
2048     case UNOP_PLUS:
2049       (*pc)++;
2050       /* + FOO is equivalent to 0 + FOO, which can be optimized. */
2051       gen_expr (exp, pc, ax, value);
2052       gen_usual_unary (exp, ax, value);
2053       break;
2054
2055     case UNOP_NEG:
2056       (*pc)++;
2057       /* -FOO is equivalent to 0 - FOO.  */
2058       gen_int_literal (ax, &value1, 0,
2059                        builtin_type (exp->gdbarch)->builtin_int);
2060       gen_usual_unary (exp, ax, &value1);       /* shouldn't do much */
2061       gen_expr (exp, pc, ax, &value2);
2062       gen_usual_unary (exp, ax, &value2);
2063       gen_usual_arithmetic (exp, ax, &value1, &value2);
2064       gen_binop (ax, value, &value1, &value2, aop_sub, aop_sub, 1, "negation");
2065       break;
2066
2067     case UNOP_LOGICAL_NOT:
2068       (*pc)++;
2069       gen_expr (exp, pc, ax, value);
2070       gen_usual_unary (exp, ax, value);
2071       gen_logical_not (ax, value, int_type);
2072       break;
2073
2074     case UNOP_COMPLEMENT:
2075       (*pc)++;
2076       gen_expr (exp, pc, ax, value);
2077       gen_usual_unary (exp, ax, value);
2078       gen_integral_promotions (exp, ax, value);
2079       gen_complement (ax, value);
2080       break;
2081
2082     case UNOP_IND:
2083       (*pc)++;
2084       gen_expr (exp, pc, ax, value);
2085       gen_usual_unary (exp, ax, value);
2086       if (!pointer_type (value->type))
2087         error (_("Argument of unary `*' is not a pointer."));
2088       gen_deref (ax, value);
2089       break;
2090
2091     case UNOP_ADDR:
2092       (*pc)++;
2093       gen_expr (exp, pc, ax, value);
2094       gen_address_of (ax, value);
2095       break;
2096
2097     case UNOP_SIZEOF:
2098       (*pc)++;
2099       /* Notice that gen_sizeof handles its own operand, unlike most
2100          of the other unary operator functions.  This is because we
2101          have to throw away the code we generate.  */
2102       gen_sizeof (exp, pc, ax, value,
2103                   builtin_type (exp->gdbarch)->builtin_int);
2104       break;
2105
2106     case STRUCTOP_STRUCT:
2107     case STRUCTOP_PTR:
2108       {
2109         int length = (*pc)[1].longconst;
2110         char *name = &(*pc)[2].string;
2111
2112         (*pc) += 4 + BYTES_TO_EXP_ELEM (length + 1);
2113         gen_expr (exp, pc, ax, value);
2114         if (op == STRUCTOP_STRUCT)
2115           gen_struct_ref (exp, ax, value, name, ".", "structure or union");
2116         else if (op == STRUCTOP_PTR)
2117           gen_struct_ref (exp, ax, value, name, "->",
2118                           "pointer to a structure or union");
2119         else
2120           /* If this `if' chain doesn't handle it, then the case list
2121              shouldn't mention it, and we shouldn't be here.  */
2122           internal_error (__FILE__, __LINE__,
2123                           _("gen_expr: unhandled struct case"));
2124       }
2125       break;
2126
2127     case OP_THIS:
2128       {
2129         char *this_name;
2130         struct symbol *func, *sym;
2131         struct block *b;
2132
2133         func = block_linkage_function (block_for_pc (ax->scope));
2134         this_name = language_def (SYMBOL_LANGUAGE (func))->la_name_of_this;
2135         b = SYMBOL_BLOCK_VALUE (func);
2136
2137         /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
2138            symbol instead of the LOC_ARG one (if both exist).  */
2139         sym = lookup_block_symbol (b, this_name, VAR_DOMAIN);
2140         if (!sym)
2141           error (_("no `%s' found"), this_name);
2142
2143         gen_var_ref (exp->gdbarch, ax, value, sym);
2144
2145         if (value->optimized_out)
2146           error (_("`%s' has been optimized out, cannot use"),
2147                  SYMBOL_PRINT_NAME (sym));
2148
2149         (*pc) += 2;
2150       }
2151       break;
2152
2153     case OP_SCOPE:
2154       {
2155         struct type *type = (*pc)[1].type;
2156         int length = longest_to_int ((*pc)[2].longconst);
2157         char *name = &(*pc)[3].string;
2158         int found;
2159
2160         found = gen_aggregate_elt_ref (exp, ax, value, type, name,
2161                                        "?", "??");
2162         if (!found)
2163           error (_("There is no field named %s"), name);
2164         (*pc) += 5 + BYTES_TO_EXP_ELEM (length + 1);
2165       }
2166       break;
2167
2168     case OP_TYPE:
2169       error (_("Attempt to use a type name as an expression."));
2170
2171     default:
2172       error (_("Unsupported operator %s (%d) in expression."),
2173              op_string (op), op);
2174     }
2175 }
2176
2177 /* This handles the middle-to-right-side of code generation for binary
2178    expressions, which is shared between regular binary operations and
2179    assign-modify (+= and friends) expressions.  */
2180
2181 static void
2182 gen_expr_binop_rest (struct expression *exp,
2183                      enum exp_opcode op, union exp_element **pc,
2184                      struct agent_expr *ax, struct axs_value *value,
2185                      struct axs_value *value1, struct axs_value *value2)
2186 {
2187   struct type *int_type = builtin_type (exp->gdbarch)->builtin_int;
2188
2189   gen_expr (exp, pc, ax, value2);
2190   gen_usual_unary (exp, ax, value2);
2191   gen_usual_arithmetic (exp, ax, value1, value2);
2192   switch (op)
2193     {
2194     case BINOP_ADD:
2195       if (TYPE_CODE (value1->type) == TYPE_CODE_INT
2196           && pointer_type (value2->type))
2197         {
2198           /* Swap the values and proceed normally.  */
2199           ax_simple (ax, aop_swap);
2200           gen_ptradd (ax, value, value2, value1);
2201         }
2202       else if (pointer_type (value1->type)
2203                && TYPE_CODE (value2->type) == TYPE_CODE_INT)
2204         gen_ptradd (ax, value, value1, value2);
2205       else
2206         gen_binop (ax, value, value1, value2,
2207                    aop_add, aop_add, 1, "addition");
2208       break;
2209     case BINOP_SUB:
2210       if (pointer_type (value1->type)
2211           && TYPE_CODE (value2->type) == TYPE_CODE_INT)
2212         gen_ptrsub (ax,value, value1, value2);
2213       else if (pointer_type (value1->type)
2214                && pointer_type (value2->type))
2215         /* FIXME --- result type should be ptrdiff_t */
2216         gen_ptrdiff (ax, value, value1, value2,
2217                      builtin_type (exp->gdbarch)->builtin_long);
2218       else
2219         gen_binop (ax, value, value1, value2,
2220                    aop_sub, aop_sub, 1, "subtraction");
2221       break;
2222     case BINOP_MUL:
2223       gen_binop (ax, value, value1, value2,
2224                  aop_mul, aop_mul, 1, "multiplication");
2225       break;
2226     case BINOP_DIV:
2227       gen_binop (ax, value, value1, value2,
2228                  aop_div_signed, aop_div_unsigned, 1, "division");
2229       break;
2230     case BINOP_REM:
2231       gen_binop (ax, value, value1, value2,
2232                  aop_rem_signed, aop_rem_unsigned, 1, "remainder");
2233       break;
2234     case BINOP_LSH:
2235       gen_binop (ax, value, value1, value2,
2236                  aop_lsh, aop_lsh, 1, "left shift");
2237       break;
2238     case BINOP_RSH:
2239       gen_binop (ax, value, value1, value2,
2240                  aop_rsh_signed, aop_rsh_unsigned, 1, "right shift");
2241       break;
2242     case BINOP_SUBSCRIPT:
2243       {
2244         struct type *type;
2245
2246         if (binop_types_user_defined_p (op, value1->type, value2->type))
2247           {
2248             error (_("\
2249 cannot subscript requested type: cannot call user defined functions"));
2250           }
2251         else
2252           {
2253             /* If the user attempts to subscript something that is not
2254                an array or pointer type (like a plain int variable for
2255                example), then report this as an error.  */
2256             type = check_typedef (value1->type);
2257             if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2258                 && TYPE_CODE (type) != TYPE_CODE_PTR)
2259               {
2260                 if (TYPE_NAME (type))
2261                   error (_("cannot subscript something of type `%s'"),
2262                          TYPE_NAME (type));
2263                 else
2264                   error (_("cannot subscript requested type"));
2265               }
2266           }
2267
2268         if (!is_integral_type (value2->type))
2269           error (_("Argument to arithmetic operation not a number or boolean."));
2270
2271         gen_ptradd (ax, value, value1, value2);
2272         gen_deref (ax, value);
2273         break;
2274       }
2275     case BINOP_BITWISE_AND:
2276       gen_binop (ax, value, value1, value2,
2277                  aop_bit_and, aop_bit_and, 0, "bitwise and");
2278       break;
2279
2280     case BINOP_BITWISE_IOR:
2281       gen_binop (ax, value, value1, value2,
2282                  aop_bit_or, aop_bit_or, 0, "bitwise or");
2283       break;
2284
2285     case BINOP_BITWISE_XOR:
2286       gen_binop (ax, value, value1, value2,
2287                  aop_bit_xor, aop_bit_xor, 0, "bitwise exclusive-or");
2288       break;
2289
2290     case BINOP_EQUAL:
2291       gen_equal (ax, value, value1, value2, int_type);
2292       break;
2293
2294     case BINOP_NOTEQUAL:
2295       gen_equal (ax, value, value1, value2, int_type);
2296       gen_logical_not (ax, value, int_type);
2297       break;
2298
2299     case BINOP_LESS:
2300       gen_less (ax, value, value1, value2, int_type);
2301       break;
2302
2303     case BINOP_GTR:
2304       ax_simple (ax, aop_swap);
2305       gen_less (ax, value, value1, value2, int_type);
2306       break;
2307
2308     case BINOP_LEQ:
2309       ax_simple (ax, aop_swap);
2310       gen_less (ax, value, value1, value2, int_type);
2311       gen_logical_not (ax, value, int_type);
2312       break;
2313
2314     case BINOP_GEQ:
2315       gen_less (ax, value, value1, value2, int_type);
2316       gen_logical_not (ax, value, int_type);
2317       break;
2318
2319     default:
2320       /* We should only list operators in the outer case statement
2321          that we actually handle in the inner case statement.  */
2322       internal_error (__FILE__, __LINE__,
2323                       _("gen_expr: op case sets don't match"));
2324     }
2325 }
2326 \f
2327
2328 /* Given a single variable and a scope, generate bytecodes to trace
2329    its value.  This is for use in situations where we have only a
2330    variable's name, and no parsed expression; for instance, when the
2331    name comes from a list of local variables of a function.  */
2332
2333 struct agent_expr *
2334 gen_trace_for_var (CORE_ADDR scope, struct gdbarch *gdbarch,
2335                    struct symbol *var)
2336 {
2337   struct cleanup *old_chain = 0;
2338   struct agent_expr *ax = new_agent_expr (gdbarch, scope);
2339   struct axs_value value;
2340
2341   old_chain = make_cleanup_free_agent_expr (ax);
2342
2343   trace_kludge = 1;
2344   gen_var_ref (gdbarch, ax, &value, var);
2345
2346   /* If there is no actual variable to trace, flag it by returning
2347      an empty agent expression.  */
2348   if (value.optimized_out)
2349     {
2350       do_cleanups (old_chain);
2351       return NULL;
2352     }
2353
2354   /* Make sure we record the final object, and get rid of it.  */
2355   gen_traced_pop (gdbarch, ax, &value);
2356
2357   /* Oh, and terminate.  */
2358   ax_simple (ax, aop_end);
2359
2360   /* We have successfully built the agent expr, so cancel the cleanup
2361      request.  If we add more cleanups that we always want done, this
2362      will have to get more complicated.  */
2363   discard_cleanups (old_chain);
2364   return ax;
2365 }
2366
2367 /* Generating bytecode from GDB expressions: driver */
2368
2369 /* Given a GDB expression EXPR, return bytecode to trace its value.
2370    The result will use the `trace' and `trace_quick' bytecodes to
2371    record the value of all memory touched by the expression.  The
2372    caller can then use the ax_reqs function to discover which
2373    registers it relies upon.  */
2374 struct agent_expr *
2375 gen_trace_for_expr (CORE_ADDR scope, struct expression *expr)
2376 {
2377   struct cleanup *old_chain = 0;
2378   struct agent_expr *ax = new_agent_expr (expr->gdbarch, scope);
2379   union exp_element *pc;
2380   struct axs_value value;
2381
2382   old_chain = make_cleanup_free_agent_expr (ax);
2383
2384   pc = expr->elts;
2385   trace_kludge = 1;
2386   value.optimized_out = 0;
2387   gen_expr (expr, &pc, ax, &value);
2388
2389   /* Make sure we record the final object, and get rid of it.  */
2390   gen_traced_pop (expr->gdbarch, ax, &value);
2391
2392   /* Oh, and terminate.  */
2393   ax_simple (ax, aop_end);
2394
2395   /* We have successfully built the agent expr, so cancel the cleanup
2396      request.  If we add more cleanups that we always want done, this
2397      will have to get more complicated.  */
2398   discard_cleanups (old_chain);
2399   return ax;
2400 }
2401
2402 /* Given a GDB expression EXPR, return a bytecode sequence that will
2403    evaluate and return a result.  The bytecodes will do a direct
2404    evaluation, using the current data on the target, rather than
2405    recording blocks of memory and registers for later use, as
2406    gen_trace_for_expr does.  The generated bytecode sequence leaves
2407    the result of expression evaluation on the top of the stack.  */
2408
2409 struct agent_expr *
2410 gen_eval_for_expr (CORE_ADDR scope, struct expression *expr)
2411 {
2412   struct cleanup *old_chain = 0;
2413   struct agent_expr *ax = new_agent_expr (expr->gdbarch, scope);
2414   union exp_element *pc;
2415   struct axs_value value;
2416
2417   old_chain = make_cleanup_free_agent_expr (ax);
2418
2419   pc = expr->elts;
2420   trace_kludge = 0;
2421   value.optimized_out = 0;
2422   gen_expr (expr, &pc, ax, &value);
2423
2424   require_rvalue (ax, &value);
2425
2426   /* Oh, and terminate.  */
2427   ax_simple (ax, aop_end);
2428
2429   /* We have successfully built the agent expr, so cancel the cleanup
2430      request.  If we add more cleanups that we always want done, this
2431      will have to get more complicated.  */
2432   discard_cleanups (old_chain);
2433   return ax;
2434 }
2435
2436 static void
2437 agent_command (char *exp, int from_tty)
2438 {
2439   struct cleanup *old_chain = 0;
2440   struct expression *expr;
2441   struct agent_expr *agent;
2442   struct frame_info *fi = get_current_frame (); /* need current scope */
2443
2444   /* We don't deal with overlay debugging at the moment.  We need to
2445      think more carefully about this.  If you copy this code into
2446      another command, change the error message; the user shouldn't
2447      have to know anything about agent expressions.  */
2448   if (overlay_debugging)
2449     error (_("GDB can't do agent expression translation with overlays."));
2450
2451   if (exp == 0)
2452     error_no_arg (_("expression to translate"));
2453
2454   expr = parse_expression (exp);
2455   old_chain = make_cleanup (free_current_contents, &expr);
2456   agent = gen_trace_for_expr (get_frame_pc (fi), expr);
2457   make_cleanup_free_agent_expr (agent);
2458   ax_reqs (agent);
2459   ax_print (gdb_stdout, agent);
2460
2461   /* It would be nice to call ax_reqs here to gather some general info
2462      about the expression, and then print out the result.  */
2463
2464   do_cleanups (old_chain);
2465   dont_repeat ();
2466 }
2467
2468 /* Parse the given expression, compile it into an agent expression
2469    that does direct evaluation, and display the resulting
2470    expression.  */
2471
2472 static void
2473 agent_eval_command (char *exp, int from_tty)
2474 {
2475   struct cleanup *old_chain = 0;
2476   struct expression *expr;
2477   struct agent_expr *agent;
2478   struct frame_info *fi = get_current_frame (); /* need current scope */
2479
2480   /* We don't deal with overlay debugging at the moment.  We need to
2481      think more carefully about this.  If you copy this code into
2482      another command, change the error message; the user shouldn't
2483      have to know anything about agent expressions.  */
2484   if (overlay_debugging)
2485     error (_("GDB can't do agent expression translation with overlays."));
2486
2487   if (exp == 0)
2488     error_no_arg (_("expression to translate"));
2489
2490   expr = parse_expression (exp);
2491   old_chain = make_cleanup (free_current_contents, &expr);
2492   agent = gen_eval_for_expr (get_frame_pc (fi), expr);
2493   make_cleanup_free_agent_expr (agent);
2494   ax_reqs (agent);
2495   ax_print (gdb_stdout, agent);
2496
2497   /* It would be nice to call ax_reqs here to gather some general info
2498      about the expression, and then print out the result.  */
2499
2500   do_cleanups (old_chain);
2501   dont_repeat ();
2502 }
2503 \f
2504
2505 /* Initialization code.  */
2506
2507 void _initialize_ax_gdb (void);
2508 void
2509 _initialize_ax_gdb (void)
2510 {
2511   add_cmd ("agent", class_maintenance, agent_command,
2512            _("Translate an expression into remote agent bytecode for tracing."),
2513            &maintenancelist);
2514
2515   add_cmd ("agent-eval", class_maintenance, agent_eval_command,
2516            _("Translate an expression into remote agent bytecode for evaluation."),
2517            &maintenancelist);
2518 }