gdb/ax-gdb.c

   1 /* GDB-specific functions for operating on agent expressions.
   2
   3    Copyright (C) 1998, 1999, 2000, 2001, 2003, 2007
   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 "value.h"
  26 #include "expression.h"
  27 #include "command.h"
  28 #include "gdbcmd.h"
  29 #include "frame.h"
  30 #include "target.h"
  31 #include "ax.h"
  32 #include "ax-gdb.h"
  33 #include "gdb_string.h"
  34 #include "block.h"
  35 #include "regcache.h"
  36
  37 /* To make sense of this file, you should read doc/agentexpr.texi.
  38    Then look at the types and enums in ax-gdb.h.  For the code itself,
  39    look at gen_expr, towards the bottom; that's the main function that
  40    looks at the GDB expressions and calls everything else to generate
  41    code.
  42
  43    I'm beginning to wonder whether it wouldn't be nicer to internally
  44    generate trees, with types, and then spit out the bytecode in
  45    linear form afterwards; we could generate fewer `swap', `ext', and
  46    `zero_ext' bytecodes that way; it would make good constant folding
  47    easier, too.  But at the moment, I think we should be willing to
  48    pay for the simplicity of this code with less-than-optimal bytecode
  49    strings.
  50
  51    Remember, "GBD" stands for "Great Britain, Dammit!"  So be careful.  */
  52 \f
  53
  54
  55 /* Prototypes for local functions. */
  56
  57 /* There's a standard order to the arguments of these functions:
  58    union exp_element ** --- pointer into expression
  59    struct agent_expr * --- agent expression buffer to generate code into
  60    struct axs_value * --- describes value left on top of stack  */
  61
  62 static struct value *const_var_ref (struct symbol *var);
  63 static struct value *const_expr (union exp_element **pc);
  64 static struct value *maybe_const_expr (union exp_element **pc);
  65
  66 static void gen_traced_pop (struct agent_expr *, struct axs_value *);
  67
  68 static void gen_sign_extend (struct agent_expr *, struct type *);
  69 static void gen_extend (struct agent_expr *, struct type *);
  70 static void gen_fetch (struct agent_expr *, struct type *);
  71 static void gen_left_shift (struct agent_expr *, int);
  72
  73
  74 static void gen_frame_args_address (struct agent_expr *);
  75 static void gen_frame_locals_address (struct agent_expr *);
  76 static void gen_offset (struct agent_expr *ax, int offset);
  77 static void gen_sym_offset (struct agent_expr *, struct symbol *);
  78 static void gen_var_ref (struct agent_expr *ax,
  79                          struct axs_value *value, struct symbol *var);
  80
  81
  82 static void gen_int_literal (struct agent_expr *ax,
  83                              struct axs_value *value,
  84                              LONGEST k, struct type *type);
  85
  86
  87 static void require_rvalue (struct agent_expr *ax, struct axs_value *value);
  88 static void gen_usual_unary (struct agent_expr *ax, struct axs_value *value);
  89 static int type_wider_than (struct type *type1, struct type *type2);
  90 static struct type *max_type (struct type *type1, struct type *type2);
  91 static void gen_conversion (struct agent_expr *ax,
  92                             struct type *from, struct type *to);
  93 static int is_nontrivial_conversion (struct type *from, struct type *to);
  94 static void gen_usual_arithmetic (struct agent_expr *ax,
  95                                   struct axs_value *value1,
  96                                   struct axs_value *value2);
  97 static void gen_integral_promotions (struct agent_expr *ax,
  98                                      struct axs_value *value);
  99 static void gen_cast (struct agent_expr *ax,
 100                       struct axs_value *value, struct type *type);
 101 static void gen_scale (struct agent_expr *ax,
 102                        enum agent_op op, struct type *type);
 103 static void gen_add (struct agent_expr *ax,
 104                      struct axs_value *value,
 105                      struct axs_value *value1,
 106                      struct axs_value *value2, char *name);
 107 static void gen_sub (struct agent_expr *ax,
 108                      struct axs_value *value,
 109                      struct axs_value *value1, struct axs_value *value2);
 110 static void gen_binop (struct agent_expr *ax,
 111                        struct axs_value *value,
 112                        struct axs_value *value1,
 113                        struct axs_value *value2,
 114                        enum agent_op op,
 115                        enum agent_op op_unsigned, int may_carry, char *name);
 116 static void gen_logical_not (struct agent_expr *ax, struct axs_value *value);
 117 static void gen_complement (struct agent_expr *ax, struct axs_value *value);
 118 static void gen_deref (struct agent_expr *, struct axs_value *);
 119 static void gen_address_of (struct agent_expr *, struct axs_value *);
 120 static int find_field (struct type *type, char *name);
 121 static void gen_bitfield_ref (struct agent_expr *ax,
 122                               struct axs_value *value,
 123                               struct type *type, int start, int end);
 124 static void gen_struct_ref (struct agent_expr *ax,
 125                             struct axs_value *value,
 126                             char *field,
 127                             char *operator_name, char *operand_name);
 128 static void gen_repeat (union exp_element **pc,
 129                         struct agent_expr *ax, struct axs_value *value);
 130 static void gen_sizeof (union exp_element **pc,
 131                         struct agent_expr *ax, struct axs_value *value);
 132 static void gen_expr (union exp_element **pc,
 133                       struct agent_expr *ax, struct axs_value *value);
 134
 135 static void agent_command (char *exp, int from_tty);
 136 \f
 137
 138 /* Detecting constant expressions.  */
 139
 140 /* If the variable reference at *PC is a constant, return its value.
 141    Otherwise, return zero.
 142
 143    Hey, Wally!  How can a variable reference be a constant?
 144
 145    Well, Beav, this function really handles the OP_VAR_VALUE operator,
 146    not specifically variable references.  GDB uses OP_VAR_VALUE to
 147    refer to any kind of symbolic reference: function names, enum
 148    elements, and goto labels are all handled through the OP_VAR_VALUE
 149    operator, even though they're constants.  It makes sense given the
 150    situation.
 151
 152    Gee, Wally, don'cha wonder sometimes if data representations that
 153    subvert commonly accepted definitions of terms in favor of heavily
 154    context-specific interpretations are really just a tool of the
 155    programming hegemony to preserve their power and exclude the
 156    proletariat?  */
 157
 158 static struct value *
 159 const_var_ref (struct symbol *var)
 160 {
 161   struct type *type = SYMBOL_TYPE (var);
 162
 163   switch (SYMBOL_CLASS (var))
 164     {
 165     case LOC_CONST:
 166       return value_from_longest (type, (LONGEST) SYMBOL_VALUE (var));
 167
 168     case LOC_LABEL:
 169       return value_from_pointer (type, (CORE_ADDR) SYMBOL_VALUE_ADDRESS (var));
 170
 171     default:
 172       return 0;
 173     }
 174 }
 175
 176
 177 /* If the expression starting at *PC has a constant value, return it.
 178    Otherwise, return zero.  If we return a value, then *PC will be
 179    advanced to the end of it.  If we return zero, *PC could be
 180    anywhere.  */
 181 static struct value *
 182 const_expr (union exp_element **pc)
 183 {
 184   enum exp_opcode op = (*pc)->opcode;
 185   struct value *v1;
 186
 187   switch (op)
 188     {
 189     case OP_LONG:
 190       {
 191         struct type *type = (*pc)[1].type;
 192         LONGEST k = (*pc)[2].longconst;
 193         (*pc) += 4;
 194         return value_from_longest (type, k);
 195       }
 196
 197     case OP_VAR_VALUE:
 198       {
 199         struct value *v = const_var_ref ((*pc)[2].symbol);
 200         (*pc) += 4;
 201         return v;
 202       }
 203
 204       /* We could add more operators in here.  */
 205
 206     case UNOP_NEG:
 207       (*pc)++;
 208       v1 = const_expr (pc);
 209       if (v1)
 210         return value_neg (v1);
 211       else
 212         return 0;
 213
 214     default:
 215       return 0;
 216     }
 217 }
 218
 219
 220 /* Like const_expr, but guarantee also that *PC is undisturbed if the
 221    expression is not constant.  */
 222 static struct value *
 223 maybe_const_expr (union exp_element **pc)
 224 {
 225   union exp_element *tentative_pc = *pc;
 226   struct value *v = const_expr (&tentative_pc);
 227
 228   /* If we got a value, then update the real PC.  */
 229   if (v)
 230     *pc = tentative_pc;
 231
 232   return v;
 233 }
 234 \f
 235
 236 /* Generating bytecode from GDB expressions: general assumptions */
 237
 238 /* Here are a few general assumptions made throughout the code; if you
 239    want to make a change that contradicts one of these, then you'd
 240    better scan things pretty thoroughly.
 241
 242    - We assume that all values occupy one stack element.  For example,
 243    sometimes we'll swap to get at the left argument to a binary
 244    operator.  If we decide that void values should occupy no stack
 245    elements, or that synthetic arrays (whose size is determined at
 246    run time, created by the `@' operator) should occupy two stack
 247    elements (address and length), then this will cause trouble.
 248
 249    - We assume the stack elements are infinitely wide, and that we
 250    don't have to worry what happens if the user requests an
 251    operation that is wider than the actual interpreter's stack.
 252    That is, it's up to the interpreter to handle directly all the
 253    integer widths the user has access to.  (Woe betide the language
 254    with bignums!)
 255
 256    - We don't support side effects.  Thus, we don't have to worry about
 257    GCC's generalized lvalues, function calls, etc.
 258
 259    - We don't support floating point.  Many places where we switch on
 260    some type don't bother to include cases for floating point; there
 261    may be even more subtle ways this assumption exists.  For
 262    example, the arguments to % must be integers.
 263
 264    - We assume all subexpressions have a static, unchanging type.  If
 265    we tried to support convenience variables, this would be a
 266    problem.
 267
 268    - All values on the stack should always be fully zero- or
 269    sign-extended.
 270
 271    (I wasn't sure whether to choose this or its opposite --- that
 272    only addresses are assumed extended --- but it turns out that
 273    neither convention completely eliminates spurious extend
 274    operations (if everything is always extended, then you have to
 275    extend after add, because it could overflow; if nothing is
 276    extended, then you end up producing extends whenever you change
 277    sizes), and this is simpler.)  */
 278 \f
 279
 280 /* Generating bytecode from GDB expressions: the `trace' kludge  */
 281
 282 /* The compiler in this file is a general-purpose mechanism for
 283    translating GDB expressions into bytecode.  One ought to be able to
 284    find a million and one uses for it.
 285
 286    However, at the moment it is HOPELESSLY BRAIN-DAMAGED for the sake
 287    of expediency.  Let he who is without sin cast the first stone.
 288
 289    For the data tracing facility, we need to insert `trace' bytecodes
 290    before each data fetch; this records all the memory that the
 291    expression touches in the course of evaluation, so that memory will
 292    be available when the user later tries to evaluate the expression
 293    in GDB.
 294
 295    This should be done (I think) in a post-processing pass, that walks
 296    an arbitrary agent expression and inserts `trace' operations at the
 297    appropriate points.  But it's much faster to just hack them
 298    directly into the code.  And since we're in a crunch, that's what
 299    I've done.
 300
 301    Setting the flag trace_kludge to non-zero enables the code that
 302    emits the trace bytecodes at the appropriate points.  */
 303 static int trace_kludge;
 304
 305 /* Trace the lvalue on the stack, if it needs it.  In either case, pop
 306    the value.  Useful on the left side of a comma, and at the end of
 307    an expression being used for tracing.  */
 308 static void
 309 gen_traced_pop (struct agent_expr *ax, struct axs_value *value)
 310 {
 311   if (trace_kludge)
 312     switch (value->kind)
 313       {
 314       case axs_rvalue:
 315         /* We don't trace rvalues, just the lvalues necessary to
 316            produce them.  So just dispose of this value.  */
 317         ax_simple (ax, aop_pop);
 318         break;
 319
 320       case axs_lvalue_memory:
 321         {
 322           int length = TYPE_LENGTH (value->type);
 323
 324           /* There's no point in trying to use a trace_quick bytecode
 325              here, since "trace_quick SIZE pop" is three bytes, whereas
 326              "const8 SIZE trace" is also three bytes, does the same
 327              thing, and the simplest code which generates that will also
 328              work correctly for objects with large sizes.  */
 329           ax_const_l (ax, length);
 330           ax_simple (ax, aop_trace);
 331         }
 332         break;
 333
 334       case axs_lvalue_register:
 335         /* We need to mention the register somewhere in the bytecode,
 336            so ax_reqs will pick it up and add it to the mask of
 337            registers used.  */
 338         ax_reg (ax, value->u.reg);
 339         ax_simple (ax, aop_pop);
 340         break;
 341       }
 342   else
 343     /* If we're not tracing, just pop the value.  */
 344     ax_simple (ax, aop_pop);
 345 }
 346 \f
 347
 348
 349 /* Generating bytecode from GDB expressions: helper functions */
 350
 351 /* Assume that the lower bits of the top of the stack is a value of
 352    type TYPE, and the upper bits are zero.  Sign-extend if necessary.  */
 353 static void
 354 gen_sign_extend (struct agent_expr *ax, struct type *type)
 355 {
 356   /* Do we need to sign-extend this?  */
 357   if (!TYPE_UNSIGNED (type))
 358     ax_ext (ax, TYPE_LENGTH (type) * TARGET_CHAR_BIT);
 359 }
 360
 361
 362 /* Assume the lower bits of the top of the stack hold a value of type
 363    TYPE, and the upper bits are garbage.  Sign-extend or truncate as
 364    needed.  */
 365 static void
 366 gen_extend (struct agent_expr *ax, struct type *type)
 367 {
 368   int bits = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
 369   /* I just had to.  */
 370   ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, bits));
 371 }
 372
 373
 374 /* Assume that the top of the stack contains a value of type "pointer
 375    to TYPE"; generate code to fetch its value.  Note that TYPE is the
 376    target type, not the pointer type.  */
 377 static void
 378 gen_fetch (struct agent_expr *ax, struct type *type)
 379 {
 380   if (trace_kludge)
 381     {
 382       /* Record the area of memory we're about to fetch.  */
 383       ax_trace_quick (ax, TYPE_LENGTH (type));
 384     }
 385
 386   switch (TYPE_CODE (type))
 387     {
 388     case TYPE_CODE_PTR:
 389     case TYPE_CODE_ENUM:
 390     case TYPE_CODE_INT:
 391     case TYPE_CODE_CHAR:
 392       /* It's a scalar value, so we know how to dereference it.  How
 393          many bytes long is it?  */
 394       switch (TYPE_LENGTH (type))
 395         {
 396         case 8 / TARGET_CHAR_BIT:
 397           ax_simple (ax, aop_ref8);
 398           break;
 399         case 16 / TARGET_CHAR_BIT:
 400           ax_simple (ax, aop_ref16);
 401           break;
 402         case 32 / TARGET_CHAR_BIT:
 403           ax_simple (ax, aop_ref32);
 404           break;
 405         case 64 / TARGET_CHAR_BIT:
 406           ax_simple (ax, aop_ref64);
 407           break;
 408
 409           /* Either our caller shouldn't have asked us to dereference
 410              that pointer (other code's fault), or we're not
 411              implementing something we should be (this code's fault).
 412              In any case, it's a bug the user shouldn't see.  */
 413         default:
 414           internal_error (__FILE__, __LINE__,
 415                           _("gen_fetch: strange size"));
 416         }
 417
 418       gen_sign_extend (ax, type);
 419       break;
 420
 421     default:
 422       /* Either our caller shouldn't have asked us to dereference that
 423          pointer (other code's fault), or we're not implementing
 424          something we should be (this code's fault).  In any case,
 425          it's a bug the user shouldn't see.  */
 426       internal_error (__FILE__, __LINE__,
 427                       _("gen_fetch: bad type code"));
 428     }
 429 }
 430
 431
 432 /* Generate code to left shift the top of the stack by DISTANCE bits, or
 433    right shift it by -DISTANCE bits if DISTANCE < 0.  This generates
 434    unsigned (logical) right shifts.  */
 435 static void
 436 gen_left_shift (struct agent_expr *ax, int distance)
 437 {
 438   if (distance > 0)
 439     {
 440       ax_const_l (ax, distance);
 441       ax_simple (ax, aop_lsh);
 442     }
 443   else if (distance < 0)
 444     {
 445       ax_const_l (ax, -distance);
 446       ax_simple (ax, aop_rsh_unsigned);
 447     }
 448 }
 449 \f
 450
 451
 452 /* Generating bytecode from GDB expressions: symbol references */
 453
 454 /* Generate code to push the base address of the argument portion of
 455    the top stack frame.  */
 456 static void
 457 gen_frame_args_address (struct agent_expr *ax)
 458 {
 459   int frame_reg;
 460   LONGEST frame_offset;
 461
 462   gdbarch_virtual_frame_pointer (current_gdbarch,
 463                                  ax->scope, &frame_reg, &frame_offset);
 464   ax_reg (ax, frame_reg);
 465   gen_offset (ax, frame_offset);
 466 }
 467
 468
 469 /* Generate code to push the base address of the locals portion of the
 470    top stack frame.  */
 471 static void
 472 gen_frame_locals_address (struct agent_expr *ax)
 473 {
 474   int frame_reg;
 475   LONGEST frame_offset;
 476
 477   gdbarch_virtual_frame_pointer (current_gdbarch,
 478                                  ax->scope, &frame_reg, &frame_offset);
 479   ax_reg (ax, frame_reg);
 480   gen_offset (ax, frame_offset);
 481 }
 482
 483
 484 /* Generate code to add OFFSET to the top of the stack.  Try to
 485    generate short and readable code.  We use this for getting to
 486    variables on the stack, and structure members.  If we were
 487    programming in ML, it would be clearer why these are the same
 488    thing.  */
 489 static void
 490 gen_offset (struct agent_expr *ax, int offset)
 491 {
 492   /* It would suffice to simply push the offset and add it, but this
 493      makes it easier to read positive and negative offsets in the
 494      bytecode.  */
 495   if (offset > 0)
 496     {
 497       ax_const_l (ax, offset);
 498       ax_simple (ax, aop_add);
 499     }
 500   else if (offset < 0)
 501     {
 502       ax_const_l (ax, -offset);
 503       ax_simple (ax, aop_sub);
 504     }
 505 }
 506
 507
 508 /* In many cases, a symbol's value is the offset from some other
 509    address (stack frame, base register, etc.)  Generate code to add
 510    VAR's value to the top of the stack.  */
 511 static void
 512 gen_sym_offset (struct agent_expr *ax, struct symbol *var)
 513 {
 514   gen_offset (ax, SYMBOL_VALUE (var));
 515 }
 516
 517
 518 /* Generate code for a variable reference to AX.  The variable is the
 519    symbol VAR.  Set VALUE to describe the result.  */
 520
 521 static void
 522 gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var)
 523 {
 524   /* Dereference any typedefs. */
 525   value->type = check_typedef (SYMBOL_TYPE (var));
 526
 527   /* I'm imitating the code in read_var_value.  */
 528   switch (SYMBOL_CLASS (var))
 529     {
 530     case LOC_CONST:             /* A constant, like an enum value.  */
 531       ax_const_l (ax, (LONGEST) SYMBOL_VALUE (var));
 532       value->kind = axs_rvalue;
 533       break;
 534
 535     case LOC_LABEL:             /* A goto label, being used as a value.  */
 536       ax_const_l (ax, (LONGEST) SYMBOL_VALUE_ADDRESS (var));
 537       value->kind = axs_rvalue;
 538       break;
 539
 540     case LOC_CONST_BYTES:
 541       internal_error (__FILE__, __LINE__,
 542                       _("gen_var_ref: LOC_CONST_BYTES symbols are not supported"));
 543
 544       /* Variable at a fixed location in memory.  Easy.  */
 545     case LOC_STATIC:
 546       /* Push the address of the variable.  */
 547       ax_const_l (ax, SYMBOL_VALUE_ADDRESS (var));
 548       value->kind = axs_lvalue_memory;
 549       break;
 550
 551     case LOC_ARG:               /* var lives in argument area of frame */
 552       gen_frame_args_address (ax);
 553       gen_sym_offset (ax, var);
 554       value->kind = axs_lvalue_memory;
 555       break;
 556
 557     case LOC_REF_ARG:           /* As above, but the frame slot really
 558                                    holds the address of the variable.  */
 559       gen_frame_args_address (ax);
 560       gen_sym_offset (ax, var);
 561       /* Don't assume any particular pointer size.  */
 562       gen_fetch (ax, lookup_pointer_type (builtin_type_void));
 563       value->kind = axs_lvalue_memory;
 564       break;
 565
 566     case LOC_LOCAL:             /* var lives in locals area of frame */
 567     case LOC_LOCAL_ARG:
 568       gen_frame_locals_address (ax);
 569       gen_sym_offset (ax, var);
 570       value->kind = axs_lvalue_memory;
 571       break;
 572
 573     case LOC_BASEREG:           /* relative to some base register */
 574     case LOC_BASEREG_ARG:
 575       ax_reg (ax, SYMBOL_BASEREG (var));
 576       gen_sym_offset (ax, var);
 577       value->kind = axs_lvalue_memory;
 578       break;
 579
 580     case LOC_TYPEDEF:
 581       error (_("Cannot compute value of typedef `%s'."),
 582              SYMBOL_PRINT_NAME (var));
 583       break;
 584
 585     case LOC_BLOCK:
 586       ax_const_l (ax, BLOCK_START (SYMBOL_BLOCK_VALUE (var)));
 587       value->kind = axs_rvalue;
 588       break;
 589
 590     case LOC_REGISTER:
 591     case LOC_REGPARM:
 592       /* Don't generate any code at all; in the process of treating
 593          this as an lvalue or rvalue, the caller will generate the
 594          right code.  */
 595       value->kind = axs_lvalue_register;
 596       value->u.reg = SYMBOL_VALUE (var);
 597       break;
 598
 599       /* A lot like LOC_REF_ARG, but the pointer lives directly in a
 600          register, not on the stack.  Simpler than LOC_REGISTER and
 601          LOC_REGPARM, because it's just like any other case where the
 602          thing has a real address.  */
 603     case LOC_REGPARM_ADDR:
 604       ax_reg (ax, SYMBOL_VALUE (var));
 605       value->kind = axs_lvalue_memory;
 606       break;
 607
 608     case LOC_UNRESOLVED:
 609       {
 610         struct minimal_symbol *msym
 611         = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);
 612         if (!msym)
 613           error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var));
 614
 615         /* Push the address of the variable.  */
 616         ax_const_l (ax, SYMBOL_VALUE_ADDRESS (msym));
 617         value->kind = axs_lvalue_memory;
 618       }
 619       break;
 620
 621     case LOC_COMPUTED:
 622     case LOC_COMPUTED_ARG:
 623       /* FIXME: cagney/2004-01-26: It should be possible to
 624          unconditionally call the SYMBOL_OPS method when available.
 625          Unfortunately DWARF 2 stores the frame-base (instead of the
 626          function) location in a function's symbol.  Oops!  For the
 627          moment enable this when/where applicable.  */
 628       SYMBOL_OPS (var)->tracepoint_var_ref (var, ax, value);
 629       break;
 630
 631     case LOC_OPTIMIZED_OUT:
 632       error (_("The variable `%s' has been optimized out."),
 633              SYMBOL_PRINT_NAME (var));
 634       break;
 635
 636     default:
 637       error (_("Cannot find value of botched symbol `%s'."),
 638              SYMBOL_PRINT_NAME (var));
 639       break;
 640     }
 641 }
 642 \f
 643
 644
 645 /* Generating bytecode from GDB expressions: literals */
 646
 647 static void
 648 gen_int_literal (struct agent_expr *ax, struct axs_value *value, LONGEST k,
 649                  struct type *type)
 650 {
 651   ax_const_l (ax, k);
 652   value->kind = axs_rvalue;
 653   value->type = type;
 654 }
 655 \f
 656
 657
 658 /* Generating bytecode from GDB expressions: unary conversions, casts */
 659
 660 /* Take what's on the top of the stack (as described by VALUE), and
 661    try to make an rvalue out of it.  Signal an error if we can't do
 662    that.  */
 663 static void
 664 require_rvalue (struct agent_expr *ax, struct axs_value *value)
 665 {
 666   switch (value->kind)
 667     {
 668     case axs_rvalue:
 669       /* It's already an rvalue.  */
 670       break;
 671
 672     case axs_lvalue_memory:
 673       /* The top of stack is the address of the object.  Dereference.  */
 674       gen_fetch (ax, value->type);
 675       break;
 676
 677     case axs_lvalue_register:
 678       /* There's nothing on the stack, but value->u.reg is the
 679          register number containing the value.
 680
 681          When we add floating-point support, this is going to have to
 682          change.  What about SPARC register pairs, for example?  */
 683       ax_reg (ax, value->u.reg);
 684       gen_extend (ax, value->type);
 685       break;
 686     }
 687
 688   value->kind = axs_rvalue;
 689 }
 690
 691
 692 /* Assume the top of the stack is described by VALUE, and perform the
 693    usual unary conversions.  This is motivated by ANSI 6.2.2, but of
 694    course GDB expressions are not ANSI; they're the mishmash union of
 695    a bunch of languages.  Rah.
 696
 697    NOTE!  This function promises to produce an rvalue only when the
 698    incoming value is of an appropriate type.  In other words, the
 699    consumer of the value this function produces may assume the value
 700    is an rvalue only after checking its type.
 701
 702    The immediate issue is that if the user tries to use a structure or
 703    union as an operand of, say, the `+' operator, we don't want to try
 704    to convert that structure to an rvalue; require_rvalue will bomb on
 705    structs and unions.  Rather, we want to simply pass the struct
 706    lvalue through unchanged, and let `+' raise an error.  */
 707
 708 static void
 709 gen_usual_unary (struct agent_expr *ax, struct axs_value *value)
 710 {
 711   /* We don't have to generate any code for the usual integral
 712      conversions, since values are always represented as full-width on
 713      the stack.  Should we tweak the type?  */
 714
 715   /* Some types require special handling.  */
 716   switch (TYPE_CODE (value->type))
 717     {
 718       /* Functions get converted to a pointer to the function.  */
 719     case TYPE_CODE_FUNC:
 720       value->type = lookup_pointer_type (value->type);
 721       value->kind = axs_rvalue; /* Should always be true, but just in case.  */
 722       break;
 723
 724       /* Arrays get converted to a pointer to their first element, and
 725          are no longer an lvalue.  */
 726     case TYPE_CODE_ARRAY:
 727       {
 728         struct type *elements = TYPE_TARGET_TYPE (value->type);
 729         value->type = lookup_pointer_type (elements);
 730         value->kind = axs_rvalue;
 731         /* We don't need to generate any code; the address of the array
 732            is also the address of its first element.  */
 733       }
 734       break;
 735
 736       /* Don't try to convert structures and unions to rvalues.  Let the
 737          consumer signal an error.  */
 738     case TYPE_CODE_STRUCT:
 739     case TYPE_CODE_UNION:
 740       return;
 741
 742       /* If the value is an enum, call it an integer.  */
 743     case TYPE_CODE_ENUM:
 744       value->type = builtin_type_int;
 745       break;
 746     }
 747
 748   /* If the value is an lvalue, dereference it.  */
 749   require_rvalue (ax, value);
 750 }
 751
 752
 753 /* Return non-zero iff the type TYPE1 is considered "wider" than the
 754    type TYPE2, according to the rules described in gen_usual_arithmetic.  */
 755 static int
 756 type_wider_than (struct type *type1, struct type *type2)
 757 {
 758   return (TYPE_LENGTH (type1) > TYPE_LENGTH (type2)
 759           || (TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
 760               && TYPE_UNSIGNED (type1)
 761               && !TYPE_UNSIGNED (type2)));
 762 }
 763
 764
 765 /* Return the "wider" of the two types TYPE1 and TYPE2.  */
 766 static struct type *
 767 max_type (struct type *type1, struct type *type2)
 768 {
 769   return type_wider_than (type1, type2) ? type1 : type2;
 770 }
 771
 772
 773 /* Generate code to convert a scalar value of type FROM to type TO.  */
 774 static void
 775 gen_conversion (struct agent_expr *ax, struct type *from, struct type *to)
 776 {
 777   /* Perhaps there is a more graceful way to state these rules.  */
 778
 779   /* If we're converting to a narrower type, then we need to clear out
 780      the upper bits.  */
 781   if (TYPE_LENGTH (to) < TYPE_LENGTH (from))
 782     gen_extend (ax, from);
 783
 784   /* If the two values have equal width, but different signednesses,
 785      then we need to extend.  */
 786   else if (TYPE_LENGTH (to) == TYPE_LENGTH (from))
 787     {
 788       if (TYPE_UNSIGNED (from) != TYPE_UNSIGNED (to))
 789         gen_extend (ax, to);
 790     }
 791
 792   /* If we're converting to a wider type, and becoming unsigned, then
 793      we need to zero out any possible sign bits.  */
 794   else if (TYPE_LENGTH (to) > TYPE_LENGTH (from))
 795     {
 796       if (TYPE_UNSIGNED (to))
 797         gen_extend (ax, to);
 798     }
 799 }
 800
 801
 802 /* Return non-zero iff the type FROM will require any bytecodes to be
 803    emitted to be converted to the type TO.  */
 804 static int
 805 is_nontrivial_conversion (struct type *from, struct type *to)
 806 {
 807   struct agent_expr *ax = new_agent_expr (0);
 808   int nontrivial;
 809
 810   /* Actually generate the code, and see if anything came out.  At the
 811      moment, it would be trivial to replicate the code in
 812      gen_conversion here, but in the future, when we're supporting
 813      floating point and the like, it may not be.  Doing things this
 814      way allows this function to be independent of the logic in
 815      gen_conversion.  */
 816   gen_conversion (ax, from, to);
 817   nontrivial = ax->len > 0;
 818   free_agent_expr (ax);
 819   return nontrivial;
 820 }
 821
 822
 823 /* Generate code to perform the "usual arithmetic conversions" (ANSI C
 824    6.2.1.5) for the two operands of an arithmetic operator.  This
 825    effectively finds a "least upper bound" type for the two arguments,
 826    and promotes each argument to that type.  *VALUE1 and *VALUE2
 827    describe the values as they are passed in, and as they are left.  */
 828 static void
 829 gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1,
 830                       struct axs_value *value2)
 831 {
 832   /* Do the usual binary conversions.  */
 833   if (TYPE_CODE (value1->type) == TYPE_CODE_INT
 834       && TYPE_CODE (value2->type) == TYPE_CODE_INT)
 835     {
 836       /* The ANSI integral promotions seem to work this way: Order the
 837          integer types by size, and then by signedness: an n-bit
 838          unsigned type is considered "wider" than an n-bit signed
 839          type.  Promote to the "wider" of the two types, and always
 840          promote at least to int.  */
 841       struct type *target = max_type (builtin_type_int,
 842                                       max_type (value1->type, value2->type));
 843
 844       /* Deal with value2, on the top of the stack.  */
 845       gen_conversion (ax, value2->type, target);
 846
 847       /* Deal with value1, not on the top of the stack.  Don't
 848          generate the `swap' instructions if we're not actually going
 849          to do anything.  */
 850       if (is_nontrivial_conversion (value1->type, target))
 851         {
 852           ax_simple (ax, aop_swap);
 853           gen_conversion (ax, value1->type, target);
 854           ax_simple (ax, aop_swap);
 855         }
 856
 857       value1->type = value2->type = target;
 858     }
 859 }
 860
 861
 862 /* Generate code to perform the integral promotions (ANSI 6.2.1.1) on
 863    the value on the top of the stack, as described by VALUE.  Assume
 864    the value has integral type.  */
 865 static void
 866 gen_integral_promotions (struct agent_expr *ax, struct axs_value *value)
 867 {
 868   if (!type_wider_than (value->type, builtin_type_int))
 869     {
 870       gen_conversion (ax, value->type, builtin_type_int);
 871       value->type = builtin_type_int;
 872     }
 873   else if (!type_wider_than (value->type, builtin_type_unsigned_int))
 874     {
 875       gen_conversion (ax, value->type, builtin_type_unsigned_int);
 876       value->type = builtin_type_unsigned_int;
 877     }
 878 }
 879
 880
 881 /* Generate code for a cast to TYPE.  */
 882 static void
 883 gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type)
 884 {
 885   /* GCC does allow casts to yield lvalues, so this should be fixed
 886      before merging these changes into the trunk.  */
 887   require_rvalue (ax, value);
 888   /* Dereference typedefs. */
 889   type = check_typedef (type);
 890
 891   switch (TYPE_CODE (type))
 892     {
 893     case TYPE_CODE_PTR:
 894       /* It's implementation-defined, and I'll bet this is what GCC
 895          does.  */
 896       break;
 897
 898     case TYPE_CODE_ARRAY:
 899     case TYPE_CODE_STRUCT:
 900     case TYPE_CODE_UNION:
 901     case TYPE_CODE_FUNC:
 902       error (_("Invalid type cast: intended type must be scalar."));
 903
 904     case TYPE_CODE_ENUM:
 905       /* We don't have to worry about the size of the value, because
 906          all our integral values are fully sign-extended, and when
 907          casting pointers we can do anything we like.  Is there any
 908          way for us to actually know what GCC actually does with a
 909          cast like this?  */
 910       value->type = type;
 911       break;
 912
 913     case TYPE_CODE_INT:
 914       gen_conversion (ax, value->type, type);
 915       break;
 916
 917     case TYPE_CODE_VOID:
 918       /* We could pop the value, and rely on everyone else to check
 919          the type and notice that this value doesn't occupy a stack
 920          slot.  But for now, leave the value on the stack, and
 921          preserve the "value == stack element" assumption.  */
 922       break;
 923
 924     default:
 925       error (_("Casts to requested type are not yet implemented."));
 926     }
 927
 928   value->type = type;
 929 }
 930 \f
 931
 932
 933 /* Generating bytecode from GDB expressions: arithmetic */
 934
 935 /* Scale the integer on the top of the stack by the size of the target
 936    of the pointer type TYPE.  */
 937 static void
 938 gen_scale (struct agent_expr *ax, enum agent_op op, struct type *type)
 939 {
 940   struct type *element = TYPE_TARGET_TYPE (type);
 941
 942   if (TYPE_LENGTH (element) != 1)
 943     {
 944       ax_const_l (ax, TYPE_LENGTH (element));
 945       ax_simple (ax, op);
 946     }
 947 }
 948
 949
 950 /* Generate code for an addition; non-trivial because we deal with
 951    pointer arithmetic.  We set VALUE to describe the result value; we
 952    assume VALUE1 and VALUE2 describe the two operands, and that
 953    they've undergone the usual binary conversions.  Used by both
 954    BINOP_ADD and BINOP_SUBSCRIPT.  NAME is used in error messages.  */
 955 static void
 956 gen_add (struct agent_expr *ax, struct axs_value *value,
 957          struct axs_value *value1, struct axs_value *value2, char *name)
 958 {
 959   /* Is it INT+PTR?  */
 960   if (TYPE_CODE (value1->type) == TYPE_CODE_INT
 961       && TYPE_CODE (value2->type) == TYPE_CODE_PTR)
 962     {
 963       /* Swap the values and proceed normally.  */
 964       ax_simple (ax, aop_swap);
 965       gen_scale (ax, aop_mul, value2->type);
 966       ax_simple (ax, aop_add);
 967       gen_extend (ax, value2->type);    /* Catch overflow.  */
 968       value->type = value2->type;
 969     }
 970
 971   /* Is it PTR+INT?  */
 972   else if (TYPE_CODE (value1->type) == TYPE_CODE_PTR
 973            && TYPE_CODE (value2->type) == TYPE_CODE_INT)
 974     {
 975       gen_scale (ax, aop_mul, value1->type);
 976       ax_simple (ax, aop_add);
 977       gen_extend (ax, value1->type);    /* Catch overflow.  */
 978       value->type = value1->type;
 979     }
 980
 981   /* Must be number + number; the usual binary conversions will have
 982      brought them both to the same width.  */
 983   else if (TYPE_CODE (value1->type) == TYPE_CODE_INT
 984            && TYPE_CODE (value2->type) == TYPE_CODE_INT)
 985     {
 986       ax_simple (ax, aop_add);
 987       gen_extend (ax, value1->type);    /* Catch overflow.  */
 988       value->type = value1->type;
 989     }
 990
 991   else
 992     error (_("Invalid combination of types in %s."), name);
 993
 994   value->kind = axs_rvalue;
 995 }
 996
 997
 998 /* Generate code for an addition; non-trivial because we have to deal
 999    with pointer arithmetic.  We set VALUE to describe the result
1000    value; we assume VALUE1 and VALUE2 describe the two operands, and
1001    that they've undergone the usual binary conversions.  */
1002 static void
1003 gen_sub (struct agent_expr *ax, struct axs_value *value,
1004          struct axs_value *value1, struct axs_value *value2)
1005 {
1006   if (TYPE_CODE (value1->type) == TYPE_CODE_PTR)
1007     {
1008       /* Is it PTR - INT?  */
1009       if (TYPE_CODE (value2->type) == TYPE_CODE_INT)
1010         {
1011           gen_scale (ax, aop_mul, value1->type);
1012           ax_simple (ax, aop_sub);
1013           gen_extend (ax, value1->type);        /* Catch overflow.  */
1014           value->type = value1->type;
1015         }
1016
1017       /* Is it PTR - PTR?  Strictly speaking, the types ought to
1018          match, but this is what the normal GDB expression evaluator
1019          tests for.  */
1020       else if (TYPE_CODE (value2->type) == TYPE_CODE_PTR
1021                && (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type))
1022                    == TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type))))
1023         {
1024           ax_simple (ax, aop_sub);
1025           gen_scale (ax, aop_div_unsigned, value1->type);
1026           value->type = builtin_type_long;      /* FIXME --- should be ptrdiff_t */
1027         }
1028       else
1029         error (_("\
1030 First argument of `-' is a pointer, but second argument is neither\n\
1031 an integer nor a pointer of the same type."));
1032     }
1033
1034   /* Must be number + number.  */
1035   else if (TYPE_CODE (value1->type) == TYPE_CODE_INT
1036            && TYPE_CODE (value2->type) == TYPE_CODE_INT)
1037     {
1038       ax_simple (ax, aop_sub);
1039       gen_extend (ax, value1->type);    /* Catch overflow.  */
1040       value->type = value1->type;
1041     }
1042
1043   else
1044     error (_("Invalid combination of types in subtraction."));
1045
1046   value->kind = axs_rvalue;
1047 }
1048
1049 /* Generate code for a binary operator that doesn't do pointer magic.
1050    We set VALUE to describe the result value; we assume VALUE1 and
1051    VALUE2 describe the two operands, and that they've undergone the
1052    usual binary conversions.  MAY_CARRY should be non-zero iff the
1053    result needs to be extended.  NAME is the English name of the
1054    operator, used in error messages */
1055 static void
1056 gen_binop (struct agent_expr *ax, struct axs_value *value,
1057            struct axs_value *value1, struct axs_value *value2, enum agent_op op,
1058            enum agent_op op_unsigned, int may_carry, char *name)
1059 {
1060   /* We only handle INT op INT.  */
1061   if ((TYPE_CODE (value1->type) != TYPE_CODE_INT)
1062       || (TYPE_CODE (value2->type) != TYPE_CODE_INT))
1063     error (_("Invalid combination of types in %s."), name);
1064
1065   ax_simple (ax,
1066              TYPE_UNSIGNED (value1->type) ? op_unsigned : op);
1067   if (may_carry)
1068     gen_extend (ax, value1->type);      /* catch overflow */
1069   value->type = value1->type;
1070   value->kind = axs_rvalue;
1071 }
1072
1073
1074 static void
1075 gen_logical_not (struct agent_expr *ax, struct axs_value *value)
1076 {
1077   if (TYPE_CODE (value->type) != TYPE_CODE_INT
1078       && TYPE_CODE (value->type) != TYPE_CODE_PTR)
1079     error (_("Invalid type of operand to `!'."));
1080
1081   gen_usual_unary (ax, value);
1082   ax_simple (ax, aop_log_not);
1083   value->type = builtin_type_int;
1084 }
1085
1086
1087 static void
1088 gen_complement (struct agent_expr *ax, struct axs_value *value)
1089 {
1090   if (TYPE_CODE (value->type) != TYPE_CODE_INT)
1091     error (_("Invalid type of operand to `~'."));
1092
1093   gen_usual_unary (ax, value);
1094   gen_integral_promotions (ax, value);
1095   ax_simple (ax, aop_bit_not);
1096   gen_extend (ax, value->type);
1097 }
1098 \f
1099
1100
1101 /* Generating bytecode from GDB expressions: * & . -> @ sizeof */
1102
1103 /* Dereference the value on the top of the stack.  */
1104 static void
1105 gen_deref (struct agent_expr *ax, struct axs_value *value)
1106 {
1107   /* The caller should check the type, because several operators use
1108      this, and we don't know what error message to generate.  */
1109   if (TYPE_CODE (value->type) != TYPE_CODE_PTR)
1110     internal_error (__FILE__, __LINE__,
1111                     _("gen_deref: expected a pointer"));
1112
1113   /* We've got an rvalue now, which is a pointer.  We want to yield an
1114      lvalue, whose address is exactly that pointer.  So we don't
1115      actually emit any code; we just change the type from "Pointer to
1116      T" to "T", and mark the value as an lvalue in memory.  Leave it
1117      to the consumer to actually dereference it.  */
1118   value->type = check_typedef (TYPE_TARGET_TYPE (value->type));
1119   value->kind = ((TYPE_CODE (value->type) == TYPE_CODE_FUNC)
1120                  ? axs_rvalue : axs_lvalue_memory);
1121 }
1122
1123
1124 /* Produce the address of the lvalue on the top of the stack.  */
1125 static void
1126 gen_address_of (struct agent_expr *ax, struct axs_value *value)
1127 {
1128   /* Special case for taking the address of a function.  The ANSI
1129      standard describes this as a special case, too, so this
1130      arrangement is not without motivation.  */
1131   if (TYPE_CODE (value->type) == TYPE_CODE_FUNC)
1132     /* The value's already an rvalue on the stack, so we just need to
1133        change the type.  */
1134     value->type = lookup_pointer_type (value->type);
1135   else
1136     switch (value->kind)
1137       {
1138       case axs_rvalue:
1139         error (_("Operand of `&' is an rvalue, which has no address."));
1140
1141       case axs_lvalue_register:
1142         error (_("Operand of `&' is in a register, and has no address."));
1143
1144       case axs_lvalue_memory:
1145         value->kind = axs_rvalue;
1146         value->type = lookup_pointer_type (value->type);
1147         break;
1148       }
1149 }
1150
1151
1152 /* A lot of this stuff will have to change to support C++.  But we're
1153    not going to deal with that at the moment.  */
1154
1155 /* Find the field in the structure type TYPE named NAME, and return
1156    its index in TYPE's field array.  */
1157 static int
1158 find_field (struct type *type, char *name)
1159 {
1160   int i;
1161
1162   CHECK_TYPEDEF (type);
1163
1164   /* Make sure this isn't C++.  */
1165   if (TYPE_N_BASECLASSES (type) != 0)
1166     internal_error (__FILE__, __LINE__,
1167                     _("find_field: derived classes supported"));
1168
1169   for (i = 0; i < TYPE_NFIELDS (type); i++)
1170     {
1171       char *this_name = TYPE_FIELD_NAME (type, i);
1172
1173       if (this_name)
1174         {
1175           if (strcmp (name, this_name) == 0)
1176             return i;
1177
1178           if (this_name[0] == '\0')
1179             internal_error (__FILE__, __LINE__,
1180                             _("find_field: anonymous unions not supported"));
1181         }
1182     }
1183
1184   error (_("Couldn't find member named `%s' in struct/union `%s'"),
1185          name, TYPE_TAG_NAME (type));
1186
1187   return 0;
1188 }
1189
1190
1191 /* Generate code to push the value of a bitfield of a structure whose
1192    address is on the top of the stack.  START and END give the
1193    starting and one-past-ending *bit* numbers of the field within the
1194    structure.  */
1195 static void
1196 gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value,
1197                   struct type *type, int start, int end)
1198 {
1199   /* Note that ops[i] fetches 8 << i bits.  */
1200   static enum agent_op ops[]
1201   =
1202   {aop_ref8, aop_ref16, aop_ref32, aop_ref64};
1203   static int num_ops = (sizeof (ops) / sizeof (ops[0]));
1204
1205   /* We don't want to touch any byte that the bitfield doesn't
1206      actually occupy; we shouldn't make any accesses we're not
1207      explicitly permitted to.  We rely here on the fact that the
1208      bytecode `ref' operators work on unaligned addresses.
1209
1210      It takes some fancy footwork to get the stack to work the way
1211      we'd like.  Say we're retrieving a bitfield that requires three
1212      fetches.  Initially, the stack just contains the address:
1213      addr
1214      For the first fetch, we duplicate the address
1215      addr addr
1216      then add the byte offset, do the fetch, and shift and mask as
1217      needed, yielding a fragment of the value, properly aligned for
1218      the final bitwise or:
1219      addr frag1
1220      then we swap, and repeat the process:
1221      frag1 addr                    --- address on top
1222      frag1 addr addr               --- duplicate it
1223      frag1 addr frag2              --- get second fragment
1224      frag1 frag2 addr              --- swap again
1225      frag1 frag2 frag3             --- get third fragment
1226      Notice that, since the third fragment is the last one, we don't
1227      bother duplicating the address this time.  Now we have all the
1228      fragments on the stack, and we can simply `or' them together,
1229      yielding the final value of the bitfield.  */
1230
1231   /* The first and one-after-last bits in the field, but rounded down
1232      and up to byte boundaries.  */
1233   int bound_start = (start / TARGET_CHAR_BIT) * TARGET_CHAR_BIT;
1234   int bound_end = (((end + TARGET_CHAR_BIT - 1)
1235                     / TARGET_CHAR_BIT)
1236                    * TARGET_CHAR_BIT);
1237
1238   /* current bit offset within the structure */
1239   int offset;
1240
1241   /* The index in ops of the opcode we're considering.  */
1242   int op;
1243
1244   /* The number of fragments we generated in the process.  Probably
1245      equal to the number of `one' bits in bytesize, but who cares?  */
1246   int fragment_count;
1247
1248   /* Dereference any typedefs. */
1249   type = check_typedef (type);
1250
1251   /* Can we fetch the number of bits requested at all?  */
1252   if ((end - start) > ((1 << num_ops) * 8))
1253     internal_error (__FILE__, __LINE__,
1254                     _("gen_bitfield_ref: bitfield too wide"));
1255
1256   /* Note that we know here that we only need to try each opcode once.
1257      That may not be true on machines with weird byte sizes.  */
1258   offset = bound_start;
1259   fragment_count = 0;
1260   for (op = num_ops - 1; op >= 0; op--)
1261     {
1262       /* number of bits that ops[op] would fetch */
1263       int op_size = 8 << op;
1264
1265       /* The stack at this point, from bottom to top, contains zero or
1266          more fragments, then the address.  */
1267
1268       /* Does this fetch fit within the bitfield?  */
1269       if (offset + op_size <= bound_end)
1270         {
1271           /* Is this the last fragment?  */
1272           int last_frag = (offset + op_size == bound_end);
1273
1274           if (!last_frag)
1275             ax_simple (ax, aop_dup);    /* keep a copy of the address */
1276
1277           /* Add the offset.  */
1278           gen_offset (ax, offset / TARGET_CHAR_BIT);
1279
1280           if (trace_kludge)
1281             {
1282               /* Record the area of memory we're about to fetch.  */
1283               ax_trace_quick (ax, op_size / TARGET_CHAR_BIT);
1284             }
1285
1286           /* Perform the fetch.  */
1287           ax_simple (ax, ops[op]);
1288
1289           /* Shift the bits we have to their proper position.
1290              gen_left_shift will generate right shifts when the operand
1291              is negative.
1292
1293              A big-endian field diagram to ponder:
1294              byte 0  byte 1  byte 2  byte 3  byte 4  byte 5  byte 6  byte 7
1295              +------++------++------++------++------++------++------++------+
1296              xxxxAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCxxxxxxxxxxx
1297              ^               ^               ^    ^
1298              bit number      16              32              48   53
1299              These are bit numbers as supplied by GDB.  Note that the
1300              bit numbers run from right to left once you've fetched the
1301              value!
1302
1303              A little-endian field diagram to ponder:
1304              byte 7  byte 6  byte 5  byte 4  byte 3  byte 2  byte 1  byte 0
1305              +------++------++------++------++------++------++------++------+
1306              xxxxxxxxxxxAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCxxxx
1307              ^               ^               ^           ^   ^
1308              bit number     48              32              16          4   0
1309
1310              In both cases, the most significant end is on the left
1311              (i.e. normal numeric writing order), which means that you
1312              don't go crazy thinking about `left' and `right' shifts.
1313
1314              We don't have to worry about masking yet:
1315              - If they contain garbage off the least significant end, then we
1316              must be looking at the low end of the field, and the right
1317              shift will wipe them out.
1318              - If they contain garbage off the most significant end, then we
1319              must be looking at the most significant end of the word, and
1320              the sign/zero extension will wipe them out.
1321              - If we're in the interior of the word, then there is no garbage
1322              on either end, because the ref operators zero-extend.  */
1323           if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
1324             gen_left_shift (ax, end - (offset + op_size));
1325           else
1326             gen_left_shift (ax, offset - start);
1327
1328           if (!last_frag)
1329             /* Bring the copy of the address up to the top.  */
1330             ax_simple (ax, aop_swap);
1331
1332           offset += op_size;
1333           fragment_count++;
1334         }
1335     }
1336
1337   /* Generate enough bitwise `or' operations to combine all the
1338      fragments we left on the stack.  */
1339   while (fragment_count-- > 1)
1340     ax_simple (ax, aop_bit_or);
1341
1342   /* Sign- or zero-extend the value as appropriate.  */
1343   ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, end - start));
1344
1345   /* This is *not* an lvalue.  Ugh.  */
1346   value->kind = axs_rvalue;
1347   value->type = type;
1348 }
1349
1350
1351 /* Generate code to reference the member named FIELD of a structure or
1352    union.  The top of the stack, as described by VALUE, should have
1353    type (pointer to a)* struct/union.  OPERATOR_NAME is the name of
1354    the operator being compiled, and OPERAND_NAME is the kind of thing
1355    it operates on; we use them in error messages.  */
1356 static void
1357 gen_struct_ref (struct agent_expr *ax, struct axs_value *value, char *field,
1358                 char *operator_name, char *operand_name)
1359 {
1360   struct type *type;
1361   int i;
1362
1363   /* Follow pointers until we reach a non-pointer.  These aren't the C
1364      semantics, but they're what the normal GDB evaluator does, so we
1365      should at least be consistent.  */
1366   while (TYPE_CODE (value->type) == TYPE_CODE_PTR)
1367     {
1368       gen_usual_unary (ax, value);
1369       gen_deref (ax, value);
1370     }
1371   type = check_typedef (value->type);
1372
1373   /* This must yield a structure or a union.  */
1374   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1375       && TYPE_CODE (type) != TYPE_CODE_UNION)
1376     error (_("The left operand of `%s' is not a %s."),
1377            operator_name, operand_name);
1378
1379   /* And it must be in memory; we don't deal with structure rvalues,
1380      or structures living in registers.  */
1381   if (value->kind != axs_lvalue_memory)
1382     error (_("Structure does not live in memory."));
1383
1384   i = find_field (type, field);
1385
1386   /* Is this a bitfield?  */
1387   if (TYPE_FIELD_PACKED (type, i))
1388     gen_bitfield_ref (ax, value, TYPE_FIELD_TYPE (type, i),
1389                       TYPE_FIELD_BITPOS (type, i),
1390                       (TYPE_FIELD_BITPOS (type, i)
1391                        + TYPE_FIELD_BITSIZE (type, i)));
1392   else
1393     {
1394       gen_offset (ax, TYPE_FIELD_BITPOS (type, i) / TARGET_CHAR_BIT);
1395       value->kind = axs_lvalue_memory;
1396       value->type = TYPE_FIELD_TYPE (type, i);
1397     }
1398 }
1399
1400
1401 /* Generate code for GDB's magical `repeat' operator.
1402    LVALUE @ INT creates an array INT elements long, and whose elements
1403    have the same type as LVALUE, located in memory so that LVALUE is
1404    its first element.  For example, argv[0]@argc gives you the array
1405    of command-line arguments.
1406
1407    Unfortunately, because we have to know the types before we actually
1408    have a value for the expression, we can't implement this perfectly
1409    without changing the type system, having values that occupy two
1410    stack slots, doing weird things with sizeof, etc.  So we require
1411    the right operand to be a constant expression.  */
1412 static void
1413 gen_repeat (union exp_element **pc, struct agent_expr *ax,
1414             struct axs_value *value)
1415 {
1416   struct axs_value value1;
1417   /* We don't want to turn this into an rvalue, so no conversions
1418      here.  */
1419   gen_expr (pc, ax, &value1);
1420   if (value1.kind != axs_lvalue_memory)
1421     error (_("Left operand of `@' must be an object in memory."));
1422
1423   /* Evaluate the length; it had better be a constant.  */
1424   {
1425     struct value *v = const_expr (pc);
1426     int length;
1427
1428     if (!v)
1429       error (_("Right operand of `@' must be a constant, in agent expressions."));
1430     if (TYPE_CODE (value_type (v)) != TYPE_CODE_INT)
1431       error (_("Right operand of `@' must be an integer."));
1432     length = value_as_long (v);
1433     if (length <= 0)
1434       error (_("Right operand of `@' must be positive."));
1435
1436     /* The top of the stack is already the address of the object, so
1437        all we need to do is frob the type of the lvalue.  */
1438     {
1439       /* FIXME-type-allocation: need a way to free this type when we are
1440          done with it.  */
1441       struct type *range
1442       = create_range_type (0, builtin_type_int, 0, length - 1);
1443       struct type *array = create_array_type (0, value1.type, range);
1444
1445       value->kind = axs_lvalue_memory;
1446       value->type = array;
1447     }
1448   }
1449 }
1450
1451
1452 /* Emit code for the `sizeof' operator.
1453    *PC should point at the start of the operand expression; we advance it
1454    to the first instruction after the operand.  */
1455 static void
1456 gen_sizeof (union exp_element **pc, struct agent_expr *ax,
1457             struct axs_value *value)
1458 {
1459   /* We don't care about the value of the operand expression; we only
1460      care about its type.  However, in the current arrangement, the
1461      only way to find an expression's type is to generate code for it.
1462      So we generate code for the operand, and then throw it away,
1463      replacing it with code that simply pushes its size.  */
1464   int start = ax->len;
1465   gen_expr (pc, ax, value);
1466
1467   /* Throw away the code we just generated.  */
1468   ax->len = start;
1469
1470   ax_const_l (ax, TYPE_LENGTH (value->type));
1471   value->kind = axs_rvalue;
1472   value->type = builtin_type_int;
1473 }
1474 \f
1475
1476 /* Generating bytecode from GDB expressions: general recursive thingy  */
1477
1478 /* XXX: i18n */
1479 /* A gen_expr function written by a Gen-X'er guy.
1480    Append code for the subexpression of EXPR starting at *POS_P to AX.  */
1481 static void
1482 gen_expr (union exp_element **pc, struct agent_expr *ax,
1483           struct axs_value *value)
1484 {
1485   /* Used to hold the descriptions of operand expressions.  */
1486   struct axs_value value1, value2;
1487   enum exp_opcode op = (*pc)[0].opcode;
1488
1489   /* If we're looking at a constant expression, just push its value.  */
1490   {
1491     struct value *v = maybe_const_expr (pc);
1492
1493     if (v)
1494       {
1495         ax_const_l (ax, value_as_long (v));
1496         value->kind = axs_rvalue;
1497         value->type = check_typedef (value_type (v));
1498         return;
1499       }
1500   }
1501
1502   /* Otherwise, go ahead and generate code for it.  */
1503   switch (op)
1504     {
1505       /* Binary arithmetic operators.  */
1506     case BINOP_ADD:
1507     case BINOP_SUB:
1508     case BINOP_MUL:
1509     case BINOP_DIV:
1510     case BINOP_REM:
1511     case BINOP_SUBSCRIPT:
1512     case BINOP_BITWISE_AND:
1513     case BINOP_BITWISE_IOR:
1514     case BINOP_BITWISE_XOR:
1515       (*pc)++;
1516       gen_expr (pc, ax, &value1);
1517       gen_usual_unary (ax, &value1);
1518       gen_expr (pc, ax, &value2);
1519       gen_usual_unary (ax, &value2);
1520       gen_usual_arithmetic (ax, &value1, &value2);
1521       switch (op)
1522         {
1523         case BINOP_ADD:
1524           gen_add (ax, value, &value1, &value2, "addition");
1525           break;
1526         case BINOP_SUB:
1527           gen_sub (ax, value, &value1, &value2);
1528           break;
1529         case BINOP_MUL:
1530           gen_binop (ax, value, &value1, &value2,
1531                      aop_mul, aop_mul, 1, "multiplication");
1532           break;
1533         case BINOP_DIV:
1534           gen_binop (ax, value, &value1, &value2,
1535                      aop_div_signed, aop_div_unsigned, 1, "division");
1536           break;
1537         case BINOP_REM:
1538           gen_binop (ax, value, &value1, &value2,
1539                      aop_rem_signed, aop_rem_unsigned, 1, "remainder");
1540           break;
1541         case BINOP_SUBSCRIPT:
1542           gen_add (ax, value, &value1, &value2, "array subscripting");
1543           if (TYPE_CODE (value->type) != TYPE_CODE_PTR)
1544             error (_("Invalid combination of types in array subscripting."));
1545           gen_deref (ax, value);
1546           break;
1547         case BINOP_BITWISE_AND:
1548           gen_binop (ax, value, &value1, &value2,
1549                      aop_bit_and, aop_bit_and, 0, "bitwise and");
1550           break;
1551
1552         case BINOP_BITWISE_IOR:
1553           gen_binop (ax, value, &value1, &value2,
1554                      aop_bit_or, aop_bit_or, 0, "bitwise or");
1555           break;
1556
1557         case BINOP_BITWISE_XOR:
1558           gen_binop (ax, value, &value1, &value2,
1559                      aop_bit_xor, aop_bit_xor, 0, "bitwise exclusive-or");
1560           break;
1561
1562         default:
1563           /* We should only list operators in the outer case statement
1564              that we actually handle in the inner case statement.  */
1565           internal_error (__FILE__, __LINE__,
1566                           _("gen_expr: op case sets don't match"));
1567         }
1568       break;
1569
1570       /* Note that we need to be a little subtle about generating code
1571          for comma.  In C, we can do some optimizations here because
1572          we know the left operand is only being evaluated for effect.
1573          However, if the tracing kludge is in effect, then we always
1574          need to evaluate the left hand side fully, so that all the
1575          variables it mentions get traced.  */
1576     case BINOP_COMMA:
1577       (*pc)++;
1578       gen_expr (pc, ax, &value1);
1579       /* Don't just dispose of the left operand.  We might be tracing,
1580          in which case we want to emit code to trace it if it's an
1581          lvalue.  */
1582       gen_traced_pop (ax, &value1);
1583       gen_expr (pc, ax, value);
1584       /* It's the consumer's responsibility to trace the right operand.  */
1585       break;
1586
1587     case OP_LONG:               /* some integer constant */
1588       {
1589         struct type *type = (*pc)[1].type;
1590         LONGEST k = (*pc)[2].longconst;
1591         (*pc) += 4;
1592         gen_int_literal (ax, value, k, type);
1593       }
1594       break;
1595
1596     case OP_VAR_VALUE:
1597       gen_var_ref (ax, value, (*pc)[2].symbol);
1598       (*pc) += 4;
1599       break;
1600
1601     case OP_REGISTER:
1602       {
1603         const char *name = &(*pc)[2].string;
1604         int reg;
1605         (*pc) += 4 + BYTES_TO_EXP_ELEM ((*pc)[1].longconst + 1);
1606         reg = frame_map_name_to_regnum (deprecated_safe_get_selected_frame (),
1607                                         name, strlen (name));
1608         if (reg == -1)
1609           internal_error (__FILE__, __LINE__,
1610                           _("Register $%s not available"), name);
1611         value->kind = axs_lvalue_register;
1612         value->u.reg = reg;
1613         value->type = register_type (current_gdbarch, reg);
1614       }
1615       break;
1616
1617     case OP_INTERNALVAR:
1618       error (_("GDB agent expressions cannot use convenience variables."));
1619
1620       /* Weirdo operator: see comments for gen_repeat for details.  */
1621     case BINOP_REPEAT:
1622       /* Note that gen_repeat handles its own argument evaluation.  */
1623       (*pc)++;
1624       gen_repeat (pc, ax, value);
1625       break;
1626
1627     case UNOP_CAST:
1628       {
1629         struct type *type = (*pc)[1].type;
1630         (*pc) += 3;
1631         gen_expr (pc, ax, value);
1632         gen_cast (ax, value, type);
1633       }
1634       break;
1635
1636     case UNOP_MEMVAL:
1637       {
1638         struct type *type = check_typedef ((*pc)[1].type);
1639         (*pc) += 3;
1640         gen_expr (pc, ax, value);
1641         /* I'm not sure I understand UNOP_MEMVAL entirely.  I think
1642            it's just a hack for dealing with minsyms; you take some
1643            integer constant, pretend it's the address of an lvalue of
1644            the given type, and dereference it.  */
1645         if (value->kind != axs_rvalue)
1646           /* This would be weird.  */
1647           internal_error (__FILE__, __LINE__,
1648                           _("gen_expr: OP_MEMVAL operand isn't an rvalue???"));
1649         value->type = type;
1650         value->kind = axs_lvalue_memory;
1651       }
1652       break;
1653
1654     case UNOP_PLUS:
1655       (*pc)++;
1656       /* + FOO is equivalent to 0 + FOO, which can be optimized. */
1657       gen_expr (pc, ax, value);
1658       gen_usual_unary (ax, value);
1659       break;
1660
1661     case UNOP_NEG:
1662       (*pc)++;
1663       /* -FOO is equivalent to 0 - FOO.  */
1664       gen_int_literal (ax, &value1, (LONGEST) 0, builtin_type_int);
1665       gen_usual_unary (ax, &value1);    /* shouldn't do much */
1666       gen_expr (pc, ax, &value2);
1667       gen_usual_unary (ax, &value2);
1668       gen_usual_arithmetic (ax, &value1, &value2);
1669       gen_sub (ax, value, &value1, &value2);
1670       break;
1671
1672     case UNOP_LOGICAL_NOT:
1673       (*pc)++;
1674       gen_expr (pc, ax, value);
1675       gen_logical_not (ax, value);
1676       break;
1677
1678     case UNOP_COMPLEMENT:
1679       (*pc)++;
1680       gen_expr (pc, ax, value);
1681       gen_complement (ax, value);
1682       break;
1683
1684     case UNOP_IND:
1685       (*pc)++;
1686       gen_expr (pc, ax, value);
1687       gen_usual_unary (ax, value);
1688       if (TYPE_CODE (value->type) != TYPE_CODE_PTR)
1689         error (_("Argument of unary `*' is not a pointer."));
1690       gen_deref (ax, value);
1691       break;
1692
1693     case UNOP_ADDR:
1694       (*pc)++;
1695       gen_expr (pc, ax, value);
1696       gen_address_of (ax, value);
1697       break;
1698
1699     case UNOP_SIZEOF:
1700       (*pc)++;
1701       /* Notice that gen_sizeof handles its own operand, unlike most
1702          of the other unary operator functions.  This is because we
1703          have to throw away the code we generate.  */
1704       gen_sizeof (pc, ax, value);
1705       break;
1706
1707     case STRUCTOP_STRUCT:
1708     case STRUCTOP_PTR:
1709       {
1710         int length = (*pc)[1].longconst;
1711         char *name = &(*pc)[2].string;
1712
1713         (*pc) += 4 + BYTES_TO_EXP_ELEM (length + 1);
1714         gen_expr (pc, ax, value);
1715         if (op == STRUCTOP_STRUCT)
1716           gen_struct_ref (ax, value, name, ".", "structure or union");
1717         else if (op == STRUCTOP_PTR)
1718           gen_struct_ref (ax, value, name, "->",
1719                           "pointer to a structure or union");
1720         else
1721           /* If this `if' chain doesn't handle it, then the case list
1722              shouldn't mention it, and we shouldn't be here.  */
1723           internal_error (__FILE__, __LINE__,
1724                           _("gen_expr: unhandled struct case"));
1725       }
1726       break;
1727
1728     case OP_TYPE:
1729       error (_("Attempt to use a type name as an expression."));
1730
1731     default:
1732       error (_("Unsupported operator in expression."));
1733     }
1734 }
1735 \f
1736
1737
1738 /* Generating bytecode from GDB expressions: driver */
1739
1740 /* Given a GDB expression EXPR, produce a string of agent bytecode
1741    which computes its value.  Return the agent expression, and set
1742    *VALUE to describe its type, and whether it's an lvalue or rvalue.  */
1743 struct agent_expr *
1744 expr_to_agent (struct expression *expr, struct axs_value *value)
1745 {
1746   struct cleanup *old_chain = 0;
1747   struct agent_expr *ax = new_agent_expr (0);
1748   union exp_element *pc;
1749
1750   old_chain = make_cleanup_free_agent_expr (ax);
1751
1752   pc = expr->elts;
1753   trace_kludge = 0;
1754   gen_expr (&pc, ax, value);
1755
1756   /* We have successfully built the agent expr, so cancel the cleanup
1757      request.  If we add more cleanups that we always want done, this
1758      will have to get more complicated.  */
1759   discard_cleanups (old_chain);
1760   return ax;
1761 }
1762
1763
1764 #if 0                           /* not used */
1765 /* Given a GDB expression EXPR denoting an lvalue in memory, produce a
1766    string of agent bytecode which will leave its address and size on
1767    the top of stack.  Return the agent expression.
1768
1769    Not sure this function is useful at all.  */
1770 struct agent_expr *
1771 expr_to_address_and_size (struct expression *expr)
1772 {
1773   struct axs_value value;
1774   struct agent_expr *ax = expr_to_agent (expr, &value);
1775
1776   /* Complain if the result is not a memory lvalue.  */
1777   if (value.kind != axs_lvalue_memory)
1778     {
1779       free_agent_expr (ax);
1780       error (_("Expression does not denote an object in memory."));
1781     }
1782
1783   /* Push the object's size on the stack.  */
1784   ax_const_l (ax, TYPE_LENGTH (value.type));
1785
1786   return ax;
1787 }
1788 #endif
1789
1790 /* Given a GDB expression EXPR, return bytecode to trace its value.
1791    The result will use the `trace' and `trace_quick' bytecodes to
1792    record the value of all memory touched by the expression.  The
1793    caller can then use the ax_reqs function to discover which
1794    registers it relies upon.  */
1795 struct agent_expr *
1796 gen_trace_for_expr (CORE_ADDR scope, struct expression *expr)
1797 {
1798   struct cleanup *old_chain = 0;
1799   struct agent_expr *ax = new_agent_expr (scope);
1800   union exp_element *pc;
1801   struct axs_value value;
1802
1803   old_chain = make_cleanup_free_agent_expr (ax);
1804
1805   pc = expr->elts;
1806   trace_kludge = 1;
1807   gen_expr (&pc, ax, &value);
1808
1809   /* Make sure we record the final object, and get rid of it.  */
1810   gen_traced_pop (ax, &value);
1811
1812   /* Oh, and terminate.  */
1813   ax_simple (ax, aop_end);
1814
1815   /* We have successfully built the agent expr, so cancel the cleanup
1816      request.  If we add more cleanups that we always want done, this
1817      will have to get more complicated.  */
1818   discard_cleanups (old_chain);
1819   return ax;
1820 }
1821
1822 static void
1823 agent_command (char *exp, int from_tty)
1824 {
1825   struct cleanup *old_chain = 0;
1826   struct expression *expr;
1827   struct agent_expr *agent;
1828   struct frame_info *fi = get_current_frame (); /* need current scope */
1829
1830   /* We don't deal with overlay debugging at the moment.  We need to
1831      think more carefully about this.  If you copy this code into
1832      another command, change the error message; the user shouldn't
1833      have to know anything about agent expressions.  */
1834   if (overlay_debugging)
1835     error (_("GDB can't do agent expression translation with overlays."));
1836
1837   if (exp == 0)
1838     error_no_arg (_("expression to translate"));
1839
1840   expr = parse_expression (exp);
1841   old_chain = make_cleanup (free_current_contents, &expr);
1842   agent = gen_trace_for_expr (get_frame_pc (fi), expr);
1843   make_cleanup_free_agent_expr (agent);
1844   ax_print (gdb_stdout, agent);
1845
1846   /* It would be nice to call ax_reqs here to gather some general info
1847      about the expression, and then print out the result.  */
1848
1849   do_cleanups (old_chain);
1850   dont_repeat ();
1851 }
1852 \f
1853
1854 /* Initialization code.  */
1855
1856 void _initialize_ax_gdb (void);
1857 void
1858 _initialize_ax_gdb (void)
1859 {
1860   add_cmd ("agent", class_maintenance, agent_command,
1861            _("Translate an expression into remote agent bytecode."),
1862            &maintenancelist);
1863 }