/* GDB-specific functions for operating on agent expressions.
- Copyright (C) 1998, 1999, 2000, 2001, 2003, 2007
+ Copyright (C) 1998, 1999, 2000, 2001, 2003, 2007, 2008
Free Software Foundation, Inc.
This file is part of GDB.
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
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "symtab.h"
case axs_lvalue_memory:
{
- int length = TYPE_LENGTH (value->type);
+ int length = TYPE_LENGTH (check_typedef (value->type));
/* There's no point in trying to use a trace_quick bytecode
here, since "trace_quick SIZE pop" is three bytes, whereas
int frame_reg;
LONGEST frame_offset;
- TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset);
+ gdbarch_virtual_frame_pointer (current_gdbarch,
+ ax->scope, &frame_reg, &frame_offset);
ax_reg (ax, frame_reg);
gen_offset (ax, frame_offset);
}
int frame_reg;
LONGEST frame_offset;
- TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset);
+ gdbarch_virtual_frame_pointer (current_gdbarch,
+ ax->scope, &frame_reg, &frame_offset);
ax_reg (ax, frame_reg);
gen_offset (ax, frame_offset);
}
break;
case LOC_LOCAL: /* var lives in locals area of frame */
- case LOC_LOCAL_ARG:
gen_frame_locals_address (ax);
gen_sym_offset (ax, var);
value->kind = axs_lvalue_memory;
break;
- case LOC_BASEREG: /* relative to some base register */
- case LOC_BASEREG_ARG:
- ax_reg (ax, SYMBOL_BASEREG (var));
- gen_sym_offset (ax, var);
- value->kind = axs_lvalue_memory;
- break;
-
case LOC_TYPEDEF:
error (_("Cannot compute value of typedef `%s'."),
SYMBOL_PRINT_NAME (var));
break;
case LOC_REGISTER:
- case LOC_REGPARM:
/* 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. */
break;
/* A lot like LOC_REF_ARG, but the pointer lives directly in a
- register, not on the stack. Simpler than LOC_REGISTER and
- LOC_REGPARM, because it's just like any other case where the
- thing has a real address. */
+ register, not on the stack. Simpler than LOC_REGISTER
+ because it's just like any other case where the thing
+ has a real address. */
case LOC_REGPARM_ADDR:
ax_reg (ax, SYMBOL_VALUE (var));
value->kind = axs_lvalue_memory;
case LOC_UNRESOLVED:
{
struct minimal_symbol *msym
- = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);
+ = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL);
if (!msym)
error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var));
break;
case LOC_COMPUTED:
- case LOC_COMPUTED_ARG:
/* FIXME: cagney/2004-01-26: It should be possible to
unconditionally call the SYMBOL_OPS method when available.
Unfortunately DWARF 2 stores the frame-base (instead of the
{
ax_const_l (ax, k);
value->kind = axs_rvalue;
- value->type = type;
+ value->type = check_typedef (type);
}
\f
ax_simple (ax, aop_swap);
}
- value1->type = value2->type = target;
+ value1->type = value2->type = check_typedef (target);
}
}
/* 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
- way for us to actually know what GCC actually does with a
- cast like this? */
- value->type = type;
+ way for us to know what GCC actually does with a cast like
+ this? */
break;
case TYPE_CODE_INT:
{
char *this_name = TYPE_FIELD_NAME (type, i);
- if (this_name && strcmp (name, this_name) == 0)
- return i;
+ if (this_name)
+ {
+ if (strcmp (name, this_name) == 0)
+ return i;
- if (this_name[0] == '\0')
- internal_error (__FILE__, __LINE__,
- _("find_field: anonymous unions not supported"));
+ if (this_name[0] == '\0')
+ internal_error (__FILE__, __LINE__,
+ _("find_field: anonymous unions not supported"));
+ }
}
error (_("Couldn't find member named `%s' in struct/union `%s'"),
case OP_REGISTER:
{
- int reg = (int) (*pc)[1].longconst;
- (*pc) += 3;
+ 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);
+ if (reg >= gdbarch_num_regs (current_gdbarch))
+ error (_("'%s' is a pseudo-register; "
+ "GDB cannot yet trace pseudoregister contents."),
+ name);
value->kind = axs_lvalue_register;
value->u.reg = reg;
value->type = register_type (current_gdbarch, reg);
/* 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 (struct expression *expr, struct axs_value *value)
-{
- struct cleanup *old_chain = 0;
- struct agent_expr *ax = new_agent_expr (0);
- union exp_element *pc;
-
- old_chain = make_cleanup_free_agent_expr (ax);
-
- pc = expr->elts;
- trace_kludge = 0;
- gen_expr (&pc, ax, value);
-
- /* 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;
-}
-
-
-#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 (struct expression *expr)
-{
- struct axs_value value;
- struct agent_expr *ax = expr_to_agent (expr, &value);
-
- /* Complain if the result is not a memory lvalue. */
- if (value.kind != axs_lvalue_memory)
- {
- free_agent_expr (ax);
- error (_("Expression does not denote an object in memory."));
- }
-
- /* Push the object's size on the stack. */
- ax_const_l (ax, TYPE_LENGTH (value.type));
-
- return ax;
-}
-#endif
-
/* 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