2003-01-13 Andrew Cagney <ac131313@redhat.com>
* ax-gdb.c, c-valprint.c, charset.c, corefile.c: Update copyright.
* demangle.c, disasm.c, dwarf2cfi.c, dwarfread.c: Update copyright.
* elfread.c, eval.c, expprint.c, expression.h: Update copyright.
* f-typeprint.c, findvar.c, gcore.c, gdb_mbuild.sh: Update copyright.
* gdbtypes.h, gnu-v2-abi.c, inferior.h, inftarg.c: Update copyright.
* language.c, language.h, m32r-tdep.c: Update copyright.
* mn10200-tdep.c, scm-lang.c, scm-lang.h: Update copyright.
* somsolib.c, somsolib.h, symfile.c, symtab.h: Update copyright.
* thread-db.c, typeprint.c, utils.c, valarith.c: Update copyright.
* values.c, win32-nat.c, x86-64-linux-nat.c: Update copyright.
* x86-64-linux-tdep.c, z8k-tdep.c: Update copyright.
* cli/cli-decode.h, config/h8500/tm-h8500.h: Update copyright.
Index: mi/ChangeLog
2003-01-13 Andrew Cagney <ac131313@redhat.com>
* mi-cmd-env.c: Update copyright.
2003-01-14 01:49:06 +01:00
|
|
|
|
/* GDB-specific functions for operating on agent expressions.
|
|
|
|
|
|
2008-01-01 23:53:26 +01:00
|
|
|
|
Copyright (C) 1998, 1999, 2000, 2001, 2003, 2007, 2008
|
2007-01-09 18:59:20 +01:00
|
|
|
|
Free Software Foundation, Inc.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
This file is part of GDB.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
2007-08-23 20:08:50 +02:00
|
|
|
|
the Free Software Foundation; either version 3 of the License, or
|
1999-07-07 22:19:36 +02:00
|
|
|
|
(at your option) any later version.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
You should have received a copy of the GNU General Public License
|
2007-08-23 20:08:50 +02:00
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
#include "defs.h"
|
|
|
|
|
#include "symtab.h"
|
|
|
|
|
#include "symfile.h"
|
|
|
|
|
#include "gdbtypes.h"
|
|
|
|
|
#include "value.h"
|
|
|
|
|
#include "expression.h"
|
|
|
|
|
#include "command.h"
|
|
|
|
|
#include "gdbcmd.h"
|
|
|
|
|
#include "frame.h"
|
|
|
|
|
#include "target.h"
|
|
|
|
|
#include "ax.h"
|
|
|
|
|
#include "ax-gdb.h"
|
2002-08-28 00:37:14 +02:00
|
|
|
|
#include "gdb_string.h"
|
2003-02-19 David Carlton <carlton@math.stanford.edu>
* Makefile.in (SFILES): Add block.c.
(block_h): New.
(COMMON_OBS): Add block.o.
(block.o): New.
(x86-64-tdep.o): Add $(block_h).
(values.o, valops.o, tracepoint.o, symtab.o, symmisc.o, symfile.o)
(stack.o, printcmd.o, p-exp.tab.o, parse.o, objfiles.o)
(objc-exp.tab.o, objc-lang.o, nlmread.o, mips-tdep.o, mdebugread.o)
(m2-exp.tab.o, linespec.o, jv-lang.o, jv-exp.tab.o, infcmd.o)
(f-valprint.o, findvar.o, f-exp.tab.o, expprint.o, coffread.o)
(c-exp.tab.o, buildsym.o, breakpoint.o, blockframe.o, ax-gdb.o)
(alpha-tdep.o, ada-lang.o, ada-exp.tab.o, mi-cmd-stack.o): Ditto.
* value.h: Add opaque declaration for struct block.
* parser-defs.h, objc-lang.h, buildsym.h, breakpoint.h: Ditto.
* ada-lang.h: Ditto.
* x86-64-tdep.c: #include "block.h"
* values.c, valops.c, tracepoint.c, symtab.c, symmisc.c: Ditto.
* symfile.c, stack.c, printcmd.c, p-exp.y, parse.c: Ditto.
* objfiles.c, objc-exp.y, objc-lang.c, nlmread.c: Ditto.
* mips-tdep.c, mdebugread.c, m2-exp.y, linespec.c: Ditto.
* jv-lang.c, jv-exp.y, infcmd.c, f-valprint.c: Ditto.
* findvar.c, f-exp.y, expprint.c, coffread.c, c-exp.y: Ditto.
* buildsym.c, breakpoint.c, blockframe.c, ax-gdb.c: Ditto.
* alpha-tdep.c, ada-lang.c, ada-exp.y: Ditto.
* blockframe.c (blockvector_for_pc_sect): Move to "block.c".
(blockvector_for_pc, block_for_pc_sect, block_for_pc): Ditto.
* symtab.c (block_function): Ditto.
(contained_in): Ditto.
* frame.h: Move block_for_pc and block_for_pc_sect declarations to
block.h. Add opaque declaration for struct block.
* symtab.h: Move block_function and contained_in declarations to
block.h. Add opaque declarations for struct block, struct
blockvector.
(struct block): Move to block.h.
(struct blockvector): Ditto.
(BLOCK_START, BLOCK_END, BLOCK_FUNCTION, BLOCK_SUPERBLOCK)
(BLOCK_GCC_COMPILED, BLOCK_HASHTABLE, BLOCK_NSYMS, BLOCK_SYM)
(BLOCK_BUCKETS, BLOCK_BUCKET, BLOCK_HASHTABLE_SIZE)
(ALL_BLOCK_SYMBOLS, BLOCK_SHOULD_SORT, BLOCKVECTOR_NBLOCKS)
(BLOCKVECTOR_BLOCK, GLOBAL_BLOCK, STATIC_BLOCK, FIRST_LOCAL_BLOCK):
Ditto.
* block.c: New file.
* block.h: New file.
2003-02-19 David Carlton <carlton@math.stanford.edu>
* mi-cmd-stack.c: #include "block.h"
2003-02-20 01:01:07 +01:00
|
|
|
|
#include "block.h"
|
2003-03-01 18:03:19 +01:00
|
|
|
|
#include "regcache.h"
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-09-28 23:55:21 +02:00
|
|
|
|
/* To make sense of this file, you should read doc/agentexpr.texi.
|
|
|
|
|
Then look at the types and enums in ax-gdb.h. For the code itself,
|
|
|
|
|
look at gen_expr, towards the bottom; that's the main function that
|
|
|
|
|
looks at the GDB expressions and calls everything else to generate
|
|
|
|
|
code.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
I'm beginning to wonder whether it wouldn't be nicer to internally
|
|
|
|
|
generate trees, with types, and then spit out the bytecode in
|
|
|
|
|
linear form afterwards; we could generate fewer `swap', `ext', and
|
|
|
|
|
`zero_ext' bytecodes that way; it would make good constant folding
|
|
|
|
|
easier, too. But at the moment, I think we should be willing to
|
|
|
|
|
pay for the simplicity of this code with less-than-optimal bytecode
|
|
|
|
|
strings.
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
Remember, "GBD" stands for "Great Britain, Dammit!" So be careful. */
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Prototypes for local functions. */
|
|
|
|
|
|
|
|
|
|
/* There's a standard order to the arguments of these functions:
|
|
|
|
|
union exp_element ** --- pointer into expression
|
|
|
|
|
struct agent_expr * --- agent expression buffer to generate code into
|
|
|
|
|
struct axs_value * --- describes value left on top of stack */
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
|
static struct value *const_var_ref (struct symbol *var);
|
|
|
|
|
static struct value *const_expr (union exp_element **pc);
|
|
|
|
|
static struct value *maybe_const_expr (union exp_element **pc);
|
|
|
|
|
|
|
|
|
|
static void gen_traced_pop (struct agent_expr *, struct axs_value *);
|
|
|
|
|
|
|
|
|
|
static void gen_sign_extend (struct agent_expr *, struct type *);
|
|
|
|
|
static void gen_extend (struct agent_expr *, struct type *);
|
|
|
|
|
static void gen_fetch (struct agent_expr *, struct type *);
|
|
|
|
|
static void gen_left_shift (struct agent_expr *, int);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void gen_frame_args_address (struct agent_expr *);
|
|
|
|
|
static void gen_frame_locals_address (struct agent_expr *);
|
|
|
|
|
static void gen_offset (struct agent_expr *ax, int offset);
|
|
|
|
|
static void gen_sym_offset (struct agent_expr *, struct symbol *);
|
|
|
|
|
static void gen_var_ref (struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value, struct symbol *var);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void gen_int_literal (struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value,
|
|
|
|
|
LONGEST k, struct type *type);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void require_rvalue (struct agent_expr *ax, struct axs_value *value);
|
|
|
|
|
static void gen_usual_unary (struct agent_expr *ax, struct axs_value *value);
|
|
|
|
|
static int type_wider_than (struct type *type1, struct type *type2);
|
|
|
|
|
static struct type *max_type (struct type *type1, struct type *type2);
|
|
|
|
|
static void gen_conversion (struct agent_expr *ax,
|
|
|
|
|
struct type *from, struct type *to);
|
|
|
|
|
static int is_nontrivial_conversion (struct type *from, struct type *to);
|
|
|
|
|
static void gen_usual_arithmetic (struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value1,
|
|
|
|
|
struct axs_value *value2);
|
|
|
|
|
static void gen_integral_promotions (struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value);
|
|
|
|
|
static void gen_cast (struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value, struct type *type);
|
|
|
|
|
static void gen_scale (struct agent_expr *ax,
|
|
|
|
|
enum agent_op op, struct type *type);
|
|
|
|
|
static void gen_add (struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value,
|
|
|
|
|
struct axs_value *value1,
|
|
|
|
|
struct axs_value *value2, char *name);
|
|
|
|
|
static void gen_sub (struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value,
|
|
|
|
|
struct axs_value *value1, struct axs_value *value2);
|
|
|
|
|
static void gen_binop (struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value,
|
|
|
|
|
struct axs_value *value1,
|
|
|
|
|
struct axs_value *value2,
|
|
|
|
|
enum agent_op op,
|
|
|
|
|
enum agent_op op_unsigned, int may_carry, char *name);
|
|
|
|
|
static void gen_logical_not (struct agent_expr *ax, struct axs_value *value);
|
|
|
|
|
static void gen_complement (struct agent_expr *ax, struct axs_value *value);
|
|
|
|
|
static void gen_deref (struct agent_expr *, struct axs_value *);
|
|
|
|
|
static void gen_address_of (struct agent_expr *, struct axs_value *);
|
|
|
|
|
static int find_field (struct type *type, char *name);
|
|
|
|
|
static void gen_bitfield_ref (struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value,
|
|
|
|
|
struct type *type, int start, int end);
|
|
|
|
|
static void gen_struct_ref (struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value,
|
|
|
|
|
char *field,
|
|
|
|
|
char *operator_name, char *operand_name);
|
|
|
|
|
static void gen_repeat (union exp_element **pc,
|
|
|
|
|
struct agent_expr *ax, struct axs_value *value);
|
|
|
|
|
static void gen_sizeof (union exp_element **pc,
|
|
|
|
|
struct agent_expr *ax, struct axs_value *value);
|
|
|
|
|
static void gen_expr (union exp_element **pc,
|
|
|
|
|
struct agent_expr *ax, struct axs_value *value);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
|
static void agent_command (char *exp, int from_tty);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Detecting constant expressions. */
|
|
|
|
|
|
|
|
|
|
/* If the variable reference at *PC is a constant, return its value.
|
|
|
|
|
Otherwise, return zero.
|
|
|
|
|
|
|
|
|
|
Hey, Wally! How can a variable reference be a constant?
|
|
|
|
|
|
|
|
|
|
Well, Beav, this function really handles the OP_VAR_VALUE operator,
|
|
|
|
|
not specifically variable references. GDB uses OP_VAR_VALUE to
|
|
|
|
|
refer to any kind of symbolic reference: function names, enum
|
|
|
|
|
elements, and goto labels are all handled through the OP_VAR_VALUE
|
|
|
|
|
operator, even though they're constants. It makes sense given the
|
|
|
|
|
situation.
|
|
|
|
|
|
|
|
|
|
Gee, Wally, don'cha wonder sometimes if data representations that
|
|
|
|
|
subvert commonly accepted definitions of terms in favor of heavily
|
|
|
|
|
context-specific interpretations are really just a tool of the
|
|
|
|
|
programming hegemony to preserve their power and exclude the
|
|
|
|
|
proletariat? */
|
|
|
|
|
|
|
|
|
|
static struct value *
|
2000-07-30 03:48:28 +02:00
|
|
|
|
const_var_ref (struct symbol *var)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
struct type *type = SYMBOL_TYPE (var);
|
|
|
|
|
|
|
|
|
|
switch (SYMBOL_CLASS (var))
|
|
|
|
|
{
|
|
|
|
|
case LOC_CONST:
|
|
|
|
|
return value_from_longest (type, (LONGEST) SYMBOL_VALUE (var));
|
|
|
|
|
|
|
|
|
|
case LOC_LABEL:
|
* gdbarch.sh (POINTER_TO_ADDRESS, ADDRESS_TO_POINTER): Two new
functions which architectures can redefine, defaulting to
generic_pointer_to_address and generic_address_to_pointer.
* findvar.c (extract_typed_address, store_typed_address,
generic_pointer_to_address, generic_address_to_pointer): New
functions.
(POINTER_TO_ADDRESS, ADDRESS_TO_POINTER): Provide default
definitions.
(extract_address, store_address): Doc fixes.
* values.c (value_as_pointer): Doc fix.
(value_from_pointer): New function.
* defs.h (extract_typed_address, store_typed_address): New
declarations.
* inferior.h (generic_address_to_pointer,
generic_pointer_to_address): New declarations.
* value.h (value_from_pointer): New declaration.
* ax-gdb.c (const_var_ref): Use value_from_pointer, not
value_from_longest.
* blockframe.c (generic_push_dummy_frame): Use read_pc and
read_sp, not read_register.
* c-valprint.c (c_val_print): Use extract_typed_address instead of
extract_address to extract vtable entries and references.
* cp-valprint.c (cp_print_value_fields): Use value_from_pointer
instead of value_from_longest to extract the vtable's address.
* eval.c (evaluate_subexp_standard): Use value_from_pointer
instead of value_from_longest to compute `this', and for doing
pointer-to-member dereferencing.
* findvar.c (read_register): Use extract_unsigned_integer, not
extract_address.
(read_var_value): Use store_typed_address instead of store_address
for building label values.
(locate_var_value): Use value_from_pointer instead of
value_from_longest.
* hppa-tdep.c (find_stub_with_shl_get): Use value_from_pointer,
instead of value_from_longest, to build arguments to __d_shl_get.
* printcmd.c (set_next_address): Use value_from_pointer, not
value_from_longest.
(x_command): Use value_from_pointer, not value_from_longest.
* tracepoint.c (set_traceframe_context): Use value_from_pointer,
not value_from_longest.
* valarith.c (value_add, value_sub): Use value_from_pointer, not
value_from_longest.
* valops.c (find_function_in_inferior, value_coerce_array,
value_coerce_function, value_addr, hand_function_call): Same.
* value.h (COERCE_REF): Use unpack_pointer, not unpack_long.
* values.c (unpack_long): Use extract_typed_address to produce
addresses from pointers and references, not extract_address.
(value_from_longest): Use store_typed_address instead of
store_address to produce pointer and reference values.
2000-04-14 20:43:41 +02:00
|
|
|
|
return value_from_pointer (type, (CORE_ADDR) SYMBOL_VALUE_ADDRESS (var));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* If the expression starting at *PC has a constant value, return it.
|
|
|
|
|
Otherwise, return zero. If we return a value, then *PC will be
|
|
|
|
|
advanced to the end of it. If we return zero, *PC could be
|
|
|
|
|
anywhere. */
|
|
|
|
|
static struct value *
|
2000-07-30 03:48:28 +02:00
|
|
|
|
const_expr (union exp_element **pc)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
enum exp_opcode op = (*pc)->opcode;
|
|
|
|
|
struct value *v1;
|
|
|
|
|
|
|
|
|
|
switch (op)
|
|
|
|
|
{
|
|
|
|
|
case OP_LONG:
|
|
|
|
|
{
|
|
|
|
|
struct type *type = (*pc)[1].type;
|
|
|
|
|
LONGEST k = (*pc)[2].longconst;
|
|
|
|
|
(*pc) += 4;
|
|
|
|
|
return value_from_longest (type, k);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case OP_VAR_VALUE:
|
|
|
|
|
{
|
|
|
|
|
struct value *v = const_var_ref ((*pc)[2].symbol);
|
|
|
|
|
(*pc) += 4;
|
|
|
|
|
return v;
|
|
|
|
|
}
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
/* We could add more operators in here. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
case UNOP_NEG:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
v1 = const_expr (pc);
|
|
|
|
|
if (v1)
|
|
|
|
|
return value_neg (v1);
|
|
|
|
|
else
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Like const_expr, but guarantee also that *PC is undisturbed if the
|
|
|
|
|
expression is not constant. */
|
|
|
|
|
static struct value *
|
2000-07-30 03:48:28 +02:00
|
|
|
|
maybe_const_expr (union exp_element **pc)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
union exp_element *tentative_pc = *pc;
|
|
|
|
|
struct value *v = const_expr (&tentative_pc);
|
|
|
|
|
|
|
|
|
|
/* If we got a value, then update the real PC. */
|
|
|
|
|
if (v)
|
|
|
|
|
*pc = tentative_pc;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
return v;
|
|
|
|
|
}
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Generating bytecode from GDB expressions: general assumptions */
|
|
|
|
|
|
|
|
|
|
/* Here are a few general assumptions made throughout the code; if you
|
|
|
|
|
want to make a change that contradicts one of these, then you'd
|
|
|
|
|
better scan things pretty thoroughly.
|
|
|
|
|
|
|
|
|
|
- We assume that all values occupy one stack element. For example,
|
1999-07-07 22:19:36 +02:00
|
|
|
|
sometimes we'll swap to get at the left argument to a binary
|
|
|
|
|
operator. If we decide that void values should occupy no stack
|
|
|
|
|
elements, or that synthetic arrays (whose size is determined at
|
|
|
|
|
run time, created by the `@' operator) should occupy two stack
|
|
|
|
|
elements (address and length), then this will cause trouble.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
- We assume the stack elements are infinitely wide, and that we
|
1999-07-07 22:19:36 +02:00
|
|
|
|
don't have to worry what happens if the user requests an
|
|
|
|
|
operation that is wider than the actual interpreter's stack.
|
|
|
|
|
That is, it's up to the interpreter to handle directly all the
|
|
|
|
|
integer widths the user has access to. (Woe betide the language
|
|
|
|
|
with bignums!)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
- We don't support side effects. Thus, we don't have to worry about
|
1999-07-07 22:19:36 +02:00
|
|
|
|
GCC's generalized lvalues, function calls, etc.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
- We don't support floating point. Many places where we switch on
|
1999-07-07 22:19:36 +02:00
|
|
|
|
some type don't bother to include cases for floating point; there
|
|
|
|
|
may be even more subtle ways this assumption exists. For
|
|
|
|
|
example, the arguments to % must be integers.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
- We assume all subexpressions have a static, unchanging type. If
|
1999-07-07 22:19:36 +02:00
|
|
|
|
we tried to support convenience variables, this would be a
|
|
|
|
|
problem.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
- All values on the stack should always be fully zero- or
|
1999-07-07 22:19:36 +02:00
|
|
|
|
sign-extended.
|
|
|
|
|
|
|
|
|
|
(I wasn't sure whether to choose this or its opposite --- that
|
|
|
|
|
only addresses are assumed extended --- but it turns out that
|
|
|
|
|
neither convention completely eliminates spurious extend
|
|
|
|
|
operations (if everything is always extended, then you have to
|
|
|
|
|
extend after add, because it could overflow; if nothing is
|
|
|
|
|
extended, then you end up producing extends whenever you change
|
|
|
|
|
sizes), and this is simpler.) */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Generating bytecode from GDB expressions: the `trace' kludge */
|
|
|
|
|
|
|
|
|
|
/* The compiler in this file is a general-purpose mechanism for
|
|
|
|
|
translating GDB expressions into bytecode. One ought to be able to
|
|
|
|
|
find a million and one uses for it.
|
|
|
|
|
|
|
|
|
|
However, at the moment it is HOPELESSLY BRAIN-DAMAGED for the sake
|
|
|
|
|
of expediency. Let he who is without sin cast the first stone.
|
|
|
|
|
|
|
|
|
|
For the data tracing facility, we need to insert `trace' bytecodes
|
|
|
|
|
before each data fetch; this records all the memory that the
|
|
|
|
|
expression touches in the course of evaluation, so that memory will
|
|
|
|
|
be available when the user later tries to evaluate the expression
|
|
|
|
|
in GDB.
|
|
|
|
|
|
|
|
|
|
This should be done (I think) in a post-processing pass, that walks
|
|
|
|
|
an arbitrary agent expression and inserts `trace' operations at the
|
|
|
|
|
appropriate points. But it's much faster to just hack them
|
|
|
|
|
directly into the code. And since we're in a crunch, that's what
|
|
|
|
|
I've done.
|
|
|
|
|
|
|
|
|
|
Setting the flag trace_kludge to non-zero enables the code that
|
|
|
|
|
emits the trace bytecodes at the appropriate points. */
|
|
|
|
|
static int trace_kludge;
|
|
|
|
|
|
|
|
|
|
/* Trace the lvalue on the stack, if it needs it. In either case, pop
|
|
|
|
|
the value. Useful on the left side of a comma, and at the end of
|
|
|
|
|
an expression being used for tracing. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_traced_pop (struct agent_expr *ax, struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
if (trace_kludge)
|
|
|
|
|
switch (value->kind)
|
|
|
|
|
{
|
|
|
|
|
case axs_rvalue:
|
|
|
|
|
/* We don't trace rvalues, just the lvalues necessary to
|
1999-07-07 22:19:36 +02:00
|
|
|
|
produce them. So just dispose of this value. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
ax_simple (ax, aop_pop);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case axs_lvalue_memory:
|
|
|
|
|
{
|
2007-10-27 01:04:57 +02:00
|
|
|
|
int length = TYPE_LENGTH (check_typedef (value->type));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* There's no point in trying to use a trace_quick bytecode
|
|
|
|
|
here, since "trace_quick SIZE pop" is three bytes, whereas
|
|
|
|
|
"const8 SIZE trace" is also three bytes, does the same
|
|
|
|
|
thing, and the simplest code which generates that will also
|
|
|
|
|
work correctly for objects with large sizes. */
|
|
|
|
|
ax_const_l (ax, length);
|
|
|
|
|
ax_simple (ax, aop_trace);
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
case axs_lvalue_register:
|
|
|
|
|
/* We need to mention the register somewhere in the bytecode,
|
|
|
|
|
so ax_reqs will pick it up and add it to the mask of
|
|
|
|
|
registers used. */
|
|
|
|
|
ax_reg (ax, value->u.reg);
|
|
|
|
|
ax_simple (ax, aop_pop);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
/* If we're not tracing, just pop the value. */
|
|
|
|
|
ax_simple (ax, aop_pop);
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generating bytecode from GDB expressions: helper functions */
|
|
|
|
|
|
|
|
|
|
/* Assume that the lower bits of the top of the stack is a value of
|
|
|
|
|
type TYPE, and the upper bits are zero. Sign-extend if necessary. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_sign_extend (struct agent_expr *ax, struct type *type)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Do we need to sign-extend this? */
|
1999-07-07 22:19:36 +02:00
|
|
|
|
if (!TYPE_UNSIGNED (type))
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
ax_ext (ax, TYPE_LENGTH (type) * TARGET_CHAR_BIT);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Assume the lower bits of the top of the stack hold a value of type
|
|
|
|
|
TYPE, and the upper bits are garbage. Sign-extend or truncate as
|
|
|
|
|
needed. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_extend (struct agent_expr *ax, struct type *type)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
int bits = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* I just had to. */
|
|
|
|
|
((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, bits));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Assume that the top of the stack contains a value of type "pointer
|
|
|
|
|
to TYPE"; generate code to fetch its value. Note that TYPE is the
|
|
|
|
|
target type, not the pointer type. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_fetch (struct agent_expr *ax, struct type *type)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
if (trace_kludge)
|
|
|
|
|
{
|
|
|
|
|
/* Record the area of memory we're about to fetch. */
|
|
|
|
|
ax_trace_quick (ax, TYPE_LENGTH (type));
|
|
|
|
|
}
|
|
|
|
|
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
switch (TYPE_CODE (type))
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
case TYPE_CODE_PTR:
|
|
|
|
|
case TYPE_CODE_ENUM:
|
|
|
|
|
case TYPE_CODE_INT:
|
|
|
|
|
case TYPE_CODE_CHAR:
|
|
|
|
|
/* It's a scalar value, so we know how to dereference it. How
|
|
|
|
|
many bytes long is it? */
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
switch (TYPE_LENGTH (type))
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
1999-07-07 22:19:36 +02:00
|
|
|
|
case 8 / TARGET_CHAR_BIT:
|
|
|
|
|
ax_simple (ax, aop_ref8);
|
|
|
|
|
break;
|
|
|
|
|
case 16 / TARGET_CHAR_BIT:
|
|
|
|
|
ax_simple (ax, aop_ref16);
|
|
|
|
|
break;
|
|
|
|
|
case 32 / TARGET_CHAR_BIT:
|
|
|
|
|
ax_simple (ax, aop_ref32);
|
|
|
|
|
break;
|
|
|
|
|
case 64 / TARGET_CHAR_BIT:
|
|
|
|
|
ax_simple (ax, aop_ref64);
|
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Either our caller shouldn't have asked us to dereference
|
|
|
|
|
that pointer (other code's fault), or we're not
|
|
|
|
|
implementing something we should be (this code's fault).
|
|
|
|
|
In any case, it's a bug the user shouldn't see. */
|
|
|
|
|
default:
|
2001-02-08 07:03:54 +01:00
|
|
|
|
internal_error (__FILE__, __LINE__,
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
_("gen_fetch: strange size"));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
gen_sign_extend (ax, type);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
/* Either our caller shouldn't have asked us to dereference that
|
1999-07-07 22:19:36 +02:00
|
|
|
|
pointer (other code's fault), or we're not implementing
|
|
|
|
|
something we should be (this code's fault). In any case,
|
|
|
|
|
it's a bug the user shouldn't see. */
|
2001-02-08 07:03:54 +01:00
|
|
|
|
internal_error (__FILE__, __LINE__,
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
_("gen_fetch: bad type code"));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code to left shift the top of the stack by DISTANCE bits, or
|
|
|
|
|
right shift it by -DISTANCE bits if DISTANCE < 0. This generates
|
|
|
|
|
unsigned (logical) right shifts. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_left_shift (struct agent_expr *ax, int distance)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
if (distance > 0)
|
|
|
|
|
{
|
|
|
|
|
ax_const_l (ax, distance);
|
|
|
|
|
ax_simple (ax, aop_lsh);
|
|
|
|
|
}
|
|
|
|
|
else if (distance < 0)
|
|
|
|
|
{
|
|
|
|
|
ax_const_l (ax, -distance);
|
|
|
|
|
ax_simple (ax, aop_rsh_unsigned);
|
|
|
|
|
}
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generating bytecode from GDB expressions: symbol references */
|
|
|
|
|
|
|
|
|
|
/* Generate code to push the base address of the argument portion of
|
|
|
|
|
the top stack frame. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_frame_args_address (struct agent_expr *ax)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2001-08-11 02:59:29 +02:00
|
|
|
|
int frame_reg;
|
|
|
|
|
LONGEST frame_offset;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2007-06-12 18:43:39 +02:00
|
|
|
|
gdbarch_virtual_frame_pointer (current_gdbarch,
|
|
|
|
|
ax->scope, &frame_reg, &frame_offset);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
ax_reg (ax, frame_reg);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_offset (ax, frame_offset);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code to push the base address of the locals portion of the
|
|
|
|
|
top stack frame. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_frame_locals_address (struct agent_expr *ax)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2001-08-11 02:59:29 +02:00
|
|
|
|
int frame_reg;
|
|
|
|
|
LONGEST frame_offset;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2007-06-12 18:43:39 +02:00
|
|
|
|
gdbarch_virtual_frame_pointer (current_gdbarch,
|
|
|
|
|
ax->scope, &frame_reg, &frame_offset);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
ax_reg (ax, frame_reg);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_offset (ax, frame_offset);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code to add OFFSET to the top of the stack. Try to
|
|
|
|
|
generate short and readable code. We use this for getting to
|
|
|
|
|
variables on the stack, and structure members. If we were
|
|
|
|
|
programming in ML, it would be clearer why these are the same
|
|
|
|
|
thing. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_offset (struct agent_expr *ax, int offset)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* It would suffice to simply push the offset and add it, but this
|
|
|
|
|
makes it easier to read positive and negative offsets in the
|
|
|
|
|
bytecode. */
|
|
|
|
|
if (offset > 0)
|
|
|
|
|
{
|
|
|
|
|
ax_const_l (ax, offset);
|
|
|
|
|
ax_simple (ax, aop_add);
|
|
|
|
|
}
|
|
|
|
|
else if (offset < 0)
|
|
|
|
|
{
|
|
|
|
|
ax_const_l (ax, -offset);
|
|
|
|
|
ax_simple (ax, aop_sub);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* In many cases, a symbol's value is the offset from some other
|
|
|
|
|
address (stack frame, base register, etc.) Generate code to add
|
|
|
|
|
VAR's value to the top of the stack. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_sym_offset (struct agent_expr *ax, struct symbol *var)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
gen_offset (ax, SYMBOL_VALUE (var));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code for a variable reference to AX. The variable is the
|
|
|
|
|
symbol VAR. Set VALUE to describe the result. */
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Dereference any typedefs. */
|
|
|
|
|
value->type = check_typedef (SYMBOL_TYPE (var));
|
|
|
|
|
|
|
|
|
|
/* I'm imitating the code in read_var_value. */
|
|
|
|
|
switch (SYMBOL_CLASS (var))
|
|
|
|
|
{
|
|
|
|
|
case LOC_CONST: /* A constant, like an enum value. */
|
|
|
|
|
ax_const_l (ax, (LONGEST) SYMBOL_VALUE (var));
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_LABEL: /* A goto label, being used as a value. */
|
|
|
|
|
ax_const_l (ax, (LONGEST) SYMBOL_VALUE_ADDRESS (var));
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_CONST_BYTES:
|
2001-02-08 07:03:54 +01:00
|
|
|
|
internal_error (__FILE__, __LINE__,
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
_("gen_var_ref: LOC_CONST_BYTES symbols are not supported"));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Variable at a fixed location in memory. Easy. */
|
|
|
|
|
case LOC_STATIC:
|
|
|
|
|
/* Push the address of the variable. */
|
|
|
|
|
ax_const_l (ax, SYMBOL_VALUE_ADDRESS (var));
|
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_ARG: /* var lives in argument area of frame */
|
|
|
|
|
gen_frame_args_address (ax);
|
|
|
|
|
gen_sym_offset (ax, var);
|
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_REF_ARG: /* As above, but the frame slot really
|
|
|
|
|
holds the address of the variable. */
|
|
|
|
|
gen_frame_args_address (ax);
|
|
|
|
|
gen_sym_offset (ax, var);
|
|
|
|
|
/* Don't assume any particular pointer size. */
|
|
|
|
|
gen_fetch (ax, lookup_pointer_type (builtin_type_void));
|
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_LOCAL: /* var lives in locals area of frame */
|
|
|
|
|
gen_frame_locals_address (ax);
|
|
|
|
|
gen_sym_offset (ax, var);
|
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_TYPEDEF:
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Cannot compute value of typedef `%s'."),
|
2003-02-20 David Carlton <carlton@math.stanford.edu>
* symtab.h (SYMBOL_PRINT_NAME): Rename from SYMBOL_SOURCE_NAME;
expand comment.
* ada-lang.c (user_select_syms, ada_finish_decode_line_1): Replace
SYMBOL_PRINT_NAME with SYMBOL_SOURCE_NAME.
* ada-typeprint.c (ada_typedef_print): Ditto.
* ax-gdb.c (gen_var_ref): Ditto.
* breakpoint.c (print_one_breakpoint): Ditto.
* buildsym.c (finish_block): Ditto.
* c-valprint.c (c_val_print): Ditto.
* expprint.c (print_subexp): Ditto.
* findvar.c (locate_var_value): Ditto.
* infcmd.c (jump_command): Ditto.
* linespec.c (decode_line_2, decode_compound): Ditto.
* maint.c (maintenance_translate_address): Ditto.
* objc-lang.c (compare_selectors, compare_classes): Ditto.
* printcmd.c (build_address_symbolic, sym_info, print_frame_args):
Ditto.
* p-valprint.c (pascal_val_print): Ditto.
* stabsread.c (define_symbol): Ditto.
* stack.c (print_frame, frame_info, print_block_frame_locals)
(print_frame_arg_vars, return_command): Ditto.
* symfile.c (compare_symbols, compare_psymbols): Ditto.
* symmisc.c (print_symbol): Ditto.
* symtab.c (lookup_partial_symbol, lookup_block_symbol)
(compare_search_syms, print_symbol_info, print_msymbol_info)
(rbreak_command): Ditto.
* tracepoint.c (tracepoints_info): Ditto.
* typeprint.c (typedef_print): Ditto.
* valops.c (value_of_variable, hand_function_call): Ditto.
* cli/cli-cmds.c (edit_command, list_command): Ditto.
* ada-typeprint.c: Update Copyright.
* infcmd.c, objc-lang.c, p-valprint.c, symmisc.c: Ditto.
* tracepoint.c, cli/cli-cmds.c: Ditto.
2003-02-20 18:17:25 +01:00
|
|
|
|
SYMBOL_PRINT_NAME (var));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_BLOCK:
|
|
|
|
|
ax_const_l (ax, BLOCK_START (SYMBOL_BLOCK_VALUE (var)));
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_REGISTER:
|
|
|
|
|
/* Don't generate any code at all; in the process of treating
|
|
|
|
|
this as an lvalue or rvalue, the caller will generate the
|
|
|
|
|
right code. */
|
|
|
|
|
value->kind = axs_lvalue_register;
|
|
|
|
|
value->u.reg = SYMBOL_VALUE (var);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* A lot like LOC_REF_ARG, but the pointer lives directly in a
|
2008-05-27 21:29:52 +02:00
|
|
|
|
register, not on the stack. Simpler than LOC_REGISTER
|
|
|
|
|
because it's just like any other case where the thing
|
|
|
|
|
has a real address. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case LOC_REGPARM_ADDR:
|
|
|
|
|
ax_reg (ax, SYMBOL_VALUE (var));
|
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_UNRESOLVED:
|
|
|
|
|
{
|
1999-07-07 22:19:36 +02:00
|
|
|
|
struct minimal_symbol *msym
|
2003-02-25 David Carlton <carlton@math.stanford.edu>
* symtab.h (SYMBOL_NATURAL_NAME): New macro.
(SYMBOL_LINKAGE_NAME): Ditto.
(SYMBOL_PRINT_NAME): Use SYMBOL_NATURAL_NAME and
SYMBOL_LINKAGE_NAME.
(struct general_symbol_info): Expand comment.
(DEPRECATED_SYMBOL_NAME): Rename from SYMBOL_NAME.
(SYMBOL_MATCHES_NAME): Use DEPRECATED_SYMBOL_NAME.
(SYMBOL_MATCHES_REGEXP): Ditto.
* symtab.c (symbol_natural_name): New function.
* objfiles.h: Replace all uses of SYMBOL_NAME by
DEPRECATED_SYMBOL_NAME.
* xcoffread.c, valops.c, typeprint.c, tracepoint.c: Ditto.
* symtab.c, symmisc.c, symfile.c, stack.c, stabsread.c: Ditto.
* somsolib.c, sol-thread.c, rs6000-tdep.c, p-valprint.c: Ditto.
* printcmd.c, objfiles.c, objc-lang.c, mipsread.c: Ditto.
* minsyms.c, mdebugread.c, linespec.c, jv-lang.c: Ditto.
* i386-tdep.c, i386-linux-tdep.c, hpread.c, hppa-tdep.c: Ditto.
* gnu-v2-abi.c, f-valprint.c, findvar.c, expprint.c: Ditto.
* dwarfread.c, dwarf2read.c, dbxread.c, c-valprint.c: Ditto.
* cp-valprint.c, coffread.c, buildsym.c, breakpoint.c: Ditto.
* blockframe.c, ax-gdb.c, arm-linux-tdep.c, ada-lang.c: Ditto.
* ada-exp.y: Ditto.
* ada-exp.y: Update copyright.
* sol-thread.c, mipsread.c, jv-lang.c, f-valprint.c: Ditto.
* cp-valprint.c: Ditto.
2003-02-25 David Carlton <carlton@math.stanford.edu>
* generic/gdbtk.h: Replace all instances of SYMBOL_NAME by
DEPRECATED_SYMBOL_NAME.
* generic/gdbtk-stack.c, generic/gdbtk-cmds.c: Ditto.
* generic/gdbtk-stack.c, generic/gdbtk-cmds.c: Update copyright.
2003-02-25 David Carlton <carlton@math.stanford.edu>
* mi-cmd-stack.c: Replace all instances of SYMBOL_NAME with
DEPRECATED_SYMBOL_NAME. Update copyright.
2003-02-25 22:36:23 +01:00
|
|
|
|
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
if (!msym)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var));
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Push the address of the variable. */
|
|
|
|
|
ax_const_l (ax, SYMBOL_VALUE_ADDRESS (msym));
|
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2003-02-28 21:03:18 +01:00
|
|
|
|
case LOC_COMPUTED:
|
2004-01-26 21:36:32 +01:00
|
|
|
|
/* FIXME: cagney/2004-01-26: It should be possible to
|
|
|
|
|
unconditionally call the SYMBOL_OPS method when available.
|
2004-02-06 19:30:47 +01:00
|
|
|
|
Unfortunately DWARF 2 stores the frame-base (instead of the
|
2004-01-26 21:36:32 +01:00
|
|
|
|
function) location in a function's symbol. Oops! For the
|
|
|
|
|
moment enable this when/where applicable. */
|
|
|
|
|
SYMBOL_OPS (var)->tracepoint_var_ref (var, ax, value);
|
2003-02-28 21:03:18 +01:00
|
|
|
|
break;
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case LOC_OPTIMIZED_OUT:
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("The variable `%s' has been optimized out."),
|
2003-02-20 David Carlton <carlton@math.stanford.edu>
* symtab.h (SYMBOL_PRINT_NAME): Rename from SYMBOL_SOURCE_NAME;
expand comment.
* ada-lang.c (user_select_syms, ada_finish_decode_line_1): Replace
SYMBOL_PRINT_NAME with SYMBOL_SOURCE_NAME.
* ada-typeprint.c (ada_typedef_print): Ditto.
* ax-gdb.c (gen_var_ref): Ditto.
* breakpoint.c (print_one_breakpoint): Ditto.
* buildsym.c (finish_block): Ditto.
* c-valprint.c (c_val_print): Ditto.
* expprint.c (print_subexp): Ditto.
* findvar.c (locate_var_value): Ditto.
* infcmd.c (jump_command): Ditto.
* linespec.c (decode_line_2, decode_compound): Ditto.
* maint.c (maintenance_translate_address): Ditto.
* objc-lang.c (compare_selectors, compare_classes): Ditto.
* printcmd.c (build_address_symbolic, sym_info, print_frame_args):
Ditto.
* p-valprint.c (pascal_val_print): Ditto.
* stabsread.c (define_symbol): Ditto.
* stack.c (print_frame, frame_info, print_block_frame_locals)
(print_frame_arg_vars, return_command): Ditto.
* symfile.c (compare_symbols, compare_psymbols): Ditto.
* symmisc.c (print_symbol): Ditto.
* symtab.c (lookup_partial_symbol, lookup_block_symbol)
(compare_search_syms, print_symbol_info, print_msymbol_info)
(rbreak_command): Ditto.
* tracepoint.c (tracepoints_info): Ditto.
* typeprint.c (typedef_print): Ditto.
* valops.c (value_of_variable, hand_function_call): Ditto.
* cli/cli-cmds.c (edit_command, list_command): Ditto.
* ada-typeprint.c: Update Copyright.
* infcmd.c, objc-lang.c, p-valprint.c, symmisc.c: Ditto.
* tracepoint.c, cli/cli-cmds.c: Ditto.
2003-02-20 18:17:25 +01:00
|
|
|
|
SYMBOL_PRINT_NAME (var));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Cannot find value of botched symbol `%s'."),
|
2003-02-20 David Carlton <carlton@math.stanford.edu>
* symtab.h (SYMBOL_PRINT_NAME): Rename from SYMBOL_SOURCE_NAME;
expand comment.
* ada-lang.c (user_select_syms, ada_finish_decode_line_1): Replace
SYMBOL_PRINT_NAME with SYMBOL_SOURCE_NAME.
* ada-typeprint.c (ada_typedef_print): Ditto.
* ax-gdb.c (gen_var_ref): Ditto.
* breakpoint.c (print_one_breakpoint): Ditto.
* buildsym.c (finish_block): Ditto.
* c-valprint.c (c_val_print): Ditto.
* expprint.c (print_subexp): Ditto.
* findvar.c (locate_var_value): Ditto.
* infcmd.c (jump_command): Ditto.
* linespec.c (decode_line_2, decode_compound): Ditto.
* maint.c (maintenance_translate_address): Ditto.
* objc-lang.c (compare_selectors, compare_classes): Ditto.
* printcmd.c (build_address_symbolic, sym_info, print_frame_args):
Ditto.
* p-valprint.c (pascal_val_print): Ditto.
* stabsread.c (define_symbol): Ditto.
* stack.c (print_frame, frame_info, print_block_frame_locals)
(print_frame_arg_vars, return_command): Ditto.
* symfile.c (compare_symbols, compare_psymbols): Ditto.
* symmisc.c (print_symbol): Ditto.
* symtab.c (lookup_partial_symbol, lookup_block_symbol)
(compare_search_syms, print_symbol_info, print_msymbol_info)
(rbreak_command): Ditto.
* tracepoint.c (tracepoints_info): Ditto.
* typeprint.c (typedef_print): Ditto.
* valops.c (value_of_variable, hand_function_call): Ditto.
* cli/cli-cmds.c (edit_command, list_command): Ditto.
* ada-typeprint.c: Update Copyright.
* infcmd.c, objc-lang.c, p-valprint.c, symmisc.c: Ditto.
* tracepoint.c, cli/cli-cmds.c: Ditto.
2003-02-20 18:17:25 +01:00
|
|
|
|
SYMBOL_PRINT_NAME (var));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generating bytecode from GDB expressions: literals */
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_int_literal (struct agent_expr *ax, struct axs_value *value, LONGEST k,
|
|
|
|
|
struct type *type)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
ax_const_l (ax, k);
|
|
|
|
|
value->kind = axs_rvalue;
|
2007-10-27 01:04:57 +02:00
|
|
|
|
value->type = check_typedef (type);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generating bytecode from GDB expressions: unary conversions, casts */
|
|
|
|
|
|
|
|
|
|
/* Take what's on the top of the stack (as described by VALUE), and
|
|
|
|
|
try to make an rvalue out of it. Signal an error if we can't do
|
|
|
|
|
that. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
require_rvalue (struct agent_expr *ax, struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
switch (value->kind)
|
|
|
|
|
{
|
|
|
|
|
case axs_rvalue:
|
|
|
|
|
/* It's already an rvalue. */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case axs_lvalue_memory:
|
|
|
|
|
/* The top of stack is the address of the object. Dereference. */
|
|
|
|
|
gen_fetch (ax, value->type);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case axs_lvalue_register:
|
|
|
|
|
/* There's nothing on the stack, but value->u.reg is the
|
|
|
|
|
register number containing the value.
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
When we add floating-point support, this is going to have to
|
|
|
|
|
change. What about SPARC register pairs, for example? */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
ax_reg (ax, value->u.reg);
|
|
|
|
|
gen_extend (ax, value->type);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Assume the top of the stack is described by VALUE, and perform the
|
|
|
|
|
usual unary conversions. This is motivated by ANSI 6.2.2, but of
|
|
|
|
|
course GDB expressions are not ANSI; they're the mishmash union of
|
|
|
|
|
a bunch of languages. Rah.
|
|
|
|
|
|
|
|
|
|
NOTE! This function promises to produce an rvalue only when the
|
|
|
|
|
incoming value is of an appropriate type. In other words, the
|
|
|
|
|
consumer of the value this function produces may assume the value
|
|
|
|
|
is an rvalue only after checking its type.
|
|
|
|
|
|
|
|
|
|
The immediate issue is that if the user tries to use a structure or
|
|
|
|
|
union as an operand of, say, the `+' operator, we don't want to try
|
|
|
|
|
to convert that structure to an rvalue; require_rvalue will bomb on
|
|
|
|
|
structs and unions. Rather, we want to simply pass the struct
|
|
|
|
|
lvalue through unchanged, and let `+' raise an error. */
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_usual_unary (struct agent_expr *ax, struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* We don't have to generate any code for the usual integral
|
|
|
|
|
conversions, since values are always represented as full-width on
|
|
|
|
|
the stack. Should we tweak the type? */
|
|
|
|
|
|
|
|
|
|
/* Some types require special handling. */
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
switch (TYPE_CODE (value->type))
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Functions get converted to a pointer to the function. */
|
|
|
|
|
case TYPE_CODE_FUNC:
|
|
|
|
|
value->type = lookup_pointer_type (value->type);
|
|
|
|
|
value->kind = axs_rvalue; /* Should always be true, but just in case. */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* Arrays get converted to a pointer to their first element, and
|
1999-07-07 22:19:36 +02:00
|
|
|
|
are no longer an lvalue. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case TYPE_CODE_ARRAY:
|
|
|
|
|
{
|
|
|
|
|
struct type *elements = TYPE_TARGET_TYPE (value->type);
|
|
|
|
|
value->type = lookup_pointer_type (elements);
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
/* We don't need to generate any code; the address of the array
|
|
|
|
|
is also the address of its first element. */
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
/* Don't try to convert structures and unions to rvalues. Let the
|
|
|
|
|
consumer signal an error. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case TYPE_CODE_STRUCT:
|
|
|
|
|
case TYPE_CODE_UNION:
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* If the value is an enum, call it an integer. */
|
|
|
|
|
case TYPE_CODE_ENUM:
|
|
|
|
|
value->type = builtin_type_int;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If the value is an lvalue, dereference it. */
|
|
|
|
|
require_rvalue (ax, value);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Return non-zero iff the type TYPE1 is considered "wider" than the
|
|
|
|
|
type TYPE2, according to the rules described in gen_usual_arithmetic. */
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
type_wider_than (struct type *type1, struct type *type2)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
return (TYPE_LENGTH (type1) > TYPE_LENGTH (type2)
|
|
|
|
|
|| (TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
|
|
|
|
|
&& TYPE_UNSIGNED (type1)
|
1999-07-07 22:19:36 +02:00
|
|
|
|
&& !TYPE_UNSIGNED (type2)));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Return the "wider" of the two types TYPE1 and TYPE2. */
|
|
|
|
|
static struct type *
|
2000-07-30 03:48:28 +02:00
|
|
|
|
max_type (struct type *type1, struct type *type2)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
return type_wider_than (type1, type2) ? type1 : type2;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code to convert a scalar value of type FROM to type TO. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_conversion (struct agent_expr *ax, struct type *from, struct type *to)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Perhaps there is a more graceful way to state these rules. */
|
|
|
|
|
|
|
|
|
|
/* If we're converting to a narrower type, then we need to clear out
|
|
|
|
|
the upper bits. */
|
|
|
|
|
if (TYPE_LENGTH (to) < TYPE_LENGTH (from))
|
|
|
|
|
gen_extend (ax, from);
|
|
|
|
|
|
|
|
|
|
/* If the two values have equal width, but different signednesses,
|
|
|
|
|
then we need to extend. */
|
|
|
|
|
else if (TYPE_LENGTH (to) == TYPE_LENGTH (from))
|
|
|
|
|
{
|
|
|
|
|
if (TYPE_UNSIGNED (from) != TYPE_UNSIGNED (to))
|
|
|
|
|
gen_extend (ax, to);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If we're converting to a wider type, and becoming unsigned, then
|
|
|
|
|
we need to zero out any possible sign bits. */
|
|
|
|
|
else if (TYPE_LENGTH (to) > TYPE_LENGTH (from))
|
|
|
|
|
{
|
|
|
|
|
if (TYPE_UNSIGNED (to))
|
|
|
|
|
gen_extend (ax, to);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Return non-zero iff the type FROM will require any bytecodes to be
|
|
|
|
|
emitted to be converted to the type TO. */
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
is_nontrivial_conversion (struct type *from, struct type *to)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
struct agent_expr *ax = new_agent_expr (0);
|
|
|
|
|
int nontrivial;
|
|
|
|
|
|
|
|
|
|
/* Actually generate the code, and see if anything came out. At the
|
|
|
|
|
moment, it would be trivial to replicate the code in
|
|
|
|
|
gen_conversion here, but in the future, when we're supporting
|
|
|
|
|
floating point and the like, it may not be. Doing things this
|
|
|
|
|
way allows this function to be independent of the logic in
|
|
|
|
|
gen_conversion. */
|
|
|
|
|
gen_conversion (ax, from, to);
|
|
|
|
|
nontrivial = ax->len > 0;
|
|
|
|
|
free_agent_expr (ax);
|
|
|
|
|
return nontrivial;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code to perform the "usual arithmetic conversions" (ANSI C
|
|
|
|
|
6.2.1.5) for the two operands of an arithmetic operator. This
|
|
|
|
|
effectively finds a "least upper bound" type for the two arguments,
|
|
|
|
|
and promotes each argument to that type. *VALUE1 and *VALUE2
|
|
|
|
|
describe the values as they are passed in, and as they are left. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1,
|
|
|
|
|
struct axs_value *value2)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Do the usual binary conversions. */
|
|
|
|
|
if (TYPE_CODE (value1->type) == TYPE_CODE_INT
|
|
|
|
|
&& TYPE_CODE (value2->type) == TYPE_CODE_INT)
|
|
|
|
|
{
|
|
|
|
|
/* The ANSI integral promotions seem to work this way: Order the
|
1999-07-07 22:19:36 +02:00
|
|
|
|
integer types by size, and then by signedness: an n-bit
|
|
|
|
|
unsigned type is considered "wider" than an n-bit signed
|
|
|
|
|
type. Promote to the "wider" of the two types, and always
|
|
|
|
|
promote at least to int. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
struct type *target = max_type (builtin_type_int,
|
|
|
|
|
max_type (value1->type, value2->type));
|
|
|
|
|
|
|
|
|
|
/* Deal with value2, on the top of the stack. */
|
|
|
|
|
gen_conversion (ax, value2->type, target);
|
|
|
|
|
|
|
|
|
|
/* Deal with value1, not on the top of the stack. Don't
|
|
|
|
|
generate the `swap' instructions if we're not actually going
|
|
|
|
|
to do anything. */
|
|
|
|
|
if (is_nontrivial_conversion (value1->type, target))
|
|
|
|
|
{
|
|
|
|
|
ax_simple (ax, aop_swap);
|
|
|
|
|
gen_conversion (ax, value1->type, target);
|
|
|
|
|
ax_simple (ax, aop_swap);
|
|
|
|
|
}
|
|
|
|
|
|
2007-10-27 01:04:57 +02:00
|
|
|
|
value1->type = value2->type = check_typedef (target);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code to perform the integral promotions (ANSI 6.2.1.1) on
|
|
|
|
|
the value on the top of the stack, as described by VALUE. Assume
|
|
|
|
|
the value has integral type. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_integral_promotions (struct agent_expr *ax, struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
1999-07-07 22:19:36 +02:00
|
|
|
|
if (!type_wider_than (value->type, builtin_type_int))
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
gen_conversion (ax, value->type, builtin_type_int);
|
|
|
|
|
value->type = builtin_type_int;
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
else if (!type_wider_than (value->type, builtin_type_unsigned_int))
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
gen_conversion (ax, value->type, builtin_type_unsigned_int);
|
|
|
|
|
value->type = builtin_type_unsigned_int;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code for a cast to TYPE. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* GCC does allow casts to yield lvalues, so this should be fixed
|
|
|
|
|
before merging these changes into the trunk. */
|
|
|
|
|
require_rvalue (ax, value);
|
|
|
|
|
/* Dereference typedefs. */
|
|
|
|
|
type = check_typedef (type);
|
|
|
|
|
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
switch (TYPE_CODE (type))
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
case TYPE_CODE_PTR:
|
|
|
|
|
/* It's implementation-defined, and I'll bet this is what GCC
|
|
|
|
|
does. */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TYPE_CODE_ARRAY:
|
|
|
|
|
case TYPE_CODE_STRUCT:
|
|
|
|
|
case TYPE_CODE_UNION:
|
|
|
|
|
case TYPE_CODE_FUNC:
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Invalid type cast: intended type must be scalar."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
case TYPE_CODE_ENUM:
|
|
|
|
|
/* We don't have to worry about the size of the value, because
|
|
|
|
|
all our integral values are fully sign-extended, and when
|
|
|
|
|
casting pointers we can do anything we like. Is there any
|
2007-10-27 01:07:26 +02:00
|
|
|
|
way for us to know what GCC actually does with a cast like
|
|
|
|
|
this? */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case TYPE_CODE_INT:
|
|
|
|
|
gen_conversion (ax, value->type, type);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TYPE_CODE_VOID:
|
|
|
|
|
/* We could pop the value, and rely on everyone else to check
|
1999-07-07 22:19:36 +02:00
|
|
|
|
the type and notice that this value doesn't occupy a stack
|
|
|
|
|
slot. But for now, leave the value on the stack, and
|
|
|
|
|
preserve the "value == stack element" assumption. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Casts to requested type are not yet implemented."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
value->type = type;
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generating bytecode from GDB expressions: arithmetic */
|
|
|
|
|
|
|
|
|
|
/* Scale the integer on the top of the stack by the size of the target
|
|
|
|
|
of the pointer type TYPE. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_scale (struct agent_expr *ax, enum agent_op op, struct type *type)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
struct type *element = TYPE_TARGET_TYPE (type);
|
|
|
|
|
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
if (TYPE_LENGTH (element) != 1)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
ax_const_l (ax, TYPE_LENGTH (element));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
ax_simple (ax, op);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code for an addition; non-trivial because we deal with
|
|
|
|
|
pointer arithmetic. We set VALUE to describe the result value; we
|
|
|
|
|
assume VALUE1 and VALUE2 describe the two operands, and that
|
|
|
|
|
they've undergone the usual binary conversions. Used by both
|
|
|
|
|
BINOP_ADD and BINOP_SUBSCRIPT. NAME is used in error messages. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_add (struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct axs_value *value1, struct axs_value *value2, char *name)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Is it INT+PTR? */
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
if (TYPE_CODE (value1->type) == TYPE_CODE_INT
|
|
|
|
|
&& TYPE_CODE (value2->type) == TYPE_CODE_PTR)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Swap the values and proceed normally. */
|
|
|
|
|
ax_simple (ax, aop_swap);
|
|
|
|
|
gen_scale (ax, aop_mul, value2->type);
|
|
|
|
|
ax_simple (ax, aop_add);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
gen_extend (ax, value2->type); /* Catch overflow. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->type = value2->type;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Is it PTR+INT? */
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
else if (TYPE_CODE (value1->type) == TYPE_CODE_PTR
|
|
|
|
|
&& TYPE_CODE (value2->type) == TYPE_CODE_INT)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
gen_scale (ax, aop_mul, value1->type);
|
|
|
|
|
ax_simple (ax, aop_add);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
gen_extend (ax, value1->type); /* Catch overflow. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->type = value1->type;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Must be number + number; the usual binary conversions will have
|
|
|
|
|
brought them both to the same width. */
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
else if (TYPE_CODE (value1->type) == TYPE_CODE_INT
|
|
|
|
|
&& TYPE_CODE (value2->type) == TYPE_CODE_INT)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
ax_simple (ax, aop_add);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
gen_extend (ax, value1->type); /* Catch overflow. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->type = value1->type;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
else
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Invalid combination of types in %s."), name);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code for an addition; non-trivial because we have to deal
|
|
|
|
|
with pointer arithmetic. We set VALUE to describe the result
|
|
|
|
|
value; we assume VALUE1 and VALUE2 describe the two operands, and
|
|
|
|
|
that they've undergone the usual binary conversions. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_sub (struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct axs_value *value1, struct axs_value *value2)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
if (TYPE_CODE (value1->type) == TYPE_CODE_PTR)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Is it PTR - INT? */
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
if (TYPE_CODE (value2->type) == TYPE_CODE_INT)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
gen_scale (ax, aop_mul, value1->type);
|
|
|
|
|
ax_simple (ax, aop_sub);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
gen_extend (ax, value1->type); /* Catch overflow. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->type = value1->type;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Is it PTR - PTR? Strictly speaking, the types ought to
|
1999-07-07 22:19:36 +02:00
|
|
|
|
match, but this is what the normal GDB expression evaluator
|
|
|
|
|
tests for. */
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
else if (TYPE_CODE (value2->type) == TYPE_CODE_PTR
|
1999-04-16 03:35:26 +02:00
|
|
|
|
&& (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type))
|
|
|
|
|
== TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type))))
|
|
|
|
|
{
|
|
|
|
|
ax_simple (ax, aop_sub);
|
|
|
|
|
gen_scale (ax, aop_div_unsigned, value1->type);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
value->type = builtin_type_long; /* FIXME --- should be ptrdiff_t */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("\
|
1999-04-16 03:35:26 +02:00
|
|
|
|
First argument of `-' is a pointer, but second argument is neither\n\
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
an integer nor a pointer of the same type."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Must be number + number. */
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
else if (TYPE_CODE (value1->type) == TYPE_CODE_INT
|
|
|
|
|
&& TYPE_CODE (value2->type) == TYPE_CODE_INT)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
ax_simple (ax, aop_sub);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
gen_extend (ax, value1->type); /* Catch overflow. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->type = value1->type;
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
else
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Invalid combination of types in subtraction."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Generate code for a binary operator that doesn't do pointer magic.
|
|
|
|
|
We set VALUE to describe the result value; we assume VALUE1 and
|
|
|
|
|
VALUE2 describe the two operands, and that they've undergone the
|
|
|
|
|
usual binary conversions. MAY_CARRY should be non-zero iff the
|
|
|
|
|
result needs to be extended. NAME is the English name of the
|
|
|
|
|
operator, used in error messages */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_binop (struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct axs_value *value1, struct axs_value *value2, enum agent_op op,
|
|
|
|
|
enum agent_op op_unsigned, int may_carry, char *name)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* We only handle INT op INT. */
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
if ((TYPE_CODE (value1->type) != TYPE_CODE_INT)
|
|
|
|
|
|| (TYPE_CODE (value2->type) != TYPE_CODE_INT))
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Invalid combination of types in %s."), name);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
ax_simple (ax,
|
|
|
|
|
TYPE_UNSIGNED (value1->type) ? op_unsigned : op);
|
|
|
|
|
if (may_carry)
|
1999-07-07 22:19:36 +02:00
|
|
|
|
gen_extend (ax, value1->type); /* catch overflow */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->type = value1->type;
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_logical_not (struct agent_expr *ax, struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
if (TYPE_CODE (value->type) != TYPE_CODE_INT
|
|
|
|
|
&& TYPE_CODE (value->type) != TYPE_CODE_PTR)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Invalid type of operand to `!'."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
gen_usual_unary (ax, value);
|
|
|
|
|
ax_simple (ax, aop_log_not);
|
|
|
|
|
value->type = builtin_type_int;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_complement (struct agent_expr *ax, struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
if (TYPE_CODE (value->type) != TYPE_CODE_INT)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Invalid type of operand to `~'."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
gen_usual_unary (ax, value);
|
|
|
|
|
gen_integral_promotions (ax, value);
|
|
|
|
|
ax_simple (ax, aop_bit_not);
|
|
|
|
|
gen_extend (ax, value->type);
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generating bytecode from GDB expressions: * & . -> @ sizeof */
|
|
|
|
|
|
|
|
|
|
/* Dereference the value on the top of the stack. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_deref (struct agent_expr *ax, struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* The caller should check the type, because several operators use
|
|
|
|
|
this, and we don't know what error message to generate. */
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
if (TYPE_CODE (value->type) != TYPE_CODE_PTR)
|
2001-02-08 07:03:54 +01:00
|
|
|
|
internal_error (__FILE__, __LINE__,
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
_("gen_deref: expected a pointer"));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* We've got an rvalue now, which is a pointer. We want to yield an
|
|
|
|
|
lvalue, whose address is exactly that pointer. So we don't
|
|
|
|
|
actually emit any code; we just change the type from "Pointer to
|
|
|
|
|
T" to "T", and mark the value as an lvalue in memory. Leave it
|
|
|
|
|
to the consumer to actually dereference it. */
|
|
|
|
|
value->type = check_typedef (TYPE_TARGET_TYPE (value->type));
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
value->kind = ((TYPE_CODE (value->type) == TYPE_CODE_FUNC)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
? axs_rvalue : axs_lvalue_memory);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Produce the address of the lvalue on the top of the stack. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_address_of (struct agent_expr *ax, struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Special case for taking the address of a function. The ANSI
|
|
|
|
|
standard describes this as a special case, too, so this
|
|
|
|
|
arrangement is not without motivation. */
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
if (TYPE_CODE (value->type) == TYPE_CODE_FUNC)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* The value's already an rvalue on the stack, so we just need to
|
|
|
|
|
change the type. */
|
|
|
|
|
value->type = lookup_pointer_type (value->type);
|
|
|
|
|
else
|
|
|
|
|
switch (value->kind)
|
|
|
|
|
{
|
|
|
|
|
case axs_rvalue:
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Operand of `&' is an rvalue, which has no address."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
case axs_lvalue_register:
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Operand of `&' is in a register, and has no address."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
case axs_lvalue_memory:
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
value->type = lookup_pointer_type (value->type);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* A lot of this stuff will have to change to support C++. But we're
|
|
|
|
|
not going to deal with that at the moment. */
|
|
|
|
|
|
|
|
|
|
/* Find the field in the structure type TYPE named NAME, and return
|
|
|
|
|
its index in TYPE's field array. */
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
find_field (struct type *type, char *name)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
CHECK_TYPEDEF (type);
|
|
|
|
|
|
|
|
|
|
/* Make sure this isn't C++. */
|
|
|
|
|
if (TYPE_N_BASECLASSES (type) != 0)
|
2001-02-08 07:03:54 +01:00
|
|
|
|
internal_error (__FILE__, __LINE__,
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
_("find_field: derived classes supported"));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
for (i = 0; i < TYPE_NFIELDS (type); i++)
|
|
|
|
|
{
|
|
|
|
|
char *this_name = TYPE_FIELD_NAME (type, i);
|
|
|
|
|
|
2007-07-25 00:49:44 +02:00
|
|
|
|
if (this_name)
|
|
|
|
|
{
|
|
|
|
|
if (strcmp (name, this_name) == 0)
|
|
|
|
|
return i;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2007-07-25 00:49:44 +02:00
|
|
|
|
if (this_name[0] == '\0')
|
|
|
|
|
internal_error (__FILE__, __LINE__,
|
|
|
|
|
_("find_field: anonymous unions not supported"));
|
|
|
|
|
}
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Couldn't find member named `%s' in struct/union `%s'"),
|
2002-02-04 00:11:33 +01:00
|
|
|
|
name, TYPE_TAG_NAME (type));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code to push the value of a bitfield of a structure whose
|
|
|
|
|
address is on the top of the stack. START and END give the
|
|
|
|
|
starting and one-past-ending *bit* numbers of the field within the
|
|
|
|
|
structure. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct type *type, int start, int end)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Note that ops[i] fetches 8 << i bits. */
|
|
|
|
|
static enum agent_op ops[]
|
1999-07-07 22:19:36 +02:00
|
|
|
|
=
|
|
|
|
|
{aop_ref8, aop_ref16, aop_ref32, aop_ref64};
|
1999-04-16 03:35:26 +02:00
|
|
|
|
static int num_ops = (sizeof (ops) / sizeof (ops[0]));
|
|
|
|
|
|
|
|
|
|
/* We don't want to touch any byte that the bitfield doesn't
|
|
|
|
|
actually occupy; we shouldn't make any accesses we're not
|
|
|
|
|
explicitly permitted to. We rely here on the fact that the
|
|
|
|
|
bytecode `ref' operators work on unaligned addresses.
|
|
|
|
|
|
|
|
|
|
It takes some fancy footwork to get the stack to work the way
|
|
|
|
|
we'd like. Say we're retrieving a bitfield that requires three
|
|
|
|
|
fetches. Initially, the stack just contains the address:
|
1999-07-07 22:19:36 +02:00
|
|
|
|
addr
|
1999-04-16 03:35:26 +02:00
|
|
|
|
For the first fetch, we duplicate the address
|
1999-07-07 22:19:36 +02:00
|
|
|
|
addr addr
|
1999-04-16 03:35:26 +02:00
|
|
|
|
then add the byte offset, do the fetch, and shift and mask as
|
|
|
|
|
needed, yielding a fragment of the value, properly aligned for
|
|
|
|
|
the final bitwise or:
|
1999-07-07 22:19:36 +02:00
|
|
|
|
addr frag1
|
1999-04-16 03:35:26 +02:00
|
|
|
|
then we swap, and repeat the process:
|
1999-07-07 22:19:36 +02:00
|
|
|
|
frag1 addr --- address on top
|
|
|
|
|
frag1 addr addr --- duplicate it
|
|
|
|
|
frag1 addr frag2 --- get second fragment
|
|
|
|
|
frag1 frag2 addr --- swap again
|
|
|
|
|
frag1 frag2 frag3 --- get third fragment
|
1999-04-16 03:35:26 +02:00
|
|
|
|
Notice that, since the third fragment is the last one, we don't
|
|
|
|
|
bother duplicating the address this time. Now we have all the
|
|
|
|
|
fragments on the stack, and we can simply `or' them together,
|
|
|
|
|
yielding the final value of the bitfield. */
|
|
|
|
|
|
|
|
|
|
/* The first and one-after-last bits in the field, but rounded down
|
|
|
|
|
and up to byte boundaries. */
|
|
|
|
|
int bound_start = (start / TARGET_CHAR_BIT) * TARGET_CHAR_BIT;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
int bound_end = (((end + TARGET_CHAR_BIT - 1)
|
|
|
|
|
/ TARGET_CHAR_BIT)
|
|
|
|
|
* TARGET_CHAR_BIT);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* current bit offset within the structure */
|
|
|
|
|
int offset;
|
|
|
|
|
|
|
|
|
|
/* The index in ops of the opcode we're considering. */
|
|
|
|
|
int op;
|
|
|
|
|
|
|
|
|
|
/* The number of fragments we generated in the process. Probably
|
|
|
|
|
equal to the number of `one' bits in bytesize, but who cares? */
|
|
|
|
|
int fragment_count;
|
|
|
|
|
|
|
|
|
|
/* Dereference any typedefs. */
|
|
|
|
|
type = check_typedef (type);
|
|
|
|
|
|
|
|
|
|
/* Can we fetch the number of bits requested at all? */
|
|
|
|
|
if ((end - start) > ((1 << num_ops) * 8))
|
2001-02-08 07:03:54 +01:00
|
|
|
|
internal_error (__FILE__, __LINE__,
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
_("gen_bitfield_ref: bitfield too wide"));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Note that we know here that we only need to try each opcode once.
|
|
|
|
|
That may not be true on machines with weird byte sizes. */
|
|
|
|
|
offset = bound_start;
|
|
|
|
|
fragment_count = 0;
|
|
|
|
|
for (op = num_ops - 1; op >= 0; op--)
|
|
|
|
|
{
|
|
|
|
|
/* number of bits that ops[op] would fetch */
|
|
|
|
|
int op_size = 8 << op;
|
|
|
|
|
|
|
|
|
|
/* The stack at this point, from bottom to top, contains zero or
|
1999-07-07 22:19:36 +02:00
|
|
|
|
more fragments, then the address. */
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Does this fetch fit within the bitfield? */
|
|
|
|
|
if (offset + op_size <= bound_end)
|
|
|
|
|
{
|
|
|
|
|
/* Is this the last fragment? */
|
|
|
|
|
int last_frag = (offset + op_size == bound_end);
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
if (!last_frag)
|
|
|
|
|
ax_simple (ax, aop_dup); /* keep a copy of the address */
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Add the offset. */
|
|
|
|
|
gen_offset (ax, offset / TARGET_CHAR_BIT);
|
|
|
|
|
|
|
|
|
|
if (trace_kludge)
|
|
|
|
|
{
|
|
|
|
|
/* Record the area of memory we're about to fetch. */
|
|
|
|
|
ax_trace_quick (ax, op_size / TARGET_CHAR_BIT);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Perform the fetch. */
|
|
|
|
|
ax_simple (ax, ops[op]);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
|
|
|
|
/* Shift the bits we have to their proper position.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_left_shift will generate right shifts when the operand
|
|
|
|
|
is negative.
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
A big-endian field diagram to ponder:
|
|
|
|
|
byte 0 byte 1 byte 2 byte 3 byte 4 byte 5 byte 6 byte 7
|
|
|
|
|
+------++------++------++------++------++------++------++------+
|
|
|
|
|
xxxxAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCxxxxxxxxxxx
|
|
|
|
|
^ ^ ^ ^
|
|
|
|
|
bit number 16 32 48 53
|
1999-04-16 03:35:26 +02:00
|
|
|
|
These are bit numbers as supplied by GDB. Note that the
|
|
|
|
|
bit numbers run from right to left once you've fetched the
|
|
|
|
|
value!
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
A little-endian field diagram to ponder:
|
|
|
|
|
byte 7 byte 6 byte 5 byte 4 byte 3 byte 2 byte 1 byte 0
|
|
|
|
|
+------++------++------++------++------++------++------++------+
|
|
|
|
|
xxxxxxxxxxxAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCxxxx
|
|
|
|
|
^ ^ ^ ^ ^
|
|
|
|
|
bit number 48 32 16 4 0
|
|
|
|
|
|
|
|
|
|
In both cases, the most significant end is on the left
|
|
|
|
|
(i.e. normal numeric writing order), which means that you
|
|
|
|
|
don't go crazy thinking about `left' and `right' shifts.
|
|
|
|
|
|
|
|
|
|
We don't have to worry about masking yet:
|
|
|
|
|
- If they contain garbage off the least significant end, then we
|
|
|
|
|
must be looking at the low end of the field, and the right
|
|
|
|
|
shift will wipe them out.
|
|
|
|
|
- If they contain garbage off the most significant end, then we
|
|
|
|
|
must be looking at the most significant end of the word, and
|
|
|
|
|
the sign/zero extension will wipe them out.
|
|
|
|
|
- If we're in the interior of the word, then there is no garbage
|
|
|
|
|
on either end, because the ref operators zero-extend. */
|
2007-05-31 Markus Deuling <deuling@de.ibm.com>
* gdbarch.sh (TARGET_BYTE_ORDER): Replace by gdbarch_byte_order.
* ax-gdb.c (gen_bitfield_ref): Likewise.
* mi/mi-main.c (get_register): Likewise.
* findvar.c (default_value_from_register, extract_signed_integer)
(extract_unsigned_integer, extract_long_unsigned_integer)
(store_signed_integer, store_unsigned_integer): Likewise.
* regcache.c (regcache_dump): Likewise.
* value.c (lookup_internalvar, value_of_internalvar)
(set_internalvar): Likewise.
* defs.h: Likewise.
* valprint.c (print_binary_chars, print_octal_chars)
(print_decimal_chars, print_hex_chars, print_char_chars): Likewise.
* infcmd.c (default_print_registers_info): Likewise.
* arch-utils.c (selected_byte_order, show_endian): Likewise.
* stabsread.c (define_symbol): Likewise.
* doublest.c (floatformat_from_length, floatformat_from_type)
(extract_typed_floating, store_typed_floating): Likewise.
* gdbarch.c, gdbarch.h: Regenerate.
2007-05-31 19:00:07 +02:00
|
|
|
|
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_left_shift (ax, end - (offset + op_size));
|
1999-07-07 22:19:36 +02:00
|
|
|
|
else
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_left_shift (ax, offset - start);
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
if (!last_frag)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Bring the copy of the address up to the top. */
|
|
|
|
|
ax_simple (ax, aop_swap);
|
|
|
|
|
|
|
|
|
|
offset += op_size;
|
|
|
|
|
fragment_count++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Generate enough bitwise `or' operations to combine all the
|
|
|
|
|
fragments we left on the stack. */
|
|
|
|
|
while (fragment_count-- > 1)
|
|
|
|
|
ax_simple (ax, aop_bit_or);
|
|
|
|
|
|
|
|
|
|
/* Sign- or zero-extend the value as appropriate. */
|
|
|
|
|
((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, end - start));
|
|
|
|
|
|
|
|
|
|
/* This is *not* an lvalue. Ugh. */
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
value->type = type;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code to reference the member named FIELD of a structure or
|
|
|
|
|
union. The top of the stack, as described by VALUE, should have
|
|
|
|
|
type (pointer to a)* struct/union. OPERATOR_NAME is the name of
|
|
|
|
|
the operator being compiled, and OPERAND_NAME is the kind of thing
|
|
|
|
|
it operates on; we use them in error messages. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_struct_ref (struct agent_expr *ax, struct axs_value *value, char *field,
|
|
|
|
|
char *operator_name, char *operand_name)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
struct type *type;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
/* Follow pointers until we reach a non-pointer. These aren't the C
|
|
|
|
|
semantics, but they're what the normal GDB evaluator does, so we
|
|
|
|
|
should at least be consistent. */
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
while (TYPE_CODE (value->type) == TYPE_CODE_PTR)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
gen_usual_unary (ax, value);
|
|
|
|
|
gen_deref (ax, value);
|
|
|
|
|
}
|
2000-10-30 22:15:56 +01:00
|
|
|
|
type = check_typedef (value->type);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* This must yield a structure or a union. */
|
|
|
|
|
if (TYPE_CODE (type) != TYPE_CODE_STRUCT
|
|
|
|
|
&& TYPE_CODE (type) != TYPE_CODE_UNION)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("The left operand of `%s' is not a %s."),
|
1999-04-16 03:35:26 +02:00
|
|
|
|
operator_name, operand_name);
|
|
|
|
|
|
|
|
|
|
/* And it must be in memory; we don't deal with structure rvalues,
|
|
|
|
|
or structures living in registers. */
|
|
|
|
|
if (value->kind != axs_lvalue_memory)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Structure does not live in memory."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
i = find_field (type, field);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Is this a bitfield? */
|
|
|
|
|
if (TYPE_FIELD_PACKED (type, i))
|
|
|
|
|
gen_bitfield_ref (ax, value, TYPE_FIELD_TYPE (type, i),
|
|
|
|
|
TYPE_FIELD_BITPOS (type, i),
|
|
|
|
|
(TYPE_FIELD_BITPOS (type, i)
|
|
|
|
|
+ TYPE_FIELD_BITSIZE (type, i)));
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
gen_offset (ax, TYPE_FIELD_BITPOS (type, i) / TARGET_CHAR_BIT);
|
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
value->type = TYPE_FIELD_TYPE (type, i);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code for GDB's magical `repeat' operator.
|
|
|
|
|
LVALUE @ INT creates an array INT elements long, and whose elements
|
|
|
|
|
have the same type as LVALUE, located in memory so that LVALUE is
|
|
|
|
|
its first element. For example, argv[0]@argc gives you the array
|
|
|
|
|
of command-line arguments.
|
|
|
|
|
|
|
|
|
|
Unfortunately, because we have to know the types before we actually
|
|
|
|
|
have a value for the expression, we can't implement this perfectly
|
|
|
|
|
without changing the type system, having values that occupy two
|
|
|
|
|
stack slots, doing weird things with sizeof, etc. So we require
|
|
|
|
|
the right operand to be a constant expression. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_repeat (union exp_element **pc, struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
struct axs_value value1;
|
|
|
|
|
/* We don't want to turn this into an rvalue, so no conversions
|
|
|
|
|
here. */
|
|
|
|
|
gen_expr (pc, ax, &value1);
|
|
|
|
|
if (value1.kind != axs_lvalue_memory)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Left operand of `@' must be an object in memory."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Evaluate the length; it had better be a constant. */
|
|
|
|
|
{
|
|
|
|
|
struct value *v = const_expr (pc);
|
|
|
|
|
int length;
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
if (!v)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Right operand of `@' must be a constant, in agent expressions."));
|
2005-02-07 Andrew Cagney <cagney@gnu.org>
* value.h (deprecated_set_value_type): Declare.
* value.c (deprecated_set_value_type): Define.
* hpacc-abi.c, gnu-v2-abi.c, cp-valprint.c: Update.
* c-valprint.c, jv-lang.c, objc-lang.c, ada-lang.c: Update.
* infcall.c, printcmd.c, valops.c, eval.c, p-exp.y: Update.
* ax-gdb.c, tracepoint.c: Update.
2005-02-08 00:51:03 +01:00
|
|
|
|
if (TYPE_CODE (value_type (v)) != TYPE_CODE_INT)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Right operand of `@' must be an integer."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
length = value_as_long (v);
|
|
|
|
|
if (length <= 0)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Right operand of `@' must be positive."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* The top of the stack is already the address of the object, so
|
|
|
|
|
all we need to do is frob the type of the lvalue. */
|
|
|
|
|
{
|
|
|
|
|
/* FIXME-type-allocation: need a way to free this type when we are
|
1999-07-07 22:19:36 +02:00
|
|
|
|
done with it. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
struct type *range
|
1999-07-07 22:19:36 +02:00
|
|
|
|
= create_range_type (0, builtin_type_int, 0, length - 1);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
struct type *array = create_array_type (0, value1.type, range);
|
|
|
|
|
|
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
value->type = array;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Emit code for the `sizeof' operator.
|
|
|
|
|
*PC should point at the start of the operand expression; we advance it
|
|
|
|
|
to the first instruction after the operand. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_sizeof (union exp_element **pc, struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* We don't care about the value of the operand expression; we only
|
|
|
|
|
care about its type. However, in the current arrangement, the
|
|
|
|
|
only way to find an expression's type is to generate code for it.
|
|
|
|
|
So we generate code for the operand, and then throw it away,
|
|
|
|
|
replacing it with code that simply pushes its size. */
|
|
|
|
|
int start = ax->len;
|
|
|
|
|
gen_expr (pc, ax, value);
|
|
|
|
|
|
|
|
|
|
/* Throw away the code we just generated. */
|
|
|
|
|
ax->len = start;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
ax_const_l (ax, TYPE_LENGTH (value->type));
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
value->type = builtin_type_int;
|
|
|
|
|
}
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Generating bytecode from GDB expressions: general recursive thingy */
|
|
|
|
|
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
/* XXX: i18n */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* A gen_expr function written by a Gen-X'er guy.
|
|
|
|
|
Append code for the subexpression of EXPR starting at *POS_P to AX. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_expr (union exp_element **pc, struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Used to hold the descriptions of operand expressions. */
|
|
|
|
|
struct axs_value value1, value2;
|
|
|
|
|
enum exp_opcode op = (*pc)[0].opcode;
|
|
|
|
|
|
|
|
|
|
/* If we're looking at a constant expression, just push its value. */
|
|
|
|
|
{
|
|
|
|
|
struct value *v = maybe_const_expr (pc);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
if (v)
|
|
|
|
|
{
|
|
|
|
|
ax_const_l (ax, value_as_long (v));
|
|
|
|
|
value->kind = axs_rvalue;
|
2004-11-12 Andrew Cagney <cagney@gnu.org>
* value.h (VALUE_TYPE, VALUE_NEXT, VALUE_OFFSET, VALUE_BITSIZE)
(VALUE_BITPOS): Delete.
(value_type, value_offset, value_bitsize, value_bitpos): Declare.
* value.c (value_type, value_offset, value_bitpos)
(value_bitsize): New functions. Update references.
* arm-tdep.c, gnu-v3-abi.c, hpacc-abi.c, gnu-v2-abi.c: Update.
* f-valprint.c, cp-valprint.c, c-valprint.c: Update.
* ada-valprint.c, typeprint.c, scm-valprint.c, scm-exp.c: Update.
* p-valprint.c, jv-valprint.c, jv-lang.c, varobj.c: Update.
* objc-lang.c, ada-lang.c, std-regs.c, stack.c: Update.
* infcall.c, linespec.c, printcmd.c, valarith.c: Update.
* valops.c, eval.c, findvar.c, breakpoint.c: Update.
* tracepoint.c, ax-gdb.c, mi/mi-main.c, cli/cli-dump.c:
* rs6000-tdep.c, ppc-sysv-tdep.c: Update.
2004-11-12 22:45:08 +01:00
|
|
|
|
value->type = check_typedef (value_type (v));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Otherwise, go ahead and generate code for it. */
|
|
|
|
|
switch (op)
|
|
|
|
|
{
|
|
|
|
|
/* Binary arithmetic operators. */
|
|
|
|
|
case BINOP_ADD:
|
|
|
|
|
case BINOP_SUB:
|
|
|
|
|
case BINOP_MUL:
|
|
|
|
|
case BINOP_DIV:
|
|
|
|
|
case BINOP_REM:
|
|
|
|
|
case BINOP_SUBSCRIPT:
|
|
|
|
|
case BINOP_BITWISE_AND:
|
|
|
|
|
case BINOP_BITWISE_IOR:
|
|
|
|
|
case BINOP_BITWISE_XOR:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
gen_expr (pc, ax, &value1);
|
|
|
|
|
gen_usual_unary (ax, &value1);
|
|
|
|
|
gen_expr (pc, ax, &value2);
|
|
|
|
|
gen_usual_unary (ax, &value2);
|
|
|
|
|
gen_usual_arithmetic (ax, &value1, &value2);
|
|
|
|
|
switch (op)
|
|
|
|
|
{
|
|
|
|
|
case BINOP_ADD:
|
|
|
|
|
gen_add (ax, value, &value1, &value2, "addition");
|
|
|
|
|
break;
|
|
|
|
|
case BINOP_SUB:
|
|
|
|
|
gen_sub (ax, value, &value1, &value2);
|
|
|
|
|
break;
|
|
|
|
|
case BINOP_MUL:
|
|
|
|
|
gen_binop (ax, value, &value1, &value2,
|
|
|
|
|
aop_mul, aop_mul, 1, "multiplication");
|
|
|
|
|
break;
|
|
|
|
|
case BINOP_DIV:
|
|
|
|
|
gen_binop (ax, value, &value1, &value2,
|
|
|
|
|
aop_div_signed, aop_div_unsigned, 1, "division");
|
|
|
|
|
break;
|
|
|
|
|
case BINOP_REM:
|
|
|
|
|
gen_binop (ax, value, &value1, &value2,
|
|
|
|
|
aop_rem_signed, aop_rem_unsigned, 1, "remainder");
|
|
|
|
|
break;
|
|
|
|
|
case BINOP_SUBSCRIPT:
|
|
|
|
|
gen_add (ax, value, &value1, &value2, "array subscripting");
|
|
|
|
|
if (TYPE_CODE (value->type) != TYPE_CODE_PTR)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Invalid combination of types in array subscripting."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_deref (ax, value);
|
|
|
|
|
break;
|
|
|
|
|
case BINOP_BITWISE_AND:
|
|
|
|
|
gen_binop (ax, value, &value1, &value2,
|
|
|
|
|
aop_bit_and, aop_bit_and, 0, "bitwise and");
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BINOP_BITWISE_IOR:
|
|
|
|
|
gen_binop (ax, value, &value1, &value2,
|
|
|
|
|
aop_bit_or, aop_bit_or, 0, "bitwise or");
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BINOP_BITWISE_XOR:
|
|
|
|
|
gen_binop (ax, value, &value1, &value2,
|
|
|
|
|
aop_bit_xor, aop_bit_xor, 0, "bitwise exclusive-or");
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
/* We should only list operators in the outer case statement
|
1999-07-07 22:19:36 +02:00
|
|
|
|
that we actually handle in the inner case statement. */
|
2001-02-08 07:03:54 +01:00
|
|
|
|
internal_error (__FILE__, __LINE__,
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
_("gen_expr: op case sets don't match"));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* Note that we need to be a little subtle about generating code
|
1999-07-07 22:19:36 +02:00
|
|
|
|
for comma. In C, we can do some optimizations here because
|
|
|
|
|
we know the left operand is only being evaluated for effect.
|
|
|
|
|
However, if the tracing kludge is in effect, then we always
|
|
|
|
|
need to evaluate the left hand side fully, so that all the
|
|
|
|
|
variables it mentions get traced. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case BINOP_COMMA:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
gen_expr (pc, ax, &value1);
|
|
|
|
|
/* Don't just dispose of the left operand. We might be tracing,
|
1999-07-07 22:19:36 +02:00
|
|
|
|
in which case we want to emit code to trace it if it's an
|
|
|
|
|
lvalue. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_traced_pop (ax, &value1);
|
|
|
|
|
gen_expr (pc, ax, value);
|
|
|
|
|
/* It's the consumer's responsibility to trace the right operand. */
|
|
|
|
|
break;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case OP_LONG: /* some integer constant */
|
|
|
|
|
{
|
|
|
|
|
struct type *type = (*pc)[1].type;
|
|
|
|
|
LONGEST k = (*pc)[2].longconst;
|
|
|
|
|
(*pc) += 4;
|
|
|
|
|
gen_int_literal (ax, value, k, type);
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
case OP_VAR_VALUE:
|
|
|
|
|
gen_var_ref (ax, value, (*pc)[2].symbol);
|
|
|
|
|
(*pc) += 4;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case OP_REGISTER:
|
|
|
|
|
{
|
2007-06-13 19:11:09 +02:00
|
|
|
|
const char *name = &(*pc)[2].string;
|
|
|
|
|
int reg;
|
|
|
|
|
(*pc) += 4 + BYTES_TO_EXP_ELEM ((*pc)[1].longconst + 1);
|
|
|
|
|
reg = frame_map_name_to_regnum (deprecated_safe_get_selected_frame (),
|
|
|
|
|
name, strlen (name));
|
|
|
|
|
if (reg == -1)
|
|
|
|
|
internal_error (__FILE__, __LINE__,
|
|
|
|
|
_("Register $%s not available"), name);
|
2008-02-05 16:54:34 +01:00
|
|
|
|
if (reg >= gdbarch_num_regs (current_gdbarch))
|
|
|
|
|
error (_("'%s' is a pseudo-register; "
|
|
|
|
|
"GDB cannot yet trace pseudoregister contents."),
|
|
|
|
|
name);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->kind = axs_lvalue_register;
|
|
|
|
|
value->u.reg = reg;
|
2003-03-01 18:03:19 +01:00
|
|
|
|
value->type = register_type (current_gdbarch, reg);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
case OP_INTERNALVAR:
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("GDB agent expressions cannot use convenience variables."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
/* Weirdo operator: see comments for gen_repeat for details. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case BINOP_REPEAT:
|
|
|
|
|
/* Note that gen_repeat handles its own argument evaluation. */
|
|
|
|
|
(*pc)++;
|
|
|
|
|
gen_repeat (pc, ax, value);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case UNOP_CAST:
|
|
|
|
|
{
|
|
|
|
|
struct type *type = (*pc)[1].type;
|
|
|
|
|
(*pc) += 3;
|
|
|
|
|
gen_expr (pc, ax, value);
|
|
|
|
|
gen_cast (ax, value, type);
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
case UNOP_MEMVAL:
|
|
|
|
|
{
|
|
|
|
|
struct type *type = check_typedef ((*pc)[1].type);
|
|
|
|
|
(*pc) += 3;
|
|
|
|
|
gen_expr (pc, ax, value);
|
|
|
|
|
/* I'm not sure I understand UNOP_MEMVAL entirely. I think
|
|
|
|
|
it's just a hack for dealing with minsyms; you take some
|
|
|
|
|
integer constant, pretend it's the address of an lvalue of
|
|
|
|
|
the given type, and dereference it. */
|
|
|
|
|
if (value->kind != axs_rvalue)
|
|
|
|
|
/* This would be weird. */
|
2001-02-08 07:03:54 +01:00
|
|
|
|
internal_error (__FILE__, __LINE__,
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
_("gen_expr: OP_MEMVAL operand isn't an rvalue???"));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->type = type;
|
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2005-03-08 15:35:20 +01:00
|
|
|
|
case UNOP_PLUS:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
/* + FOO is equivalent to 0 + FOO, which can be optimized. */
|
|
|
|
|
gen_expr (pc, ax, value);
|
|
|
|
|
gen_usual_unary (ax, value);
|
|
|
|
|
break;
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case UNOP_NEG:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
/* -FOO is equivalent to 0 - FOO. */
|
|
|
|
|
gen_int_literal (ax, &value1, (LONGEST) 0, builtin_type_int);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
gen_usual_unary (ax, &value1); /* shouldn't do much */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_expr (pc, ax, &value2);
|
|
|
|
|
gen_usual_unary (ax, &value2);
|
|
|
|
|
gen_usual_arithmetic (ax, &value1, &value2);
|
|
|
|
|
gen_sub (ax, value, &value1, &value2);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case UNOP_LOGICAL_NOT:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
gen_expr (pc, ax, value);
|
|
|
|
|
gen_logical_not (ax, value);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case UNOP_COMPLEMENT:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
gen_expr (pc, ax, value);
|
|
|
|
|
gen_complement (ax, value);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case UNOP_IND:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
gen_expr (pc, ax, value);
|
|
|
|
|
gen_usual_unary (ax, value);
|
|
|
|
|
if (TYPE_CODE (value->type) != TYPE_CODE_PTR)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Argument of unary `*' is not a pointer."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_deref (ax, value);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case UNOP_ADDR:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
gen_expr (pc, ax, value);
|
|
|
|
|
gen_address_of (ax, value);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case UNOP_SIZEOF:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
/* Notice that gen_sizeof handles its own operand, unlike most
|
1999-07-07 22:19:36 +02:00
|
|
|
|
of the other unary operator functions. This is because we
|
|
|
|
|
have to throw away the code we generate. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_sizeof (pc, ax, value);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case STRUCTOP_STRUCT:
|
|
|
|
|
case STRUCTOP_PTR:
|
|
|
|
|
{
|
|
|
|
|
int length = (*pc)[1].longconst;
|
|
|
|
|
char *name = &(*pc)[2].string;
|
|
|
|
|
|
|
|
|
|
(*pc) += 4 + BYTES_TO_EXP_ELEM (length + 1);
|
|
|
|
|
gen_expr (pc, ax, value);
|
|
|
|
|
if (op == STRUCTOP_STRUCT)
|
|
|
|
|
gen_struct_ref (ax, value, name, ".", "structure or union");
|
|
|
|
|
else if (op == STRUCTOP_PTR)
|
|
|
|
|
gen_struct_ref (ax, value, name, "->",
|
|
|
|
|
"pointer to a structure or union");
|
|
|
|
|
else
|
|
|
|
|
/* If this `if' chain doesn't handle it, then the case list
|
1999-07-07 22:19:36 +02:00
|
|
|
|
shouldn't mention it, and we shouldn't be here. */
|
2001-02-08 07:03:54 +01:00
|
|
|
|
internal_error (__FILE__, __LINE__,
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
_("gen_expr: unhandled struct case"));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
case OP_TYPE:
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Attempt to use a type name as an expression."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
default:
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Unsupported operator in expression."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Generating bytecode from GDB expressions: driver */
|
|
|
|
|
|
|
|
|
|
/* Given a GDB expression EXPR, return bytecode to trace its value.
|
|
|
|
|
The result will use the `trace' and `trace_quick' bytecodes to
|
|
|
|
|
record the value of all memory touched by the expression. The
|
|
|
|
|
caller can then use the ax_reqs function to discover which
|
|
|
|
|
registers it relies upon. */
|
|
|
|
|
struct agent_expr *
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_trace_for_expr (CORE_ADDR scope, struct expression *expr)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
struct cleanup *old_chain = 0;
|
|
|
|
|
struct agent_expr *ax = new_agent_expr (scope);
|
|
|
|
|
union exp_element *pc;
|
|
|
|
|
struct axs_value value;
|
|
|
|
|
|
2000-05-15 08:15:27 +02:00
|
|
|
|
old_chain = make_cleanup_free_agent_expr (ax);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
pc = expr->elts;
|
|
|
|
|
trace_kludge = 1;
|
|
|
|
|
gen_expr (&pc, ax, &value);
|
|
|
|
|
|
|
|
|
|
/* Make sure we record the final object, and get rid of it. */
|
|
|
|
|
gen_traced_pop (ax, &value);
|
|
|
|
|
|
|
|
|
|
/* Oh, and terminate. */
|
|
|
|
|
ax_simple (ax, aop_end);
|
|
|
|
|
|
|
|
|
|
/* We have successfully built the agent expr, so cancel the cleanup
|
|
|
|
|
request. If we add more cleanups that we always want done, this
|
|
|
|
|
will have to get more complicated. */
|
|
|
|
|
discard_cleanups (old_chain);
|
|
|
|
|
return ax;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
agent_command (char *exp, int from_tty)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
struct cleanup *old_chain = 0;
|
|
|
|
|
struct expression *expr;
|
|
|
|
|
struct agent_expr *agent;
|
1999-09-28 23:55:21 +02:00
|
|
|
|
struct frame_info *fi = get_current_frame (); /* need current scope */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* We don't deal with overlay debugging at the moment. We need to
|
|
|
|
|
think more carefully about this. If you copy this code into
|
|
|
|
|
another command, change the error message; the user shouldn't
|
|
|
|
|
have to know anything about agent expressions. */
|
|
|
|
|
if (overlay_debugging)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("GDB can't do agent expression translation with overlays."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
if (exp == 0)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error_no_arg (_("expression to translate"));
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
expr = parse_expression (exp);
|
2000-04-26 14:41:48 +02:00
|
|
|
|
old_chain = make_cleanup (free_current_contents, &expr);
|
2002-12-09 04:30:44 +01:00
|
|
|
|
agent = gen_trace_for_expr (get_frame_pc (fi), expr);
|
2000-05-15 08:15:27 +02:00
|
|
|
|
make_cleanup_free_agent_expr (agent);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
ax_print (gdb_stdout, agent);
|
1999-06-28 18:06:02 +02:00
|
|
|
|
|
|
|
|
|
/* It would be nice to call ax_reqs here to gather some general info
|
|
|
|
|
about the expression, and then print out the result. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
do_cleanups (old_chain);
|
|
|
|
|
dont_repeat ();
|
|
|
|
|
}
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Initialization code. */
|
|
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
|
void _initialize_ax_gdb (void);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
_initialize_ax_gdb (void)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
add_cmd ("agent", class_maintenance, agent_command,
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
_("Translate an expression into remote agent bytecode."),
|
1999-04-16 03:35:26 +02:00
|
|
|
|
&maintenancelist);
|
|
|
|
|
}
|