/* GDB-specific functions for operating on agent expressions.
- Copyright (C) 1998, 1999, 2000, 2001, 2003, 2007, 2008, 2009, 2010
+ Copyright (C) 1998, 1999, 2000, 2001, 2003, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
This file is part of GDB.
\f
-/* Prototypes for local functions. */
+/* Prototypes for local functions. */
/* There's a standard order to the arguments of these functions:
union exp_element ** --- pointer into expression
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 gdbarch *, struct agent_expr *, struct axs_value *);
+static void gen_traced_pop (struct gdbarch *, 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 *);
{
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;
}
break;
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);
+ /* We don't actually need the register's value to be pushed,
+ just note that we need it to be collected. */
+ ax_reg_mask (ax, value.u.reg);
default:
break;
break;
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);
+ /* We don't actually need the register's value to be on the
+ stack, and the target will get heartburn if the register is
+ larger than will fit in a stack, so just mark it for
+ collection and be done with it. */
+ ax_reg_mask (ax, value->u.reg);
break;
}
else
gen_extend (struct agent_expr *ax, struct type *type)
{
int bits = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
+
/* I just had to. */
((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, bits));
}
gen_var_ref (struct gdbarch *gdbarch, struct agent_expr *ax,
struct axs_value *value, struct symbol *var)
{
- /* Dereference any typedefs. */
+ /* Dereference any typedefs. */
value->type = check_typedef (SYMBOL_TYPE (var));
value->optimized_out = 0;
case LOC_CONST_BYTES:
internal_error (__FILE__, __LINE__,
- _("gen_var_ref: LOC_CONST_BYTES symbols are not supported"));
+ _("gen_var_ref: LOC_CONST_BYTES "
+ "symbols are not supported"));
/* Variable at a fixed location in memory. Easy. */
case LOC_STATIC:
{
struct minimal_symbol *msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL);
+
if (!msym)
error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var));
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
static int
is_nontrivial_conversion (struct type *from, struct type *to)
{
- struct agent_expr *ax = new_agent_expr (0);
+ struct agent_expr *ax = new_agent_expr (NULL, 0);
int nontrivial;
/* Actually generate the code, and see if anything came out. At the
/* 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. */
+ /* Dereference typedefs. */
type = check_typedef (type);
switch (TYPE_CODE (type))
operator, used in error messages */
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)
+ 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 ((TYPE_CODE (value1->type) != TYPE_CODE_INT)
{
/* Note that ops[i] fetches 8 << i bits. */
static enum agent_op ops[]
- =
- {aop_ref8, aop_ref16, aop_ref32, aop_ref64};
+ = {aop_ref8, aop_ref16, aop_ref32, aop_ref64};
static int num_ops = (sizeof (ops) / sizeof (ops[0]));
/* We don't want to touch any byte that the bitfield doesn't
equal to the number of `one' bits in bytesize, but who cares? */
int fragment_count;
- /* Dereference any typedefs. */
+ /* Dereference any typedefs. */
type = check_typedef (type);
/* Can we fetch the number of bits requested at all? */
{
gen_static_field (exp->gdbarch, ax, value, type, i);
if (value->optimized_out)
- error (_("static field `%s' has been optimized out, cannot use"),
+ error (_("static field `%s' has been "
+ "optimized out, cannot use"),
field);
return 1;
}
struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
rslt = gen_struct_ref_recursive (exp, ax, value, field,
- offset + TYPE_BASECLASS_BITPOS (type, i) / TARGET_CHAR_BIT,
+ offset + TYPE_BASECLASS_BITPOS (type, i)
+ / TARGET_CHAR_BIT,
basetype);
if (rslt)
return 1;
}
else
{
- char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
+ const char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0);
if (sym)
{
struct type *t = type;
int i;
- struct value *v, *result;
if (TYPE_CODE (t) != TYPE_CODE_STRUCT
&& TYPE_CODE (t) != TYPE_CODE_UNION)
{
gen_static_field (exp->gdbarch, ax, value, t, i);
if (value->optimized_out)
- error (_("static field `%s' has been optimized out, cannot use"),
+ error (_("static field `%s' has been "
+ "optimized out, cannot use"),
fieldname);
return 1;
}
return 0;
}
-/* Generate code for GDB's magical `repeat' operator.
+/* 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
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
here. */
gen_expr (exp, pc, ax, &value1);
int length;
if (!v)
- error (_("Right operand of `@' must be a constant, in agent expressions."));
+ error (_("Right operand of `@' must be a "
+ "constant, in agent expressions."));
if (TYPE_CODE (value_type (v)) != TYPE_CODE_INT)
error (_("Right operand of `@' must be an integer."));
length = value_as_long (v);
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 (exp, pc, ax, value);
/* Throw away the code we just generated. */
{
char *name = internalvar_name ((*pc)[1].internalvar);
struct trace_state_variable *tsv;
+
(*pc) += 3;
gen_expr (exp, pc, ax, value);
tsv = find_trace_state_variable (name);
ax_tsv (ax, aop_tracev, tsv->number);
}
else
- error (_("$%s is not a trace state variable, may not assign to it"), name);
+ error (_("$%s is not a trace state variable, "
+ "may not assign to it"), name);
}
else
error (_("May only assign to trace state variables"));
{
char *name = internalvar_name ((*pc)[1].internalvar);
struct trace_state_variable *tsv;
+
(*pc) += 3;
tsv = find_trace_state_variable (name);
if (tsv)
ax_tsv (ax, aop_tracev, tsv->number);
}
else
- error (_("$%s is not a trace state variable, may not assign to it"), name);
+ error (_("$%s is not a trace state variable, "
+ "may not assign to it"), name);
}
else
error (_("May only assign to trace state variables"));
{
struct type *type = (*pc)[1].type;
LONGEST k = (*pc)[2].longconst;
+
(*pc) += 4;
gen_int_literal (ax, value, k, type);
}
{
const char *name = &(*pc)[2].string;
int reg;
+
(*pc) += 4 + BYTES_TO_EXP_ELEM ((*pc)[1].longconst + 1);
reg = user_reg_map_name_to_regnum (exp->gdbarch, name, strlen (name));
if (reg == -1)
internal_error (__FILE__, __LINE__,
_("Register $%s not available"), name);
- if (reg >= gdbarch_num_regs (exp->gdbarch))
- error (_("'%s' is a pseudo-register; "
- "GDB cannot yet trace pseudoregister contents."),
+ /* No support for tracing user registers yet. */
+ if (reg >= gdbarch_num_regs (exp->gdbarch)
+ + gdbarch_num_pseudo_regs (exp->gdbarch))
+ error (_("'%s' is a user-register; "
+ "GDB cannot yet trace user-register contents."),
name);
value->kind = axs_lvalue_register;
value->u.reg = reg;
{
const char *name = internalvar_name ((*pc)[1].internalvar);
struct trace_state_variable *tsv;
+
(*pc) += 3;
tsv = find_trace_state_variable (name);
if (tsv)
value->type = builtin_type (exp->gdbarch)->builtin_long_long;
}
else
- error (_("$%s is not a trace state variable; GDB agent expressions cannot use convenience variables."), name);
+ error (_("$%s is not a trace state variable; GDB agent "
+ "expressions cannot use convenience variables."), name);
}
break;
case UNOP_CAST:
{
struct type *type = (*pc)[1].type;
+
(*pc) += 3;
gen_expr (exp, pc, ax, value);
gen_cast (ax, value, type);
case UNOP_MEMVAL:
{
struct type *type = check_typedef ((*pc)[1].type);
+
(*pc) += 3;
gen_expr (exp, 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. */
- internal_error (__FILE__, __LINE__,
- _("gen_expr: OP_MEMVAL operand isn't an rvalue???"));
+
+ /* If we have an axs_rvalue or an axs_lvalue_memory, then we
+ already have the right value on the stack. For
+ axs_lvalue_register, we must convert. */
+ if (value->kind == axs_lvalue_register)
+ require_rvalue (ax, value);
+
value->type = type;
value->kind = axs_lvalue_memory;
}
case UNOP_PLUS:
(*pc)++;
- /* + FOO is equivalent to 0 + FOO, which can be optimized. */
+ /* + FOO is equivalent to 0 + FOO, which can be optimized. */
gen_expr (exp, pc, ax, value);
gen_usual_unary (exp, ax, value);
break;
case OP_THIS:
{
char *this_name;
- struct symbol *func, *sym;
+ struct symbol *sym, *func;
struct block *b;
+ const struct language_defn *lang;
- func = block_linkage_function (block_for_pc (ax->scope));
- this_name = language_def (SYMBOL_LANGUAGE (func))->la_name_of_this;
- b = SYMBOL_BLOCK_VALUE (func);
+ b = block_for_pc (ax->scope);
+ func = block_linkage_function (b);
+ lang = language_def (SYMBOL_LANGUAGE (func));
- /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
- symbol instead of the LOC_ARG one (if both exist). */
- sym = lookup_block_symbol (b, this_name, VAR_DOMAIN);
+ sym = lookup_language_this (lang, b);
if (!sym)
- error (_("no `%s' found"), this_name);
+ error (_("no `%s' found"), lang->la_name_of_this);
gen_var_ref (exp->gdbarch, ax, value, sym);
if (binop_types_user_defined_p (op, value1->type, value2->type))
{
- error (_("\
-cannot subscript requested type: cannot call user defined functions"));
+ error (_("cannot subscript requested type: "
+ "cannot call user defined functions"));
}
else
{
}
if (!is_integral_type (value2->type))
- error (_("Argument to arithmetic operation not a number or boolean."));
+ error (_("Argument to arithmetic operation "
+ "not a number or boolean."));
gen_ptradd (ax, value, value1, value2);
gen_deref (ax, value);
struct symbol *var)
{
struct cleanup *old_chain = 0;
- struct agent_expr *ax = new_agent_expr (scope);
+ struct agent_expr *ax = new_agent_expr (gdbarch, scope);
struct axs_value value;
old_chain = make_cleanup_free_agent_expr (ax);
gen_trace_for_expr (CORE_ADDR scope, struct expression *expr)
{
struct cleanup *old_chain = 0;
- struct agent_expr *ax = new_agent_expr (scope);
+ struct agent_expr *ax = new_agent_expr (expr->gdbarch, scope);
union exp_element *pc;
struct axs_value value;
pc = expr->elts;
trace_kludge = 1;
+ value.optimized_out = 0;
gen_expr (expr, &pc, ax, &value);
/* Make sure we record the final object, and get rid of it. */
gen_eval_for_expr (CORE_ADDR scope, struct expression *expr)
{
struct cleanup *old_chain = 0;
- struct agent_expr *ax = new_agent_expr (scope);
+ struct agent_expr *ax = new_agent_expr (expr->gdbarch, scope);
union exp_element *pc;
struct axs_value value;
pc = expr->elts;
trace_kludge = 0;
+ value.optimized_out = 0;
gen_expr (expr, &pc, ax, &value);
+ require_rvalue (ax, &value);
+
/* Oh, and terminate. */
ax_simple (ax, aop_end);
old_chain = make_cleanup (free_current_contents, &expr);
agent = gen_trace_for_expr (get_frame_pc (fi), expr);
make_cleanup_free_agent_expr (agent);
+ ax_reqs (agent);
ax_print (gdb_stdout, agent);
/* It would be nice to call ax_reqs here to gather some general info
old_chain = make_cleanup (free_current_contents, &expr);
agent = gen_eval_for_expr (get_frame_pc (fi), expr);
make_cleanup_free_agent_expr (agent);
+ ax_reqs (agent);
ax_print (gdb_stdout, agent);
/* It would be nice to call ax_reqs here to gather some general info
_initialize_ax_gdb (void)
{
add_cmd ("agent", class_maintenance, agent_command,
- _("Translate an expression into remote agent bytecode for tracing."),
+ _("Translate an expression into "
+ "remote agent bytecode for tracing."),
&maintenancelist);
add_cmd ("agent-eval", class_maintenance, agent_eval_command,
- _("Translate an expression into remote agent bytecode for evaluation."),
+ _("Translate an expression into remote "
+ "agent bytecode for evaluation."),
&maintenancelist);
}