/* 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);
}
{
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'"),
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. */
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
gen_left_shift (ax, end - (offset + op_size));
else
gen_left_shift (ax, offset - start);
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);
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