/* GDB-specific functions for operating on agent expressions
- Copyright 1998 Free Software Foundation, Inc.
+ Copyright 1998, 2000 Free Software Foundation, Inc.
This file is part of GDB.
#include "ax.h"
#include "ax-gdb.h"
-/* Probably the best way to read this file is to start with the types
- and enums in ax-gdb.h, and then 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.
+/* 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.
I'm beginning to wonder whether it wouldn't be nicer to internally
generate trees, with types, and then spit out the bytecode in
struct agent_expr * --- agent expression buffer to generate code into
struct axs_value * --- describes value left on top of stack */
-static struct value *const_var_ref PARAMS ((struct symbol * var));
-static struct value *const_expr PARAMS ((union exp_element ** pc));
-static struct value *maybe_const_expr PARAMS ((union exp_element ** pc));
-
-static void gen_traced_pop PARAMS ((struct agent_expr *, struct axs_value *));
-
-static void gen_sign_extend PARAMS ((struct agent_expr *, struct type *));
-static void gen_extend PARAMS ((struct agent_expr *, struct type *));
-static void gen_fetch PARAMS ((struct agent_expr *, struct type *));
-static void gen_left_shift PARAMS ((struct agent_expr *, int));
-
-
-static void gen_frame_args_address PARAMS ((struct agent_expr *));
-static void gen_frame_locals_address PARAMS ((struct agent_expr *));
-static void gen_offset PARAMS ((struct agent_expr * ax, int offset));
-static void gen_sym_offset PARAMS ((struct agent_expr *, struct symbol *));
-static void gen_var_ref PARAMS ((struct agent_expr * ax,
- struct axs_value * value,
- struct symbol * var));
-
-
-static void gen_int_literal PARAMS ((struct agent_expr * ax,
- struct axs_value * value,
- LONGEST k, struct type * type));
-
-
-static void require_rvalue PARAMS ((struct agent_expr * ax,
- struct axs_value * value));
-static void gen_usual_unary PARAMS ((struct agent_expr * ax,
- struct axs_value * value));
-static int type_wider_than PARAMS ((struct type * type1,
- struct type * type2));
-static struct type *max_type PARAMS ((struct type * type1,
- struct type * type2));
-static void gen_conversion PARAMS ((struct agent_expr * ax,
- struct type * from,
- struct type * to));
-static int is_nontrivial_conversion PARAMS ((struct type * from,
- struct type * to));
-static void gen_usual_arithmetic PARAMS ((struct agent_expr * ax,
- struct axs_value * value1,
- struct axs_value * value2));
-static void gen_integral_promotions PARAMS ((struct agent_expr * ax,
- struct axs_value * value));
-static void gen_cast PARAMS ((struct agent_expr * ax,
- struct axs_value * value,
- struct type * type));
-static void gen_scale PARAMS ((struct agent_expr * ax,
- enum agent_op op,
- struct type * type));
-static void gen_add PARAMS ((struct agent_expr * ax,
- struct axs_value * value,
- struct axs_value * value1,
- struct axs_value * value2,
- char *name));
-static void gen_sub PARAMS ((struct agent_expr * ax,
- struct axs_value * value,
- struct axs_value * value1,
- struct axs_value * value2));
-static void gen_binop PARAMS ((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 PARAMS ((struct agent_expr * ax,
- struct axs_value * value));
-static void gen_complement PARAMS ((struct agent_expr * ax,
- struct axs_value * value));
-static void gen_deref PARAMS ((struct agent_expr *, struct axs_value *));
-static void gen_address_of PARAMS ((struct agent_expr *, struct axs_value *));
-static int find_field PARAMS ((struct type * type, char *name));
-static void gen_bitfield_ref PARAMS ((struct agent_expr * ax,
- struct axs_value * value,
- struct type * type,
- int start, int end));
-static void gen_struct_ref PARAMS ((struct agent_expr * ax,
- struct axs_value * value,
- char *field,
- char *operator_name,
- char *operand_name));
-static void gen_repeat PARAMS ((union exp_element ** pc,
- struct agent_expr * ax,
- struct axs_value * value));
-static void gen_sizeof PARAMS ((union exp_element ** pc,
- struct agent_expr * ax,
- struct axs_value * value));
-static void gen_expr PARAMS ((union exp_element ** pc,
- struct agent_expr * ax,
- struct axs_value * value));
-
-static void print_axs_value PARAMS ((GDB_FILE * f, struct axs_value * value));
-static void agent_command PARAMS ((char *exp, int from_tty));
+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);
+
+static void print_axs_value (struct ui_file *f, struct axs_value * value);
+static void agent_command (char *exp, int from_tty);
\f
/* Detecting constant expressions. */
proletariat? */
static struct value *
-const_var_ref (var)
- struct symbol *var;
+const_var_ref (struct symbol *var)
{
struct type *type = SYMBOL_TYPE (var);
return value_from_longest (type, (LONGEST) SYMBOL_VALUE (var));
case LOC_LABEL:
- return value_from_longest (type, (LONGEST) SYMBOL_VALUE_ADDRESS (var));
+ return value_from_pointer (type, (CORE_ADDR) SYMBOL_VALUE_ADDRESS (var));
default:
return 0;
advanced to the end of it. If we return zero, *PC could be
anywhere. */
static struct value *
-const_expr (pc)
- union exp_element **pc;
+const_expr (union exp_element **pc)
{
enum exp_opcode op = (*pc)->opcode;
struct value *v1;
/* Like const_expr, but guarantee also that *PC is undisturbed if the
expression is not constant. */
static struct value *
-maybe_const_expr (pc)
- union exp_element **pc;
+maybe_const_expr (union exp_element **pc)
{
union exp_element *tentative_pc = *pc;
struct value *v = const_expr (&tentative_pc);
the value. Useful on the left side of a comma, and at the end of
an expression being used for tracing. */
static void
-gen_traced_pop (ax, value)
- struct agent_expr *ax;
- struct axs_value *value;
+gen_traced_pop (struct agent_expr *ax, struct axs_value *value)
{
if (trace_kludge)
switch (value->kind)
/* 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
-gen_sign_extend (ax, type)
- struct agent_expr *ax;
- struct type *type;
+gen_sign_extend (struct agent_expr *ax, struct type *type)
{
/* Do we need to sign-extend this? */
if (!TYPE_UNSIGNED (type))
TYPE, and the upper bits are garbage. Sign-extend or truncate as
needed. */
static void
-gen_extend (ax, type)
- struct agent_expr *ax;
- struct type *type;
+gen_extend (struct agent_expr *ax, struct type *type)
{
int bits = type->length * TARGET_CHAR_BIT;
/* I just had to. */
to TYPE"; generate code to fetch its value. Note that TYPE is the
target type, not the pointer type. */
static void
-gen_fetch (ax, type)
- struct agent_expr *ax;
- struct type *type;
+gen_fetch (struct agent_expr *ax, struct type *type)
{
if (trace_kludge)
{
implementing something we should be (this code's fault).
In any case, it's a bug the user shouldn't see. */
default:
- error ("GDB bug: ax-gdb.c (gen_fetch): strange size");
+ internal_error ("ax-gdb.c (gen_fetch): strange size");
}
gen_sign_extend (ax, type);
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. */
- error ("GDB bug: ax-gdb.c (gen_fetch): bad type code");
+ internal_error ("ax-gdb.c (gen_fetch): bad type code");
}
}
right shift it by -DISTANCE bits if DISTANCE < 0. This generates
unsigned (logical) right shifts. */
static void
-gen_left_shift (ax, distance)
- struct agent_expr *ax;
- int distance;
+gen_left_shift (struct agent_expr *ax, int distance)
{
if (distance > 0)
{
/* Generate code to push the base address of the argument portion of
the top stack frame. */
static void
-gen_frame_args_address (ax)
- struct agent_expr *ax;
+gen_frame_args_address (struct agent_expr *ax)
{
long frame_reg, frame_offset;
/* Generate code to push the base address of the locals portion of the
top stack frame. */
static void
-gen_frame_locals_address (ax)
- struct agent_expr *ax;
+gen_frame_locals_address (struct agent_expr *ax)
{
long frame_reg, frame_offset;
programming in ML, it would be clearer why these are the same
thing. */
static void
-gen_offset (ax, offset)
- struct agent_expr *ax;
- int offset;
+gen_offset (struct agent_expr *ax, int offset)
{
/* It would suffice to simply push the offset and add it, but this
makes it easier to read positive and negative offsets in the
address (stack frame, base register, etc.) Generate code to add
VAR's value to the top of the stack. */
static void
-gen_sym_offset (ax, var)
- struct agent_expr *ax;
- struct symbol *var;
+gen_sym_offset (struct agent_expr *ax, struct symbol *var)
{
gen_offset (ax, SYMBOL_VALUE (var));
}
symbol VAR. Set VALUE to describe the result. */
static void
-gen_var_ref (ax, value, var)
- struct agent_expr *ax;
- struct axs_value *value;
- struct symbol *var;
+gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var)
{
/* Dereference any typedefs. */
value->type = check_typedef (SYMBOL_TYPE (var));
break;
case LOC_CONST_BYTES:
- error ("GDB bug: ax-gdb.c (gen_var_ref): LOC_CONST_BYTES symbols are not supported");
+ internal_error ("ax-gdb.c (gen_var_ref): LOC_CONST_BYTES symbols are not supported");
/* Variable at a fixed location in memory. Easy. */
case LOC_STATIC:
/* Generating bytecode from GDB expressions: literals */
static void
-gen_int_literal (ax, value, k, type)
- struct agent_expr *ax;
- struct axs_value *value;
- LONGEST k;
- struct type *type;
+gen_int_literal (struct agent_expr *ax, struct axs_value *value, LONGEST k,
+ struct type *type)
{
ax_const_l (ax, k);
value->kind = axs_rvalue;
try to make an rvalue out of it. Signal an error if we can't do
that. */
static void
-require_rvalue (ax, value)
- struct agent_expr *ax;
- struct axs_value *value;
+require_rvalue (struct agent_expr *ax, struct axs_value *value)
{
switch (value->kind)
{
lvalue through unchanged, and let `+' raise an error. */
static void
-gen_usual_unary (ax, value)
- struct agent_expr *ax;
- struct axs_value *value;
+gen_usual_unary (struct agent_expr *ax, struct axs_value *value)
{
/* We don't have to generate any code for the usual integral
conversions, since values are always represented as full-width on
/* 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
-type_wider_than (type1, type2)
- struct type *type1, *type2;
+type_wider_than (struct type *type1, struct type *type2)
{
return (TYPE_LENGTH (type1) > TYPE_LENGTH (type2)
|| (TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
/* Return the "wider" of the two types TYPE1 and TYPE2. */
static struct type *
-max_type (type1, type2)
- struct type *type1, *type2;
+max_type (struct type *type1, struct type *type2)
{
return type_wider_than (type1, type2) ? type1 : type2;
}
/* Generate code to convert a scalar value of type FROM to type TO. */
static void
-gen_conversion (ax, from, to)
- struct agent_expr *ax;
- struct type *from, *to;
+gen_conversion (struct agent_expr *ax, struct type *from, struct type *to)
{
/* Perhaps there is a more graceful way to state these rules. */
/* Return non-zero iff the type FROM will require any bytecodes to be
emitted to be converted to the type TO. */
static int
-is_nontrivial_conversion (from, to)
- struct type *from, *to;
+is_nontrivial_conversion (struct type *from, struct type *to)
{
struct agent_expr *ax = new_agent_expr (0);
int nontrivial;
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
-gen_usual_arithmetic (ax, value1, value2)
- struct agent_expr *ax;
- struct axs_value *value1, *value2;
+gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1,
+ struct axs_value *value2)
{
/* Do the usual binary conversions. */
if (TYPE_CODE (value1->type) == TYPE_CODE_INT
the value on the top of the stack, as described by VALUE. Assume
the value has integral type. */
static void
-gen_integral_promotions (ax, value)
- struct agent_expr *ax;
- struct axs_value *value;
+gen_integral_promotions (struct agent_expr *ax, struct axs_value *value)
{
if (!type_wider_than (value->type, builtin_type_int))
{
/* Generate code for a cast to TYPE. */
static void
-gen_cast (ax, value, type)
- struct agent_expr *ax;
- struct axs_value *value;
- struct type *type;
+gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type)
{
/* GCC does allow casts to yield lvalues, so this should be fixed
before merging these changes into the trunk. */
/* Scale the integer on the top of the stack by the size of the target
of the pointer type TYPE. */
static void
-gen_scale (ax, op, type)
- struct agent_expr *ax;
- enum agent_op op;
- struct type *type;
+gen_scale (struct agent_expr *ax, enum agent_op op, struct type *type)
{
struct type *element = TYPE_TARGET_TYPE (type);
they've undergone the usual binary conversions. Used by both
BINOP_ADD and BINOP_SUBSCRIPT. NAME is used in error messages. */
static void
-gen_add (ax, value, value1, value2, name)
- struct agent_expr *ax;
- struct axs_value *value, *value1, *value2;
- char *name;
+gen_add (struct agent_expr *ax, struct axs_value *value,
+ struct axs_value *value1, struct axs_value *value2, char *name)
{
/* Is it INT+PTR? */
if (value1->type->code == TYPE_CODE_INT
value; we assume VALUE1 and VALUE2 describe the two operands, and
that they've undergone the usual binary conversions. */
static void
-gen_sub (ax, value, value1, value2)
- struct agent_expr *ax;
- struct axs_value *value, *value1, *value2;
+gen_sub (struct agent_expr *ax, struct axs_value *value,
+ struct axs_value *value1, struct axs_value *value2)
{
- struct type *element;
-
if (value1->type->code == TYPE_CODE_PTR)
{
/* Is it PTR - INT? */
result needs to be extended. NAME is the English name of the
operator, used in error messages */
static void
-gen_binop (ax, value, value1, value2, op, op_unsigned, may_carry, name)
- struct agent_expr *ax;
- struct axs_value *value, *value1, *value2;
- enum agent_op op, op_unsigned;
- int may_carry;
- char *name;
+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)
{
/* We only handle INT op INT. */
if ((value1->type->code != TYPE_CODE_INT)
static void
-gen_logical_not (ax, value)
- struct agent_expr *ax;
- struct axs_value *value;
+gen_logical_not (struct agent_expr *ax, struct axs_value *value)
{
if (TYPE_CODE (value->type) != TYPE_CODE_INT
&& TYPE_CODE (value->type) != TYPE_CODE_PTR)
static void
-gen_complement (ax, value)
- struct agent_expr *ax;
- struct axs_value *value;
+gen_complement (struct agent_expr *ax, struct axs_value *value)
{
if (TYPE_CODE (value->type) != TYPE_CODE_INT)
error ("Illegal type of operand to `~'.");
/* Dereference the value on the top of the stack. */
static void
-gen_deref (ax, value)
- struct agent_expr *ax;
- struct axs_value *value;
+gen_deref (struct agent_expr *ax, struct axs_value *value)
{
/* The caller should check the type, because several operators use
this, and we don't know what error message to generate. */
if (value->type->code != TYPE_CODE_PTR)
- error ("GDB bug: ax-gdb.c (gen_deref): expected a pointer");
+ internal_error ("ax-gdb.c (gen_deref): expected a pointer");
/* 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
/* Produce the address of the lvalue on the top of the stack. */
static void
-gen_address_of (ax, value)
- struct agent_expr *ax;
- struct axs_value *value;
+gen_address_of (struct agent_expr *ax, struct axs_value *value)
{
/* Special case for taking the address of a function. The ANSI
standard describes this as a special case, too, so this
/* Find the field in the structure type TYPE named NAME, and return
its index in TYPE's field array. */
static int
-find_field (type, name)
- struct type *type;
- char *name;
+find_field (struct type *type, char *name)
{
int i;
/* Make sure this isn't C++. */
if (TYPE_N_BASECLASSES (type) != 0)
- error ("GDB bug: ax-gdb.c (find_field): derived classes supported");
+ internal_error ("ax-gdb.c (find_field): derived classes supported");
for (i = 0; i < TYPE_NFIELDS (type); i++)
{
return i;
if (this_name[0] == '\0')
- error ("GDB bug: ax-gdb.c (find_field): anonymous unions not supported");
+ internal_error ("ax-gdb.c (find_field): anonymous unions not supported");
}
error ("Couldn't find member named `%s' in struct/union `%s'",
starting and one-past-ending *bit* numbers of the field within the
structure. */
static void
-gen_bitfield_ref (ax, value, type, start, end)
- struct agent_expr *ax;
- struct axs_value *value;
- struct type *type;
- int start, end;
+gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value,
+ struct type *type, int start, int end)
{
/* Note that ops[i] fetches 8 << i bits. */
static enum agent_op ops[]
/* Can we fetch the number of bits requested at all? */
if ((end - start) > ((1 << num_ops) * 8))
- error ("GDB bug: ax-gdb.c (gen_bitfield_ref): bitfield too wide");
+ internal_error ("ax-gdb.c (gen_bitfield_ref): bitfield too wide");
/* 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. */
the operator being compiled, and OPERAND_NAME is the kind of thing
it operates on; we use them in error messages. */
static void
-gen_struct_ref (ax, value, field, operator_name, operand_name)
- struct agent_expr *ax;
- struct axs_value *value;
- char *field;
- char *operator_name;
- char *operand_name;
+gen_struct_ref (struct agent_expr *ax, struct axs_value *value, char *field,
+ char *operator_name, char *operand_name)
{
struct type *type;
int i;
gen_usual_unary (ax, value);
gen_deref (ax, value);
}
- type = value->type;
+ type = check_typedef (value->type);
/* This must yield a structure or a union. */
if (TYPE_CODE (type) != TYPE_CODE_STRUCT
stack slots, doing weird things with sizeof, etc. So we require
the right operand to be a constant expression. */
static void
-gen_repeat (pc, ax, value)
- union exp_element **pc;
- struct agent_expr *ax;
- struct axs_value *value;
+gen_repeat (union exp_element **pc, struct agent_expr *ax,
+ struct axs_value *value)
{
struct axs_value value1;
/* We don't want to turn this into an rvalue, so no conversions
*PC should point at the start of the operand expression; we advance it
to the first instruction after the operand. */
static void
-gen_sizeof (pc, ax, value)
- union exp_element **pc;
- struct agent_expr *ax;
- struct axs_value *value;
+gen_sizeof (union exp_element **pc, struct agent_expr *ax,
+ struct axs_value *value)
{
/* We don't care about the value of the operand expression; we only
care about its type. However, in the current arrangement, the
/* 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
-gen_expr (pc, ax, value)
- union exp_element **pc;
- struct agent_expr *ax;
- struct axs_value *value;
+gen_expr (union exp_element **pc, struct agent_expr *ax,
+ struct axs_value *value)
{
/* Used to hold the descriptions of operand expressions. */
struct axs_value value1, value2;
default:
/* We should only list operators in the outer case statement
that we actually handle in the inner case statement. */
- error ("GDB bug: ax-gdb.c (gen_expr): op case sets don't match");
+ internal_error ("ax-gdb.c (gen_expr): op case sets don't match");
}
break;
the given type, and dereference it. */
if (value->kind != axs_rvalue)
/* This would be weird. */
- error ("GDB bug: ax-gdb.c (gen_expr): OP_MEMVAL operand isn't an rvalue???");
+ internal_error ("ax-gdb.c (gen_expr): OP_MEMVAL operand isn't an rvalue???");
value->type = type;
value->kind = axs_lvalue_memory;
}
else
/* If this `if' chain doesn't handle it, then the case list
shouldn't mention it, and we shouldn't be here. */
- error ("GDB bug: ax-gdb.c (gen_expr): unhandled struct case");
+ internal_error ("ax-gdb.c (gen_expr): unhandled struct case");
}
break;
\f
-#if 0 /* not used */
/* Generating bytecode from GDB expressions: driver */
/* Given a GDB expression EXPR, produce a string of agent bytecode
which computes its value. Return the agent expression, and set
*VALUE to describe its type, and whether it's an lvalue or rvalue. */
struct agent_expr *
-expr_to_agent (expr, value)
- struct expression *expr;
- struct axs_value *value;
+expr_to_agent (struct expression *expr, struct axs_value *value)
{
struct cleanup *old_chain = 0;
- struct agent_expr *ax = new_agent_expr ();
+ struct agent_expr *ax = new_agent_expr (0);
union exp_element *pc;
- old_chain = make_cleanup ((make_cleanup_func) free_agent_expr, ax);
+ old_chain = make_cleanup_free_agent_expr (ax);
pc = expr->elts;
trace_kludge = 0;
}
+#if 0 /* not used */
/* Given a GDB expression EXPR denoting an lvalue in memory, produce a
string of agent bytecode which will leave its address and size on
the top of stack. Return the agent expression.
Not sure this function is useful at all. */
struct agent_expr *
-expr_to_address_and_size (expr)
- struct expression *expr;
+expr_to_address_and_size (struct expression *expr)
{
struct axs_value value;
struct agent_expr *ax = expr_to_agent (expr, &value);
return ax;
}
-#endif /* 0 */
+#endif
/* Given a GDB expression EXPR, return bytecode to trace its value.
The result will use the `trace' and `trace_quick' bytecodes to
caller can then use the ax_reqs function to discover which
registers it relies upon. */
struct agent_expr *
-gen_trace_for_expr (scope, expr)
- CORE_ADDR scope;
- struct expression *expr;
+gen_trace_for_expr (CORE_ADDR scope, struct expression *expr)
{
struct cleanup *old_chain = 0;
struct agent_expr *ax = new_agent_expr (scope);
union exp_element *pc;
struct axs_value value;
- old_chain = make_cleanup ((make_cleanup_func) free_agent_expr, ax);
+ old_chain = make_cleanup_free_agent_expr (ax);
pc = expr->elts;
trace_kludge = 1;
/* The "agent" command, for testing: compile and disassemble an expression. */
static void
-print_axs_value (f, value)
- GDB_FILE *f;
- struct axs_value *value;
+print_axs_value (struct ui_file *f, struct axs_value *value)
{
switch (value->kind)
{
static void
-agent_command (exp, from_tty)
- char *exp;
- int from_tty;
+agent_command (char *exp, int from_tty)
{
struct cleanup *old_chain = 0;
struct expression *expr;
struct agent_expr *agent;
- struct frame_info *fi = get_current_frame (); /* need current scope */
+ struct frame_info *fi = get_current_frame (); /* need current scope */
/* We don't deal with overlay debugging at the moment. We need to
think more carefully about this. If you copy this code into
error_no_arg ("expression to translate");
expr = parse_expression (exp);
- old_chain = make_cleanup ((make_cleanup_func) free_current_contents, &expr);
+ old_chain = make_cleanup (free_current_contents, &expr);
agent = gen_trace_for_expr (fi->pc, expr);
- make_cleanup ((make_cleanup_func) free_agent_expr, agent);
+ make_cleanup_free_agent_expr (agent);
ax_print (gdb_stdout, agent);
/* It would be nice to call ax_reqs here to gather some general info
/* Initialization code. */
-void _initialize_ax_gdb PARAMS ((void));
+void _initialize_ax_gdb (void);
void
-_initialize_ax_gdb ()
+_initialize_ax_gdb (void)
{
- struct cmd_list_element *c;
-
add_cmd ("agent", class_maintenance, agent_command,
"Translate an expression into remote agent bytecode.",
&maintenancelist);
projects / binutils.git / blobdiff