OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [ax-gdb.c] - Blame information for rev 227

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.