X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gdb%2Fax-gdb.c;h=46a88e25cd985c508cec1c4939c7980a6f817eb9;hb=581594903a0e952e9976f6f41f12968dd51189ee;hp=d828895bf72f0c0e2cfdad25584565ec940333d7;hpb=a67af2b9de8208a715df12a4fa4da0d05c08570e;p=external%2Fbinutils.git diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c index d828895..46a88e2 100644 --- a/gdb/ax-gdb.c +++ b/gdb/ax-gdb.c @@ -1,13 +1,13 @@ /* GDB-specific functions for operating on agent expressions. - Copyright 1998, 1999, 2000, 2001, 2003 Free Software Foundation, - Inc. + Copyright (C) 1998, 1999, 2000, 2001, 2003, 2007, 2008, 2009 + 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, @@ -16,9 +16,7 @@ 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., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + along with this program. If not, see . */ #include "defs.h" #include "symtab.h" @@ -35,6 +33,8 @@ #include "gdb_string.h" #include "block.h" #include "regcache.h" +#include "user-regs.h" +#include "language.h" /* 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, @@ -73,11 +73,11 @@ 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_frame_args_address (struct gdbarch *, struct agent_expr *); +static void gen_frame_locals_address (struct gdbarch *, 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, +static void gen_var_ref (struct gdbarch *, struct agent_expr *ax, struct axs_value *value, struct symbol *var); @@ -87,35 +87,39 @@ static void gen_int_literal (struct agent_expr *ax, 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 void gen_usual_unary (struct expression *exp, 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, +static void gen_usual_arithmetic (struct expression *exp, + struct agent_expr *ax, struct axs_value *value1, struct axs_value *value2); -static void gen_integral_promotions (struct agent_expr *ax, +static void gen_integral_promotions (struct expression *exp, + 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_ptradd (struct agent_expr *ax, struct axs_value *value, + struct axs_value *value1, struct axs_value *value2); +static void gen_ptrsub (struct agent_expr *ax, struct axs_value *value, + struct axs_value *value1, struct axs_value *value2); +static void gen_ptrdiff (struct agent_expr *ax, struct axs_value *value, + struct axs_value *value1, struct axs_value *value2, + struct type *result_type); 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_logical_not (struct agent_expr *ax, struct axs_value *value, + struct type *result_type); 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 *); @@ -127,11 +131,12 @@ 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, +static void gen_repeat (struct expression *exp, 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, +static void gen_sizeof (struct expression *exp, union exp_element **pc, + struct agent_expr *ax, struct axs_value *value, + struct type *size_type); +static void gen_expr (struct expression *exp, union exp_element **pc, struct agent_expr *ax, struct axs_value *value); static void agent_command (char *exp, int from_tty); @@ -321,7 +326,7 @@ gen_traced_pop (struct agent_expr *ax, struct axs_value *value) 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 @@ -414,7 +419,7 @@ gen_fetch (struct agent_expr *ax, struct type *type) In any case, it's a bug the user shouldn't see. */ default: internal_error (__FILE__, __LINE__, - "gen_fetch: strange size"); + _("gen_fetch: strange size")); } gen_sign_extend (ax, type); @@ -426,7 +431,7 @@ gen_fetch (struct agent_expr *ax, struct type *type) something we should be (this code's fault). In any case, it's a bug the user shouldn't see. */ internal_error (__FILE__, __LINE__, - "gen_fetch: bad type code"); + _("gen_fetch: bad type code")); } } @@ -456,12 +461,13 @@ gen_left_shift (struct agent_expr *ax, int distance) /* Generate code to push the base address of the argument portion of the top stack frame. */ static void -gen_frame_args_address (struct agent_expr *ax) +gen_frame_args_address (struct gdbarch *gdbarch, struct agent_expr *ax) { int frame_reg; LONGEST frame_offset; - TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset); + gdbarch_virtual_frame_pointer (gdbarch, + ax->scope, &frame_reg, &frame_offset); ax_reg (ax, frame_reg); gen_offset (ax, frame_offset); } @@ -470,12 +476,13 @@ gen_frame_args_address (struct agent_expr *ax) /* Generate code to push the base address of the locals portion of the top stack frame. */ static void -gen_frame_locals_address (struct agent_expr *ax) +gen_frame_locals_address (struct gdbarch *gdbarch, struct agent_expr *ax) { int frame_reg; LONGEST frame_offset; - TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset); + gdbarch_virtual_frame_pointer (gdbarch, + ax->scope, &frame_reg, &frame_offset); ax_reg (ax, frame_reg); gen_offset (ax, frame_offset); } @@ -519,7 +526,8 @@ gen_sym_offset (struct agent_expr *ax, struct symbol *var) symbol VAR. Set VALUE to describe the result. */ static void -gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var) +gen_var_ref (struct gdbarch *gdbarch, struct agent_expr *ax, + struct axs_value *value, struct symbol *var) { /* Dereference any typedefs. */ value->type = check_typedef (SYMBOL_TYPE (var)); @@ -539,7 +547,7 @@ gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var) 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: @@ -549,36 +557,28 @@ gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var) break; case LOC_ARG: /* var lives in argument area of frame */ - gen_frame_args_address (ax); + gen_frame_args_address (gdbarch, 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_frame_args_address (gdbarch, ax); gen_sym_offset (ax, var); /* Don't assume any particular pointer size. */ - gen_fetch (ax, lookup_pointer_type (builtin_type_void)); + gen_fetch (ax, builtin_type (gdbarch)->builtin_data_ptr); value->kind = axs_lvalue_memory; 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_frame_locals_address (gdbarch, ax); gen_sym_offset (ax, var); value->kind = axs_lvalue_memory; break; case LOC_TYPEDEF: - error ("Cannot compute value of typedef `%s'.", + error (_("Cannot compute value of typedef `%s'."), SYMBOL_PRINT_NAME (var)); break; @@ -588,7 +588,6 @@ gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *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. */ @@ -597,9 +596,9 @@ gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var) 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; @@ -608,9 +607,9 @@ gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var) 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)); + error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var)); /* Push the address of the variable. */ ax_const_l (ax, SYMBOL_VALUE_ADDRESS (msym)); @@ -619,22 +618,21 @@ gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *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. - Unfortunatly DWARF 2 stores the frame-base (instead of the + Unfortunately DWARF 2 stores the frame-base (instead of the 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); break; case LOC_OPTIMIZED_OUT: - error ("The variable `%s' has been optimized out.", + error (_("The variable `%s' has been optimized out."), SYMBOL_PRINT_NAME (var)); break; default: - error ("Cannot find value of botched symbol `%s'.", + error (_("Cannot find value of botched symbol `%s'."), SYMBOL_PRINT_NAME (var)); break; } @@ -650,7 +648,7 @@ gen_int_literal (struct agent_expr *ax, struct axs_value *value, LONGEST k, { ax_const_l (ax, k); value->kind = axs_rvalue; - value->type = type; + value->type = check_typedef (type); } @@ -706,7 +704,8 @@ require_rvalue (struct agent_expr *ax, struct axs_value *value) lvalue through unchanged, and let `+' raise an error. */ static void -gen_usual_unary (struct agent_expr *ax, struct axs_value *value) +gen_usual_unary (struct expression *exp, 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 @@ -741,7 +740,7 @@ gen_usual_unary (struct agent_expr *ax, struct axs_value *value) /* If the value is an enum, call it an integer. */ case TYPE_CODE_ENUM: - value->type = builtin_type_int; + value->type = builtin_type (exp->gdbarch)->builtin_int; break; } @@ -826,8 +825,8 @@ is_nontrivial_conversion (struct type *from, struct type *to) 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 (struct agent_expr *ax, struct axs_value *value1, - struct axs_value *value2) +gen_usual_arithmetic (struct expression *exp, 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 @@ -838,7 +837,7 @@ gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1, 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. */ - struct type *target = max_type (builtin_type_int, + struct type *target = max_type (builtin_type (exp->gdbarch)->builtin_int, max_type (value1->type, value2->type)); /* Deal with value2, on the top of the stack. */ @@ -854,7 +853,7 @@ gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1, ax_simple (ax, aop_swap); } - value1->type = value2->type = target; + value1->type = value2->type = check_typedef (target); } } @@ -863,17 +862,20 @@ gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1, the value on the top of the stack, as described by VALUE. Assume the value has integral type. */ static void -gen_integral_promotions (struct agent_expr *ax, struct axs_value *value) +gen_integral_promotions (struct expression *exp, struct agent_expr *ax, + struct axs_value *value) { - if (!type_wider_than (value->type, builtin_type_int)) + const struct builtin_type *builtin = builtin_type (exp->gdbarch); + + if (!type_wider_than (value->type, builtin->builtin_int)) { - gen_conversion (ax, value->type, builtin_type_int); - value->type = builtin_type_int; + gen_conversion (ax, value->type, builtin->builtin_int); + value->type = builtin->builtin_int; } - else if (!type_wider_than (value->type, builtin_type_unsigned_int)) + else if (!type_wider_than (value->type, builtin->builtin_unsigned_int)) { - gen_conversion (ax, value->type, builtin_type_unsigned_int); - value->type = builtin_type_unsigned_int; + gen_conversion (ax, value->type, builtin->builtin_unsigned_int); + value->type = builtin->builtin_unsigned_int; } } @@ -899,15 +901,14 @@ gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type) case TYPE_CODE_STRUCT: case TYPE_CODE_UNION: case TYPE_CODE_FUNC: - error ("Illegal type cast: intended type must be scalar."); + error (_("Invalid type cast: intended type must be scalar.")); 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 - 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: @@ -922,7 +923,7 @@ gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type) break; default: - error ("Casts to requested type are not yet implemented."); + error (_("Casts to requested type are not yet implemented.")); } value->type = type; @@ -947,105 +948,60 @@ gen_scale (struct agent_expr *ax, enum agent_op op, struct type *type) } -/* 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. */ +/* Generate code for pointer arithmetic PTR + INT. */ static void -gen_add (struct agent_expr *ax, struct axs_value *value, - struct axs_value *value1, struct axs_value *value2, char *name) +gen_ptradd (struct agent_expr *ax, struct axs_value *value, + struct axs_value *value1, struct axs_value *value2) { - /* Is it INT+PTR? */ - if (TYPE_CODE (value1->type) == TYPE_CODE_INT - && TYPE_CODE (value2->type) == TYPE_CODE_PTR) - { - /* Swap the values and proceed normally. */ - ax_simple (ax, aop_swap); - gen_scale (ax, aop_mul, value2->type); - ax_simple (ax, aop_add); - gen_extend (ax, value2->type); /* Catch overflow. */ - value->type = value2->type; - } + gdb_assert (TYPE_CODE (value1->type) == TYPE_CODE_PTR); + gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_INT); - /* Is it PTR+INT? */ - else if (TYPE_CODE (value1->type) == TYPE_CODE_PTR - && TYPE_CODE (value2->type) == TYPE_CODE_INT) - { - gen_scale (ax, aop_mul, value1->type); - ax_simple (ax, aop_add); - gen_extend (ax, value1->type); /* Catch overflow. */ - value->type = value1->type; - } + gen_scale (ax, aop_mul, value1->type); + ax_simple (ax, aop_add); + gen_extend (ax, value1->type); /* Catch overflow. */ + value->type = value1->type; + value->kind = axs_rvalue; +} - /* Must be number + number; the usual binary conversions will have - brought them both to the same width. */ - else if (TYPE_CODE (value1->type) == TYPE_CODE_INT - && TYPE_CODE (value2->type) == TYPE_CODE_INT) - { - ax_simple (ax, aop_add); - gen_extend (ax, value1->type); /* Catch overflow. */ - value->type = value1->type; - } - else - error ("Illegal combination of types in %s.", name); +/* Generate code for pointer arithmetic PTR - INT. */ +static void +gen_ptrsub (struct agent_expr *ax, struct axs_value *value, + struct axs_value *value1, struct axs_value *value2) +{ + gdb_assert (TYPE_CODE (value1->type) == TYPE_CODE_PTR); + gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_INT); + gen_scale (ax, aop_mul, value1->type); + ax_simple (ax, aop_sub); + gen_extend (ax, value1->type); /* Catch overflow. */ + value->type = value1->type; 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. */ +/* Generate code for pointer arithmetic PTR - PTR. */ static void -gen_sub (struct agent_expr *ax, struct axs_value *value, - struct axs_value *value1, struct axs_value *value2) +gen_ptrdiff (struct agent_expr *ax, struct axs_value *value, + struct axs_value *value1, struct axs_value *value2, + struct type *result_type) { - if (TYPE_CODE (value1->type) == TYPE_CODE_PTR) - { - /* Is it PTR - INT? */ - if (TYPE_CODE (value2->type) == TYPE_CODE_INT) - { - gen_scale (ax, aop_mul, value1->type); - ax_simple (ax, aop_sub); - gen_extend (ax, value1->type); /* Catch overflow. */ - value->type = value1->type; - } + gdb_assert (TYPE_CODE (value1->type) == TYPE_CODE_PTR); + gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_PTR); - /* Is it PTR - PTR? Strictly speaking, the types ought to - match, but this is what the normal GDB expression evaluator - tests for. */ - else if (TYPE_CODE (value2->type) == TYPE_CODE_PTR - && (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); - value->type = builtin_type_long; /* FIXME --- should be ptrdiff_t */ - } - else - error ("\ + if (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type)) + != TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type))) + error (_("\ First argument of `-' is a pointer, but second argument is neither\n\ -an integer nor a pointer of the same type."); - } - - /* Must be number + number. */ - else if (TYPE_CODE (value1->type) == TYPE_CODE_INT - && TYPE_CODE (value2->type) == TYPE_CODE_INT) - { - ax_simple (ax, aop_sub); - gen_extend (ax, value1->type); /* Catch overflow. */ - value->type = value1->type; - } - - else - error ("Illegal combination of types in subtraction."); +an integer nor a pointer of the same type.")); + ax_simple (ax, aop_sub); + gen_scale (ax, aop_div_unsigned, value1->type); + value->type = result_type; 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 @@ -1060,7 +1016,7 @@ gen_binop (struct agent_expr *ax, struct axs_value *value, /* We only handle INT op INT. */ if ((TYPE_CODE (value1->type) != TYPE_CODE_INT) || (TYPE_CODE (value2->type) != TYPE_CODE_INT)) - error ("Illegal combination of types in %s.", name); + error (_("Invalid combination of types in %s."), name); ax_simple (ax, TYPE_UNSIGNED (value1->type) ? op_unsigned : op); @@ -1072,15 +1028,15 @@ gen_binop (struct agent_expr *ax, struct axs_value *value, static void -gen_logical_not (struct agent_expr *ax, struct axs_value *value) +gen_logical_not (struct agent_expr *ax, struct axs_value *value, + struct type *result_type) { if (TYPE_CODE (value->type) != TYPE_CODE_INT && TYPE_CODE (value->type) != TYPE_CODE_PTR) - error ("Illegal type of operand to `!'."); + error (_("Invalid type of operand to `!'.")); - gen_usual_unary (ax, value); ax_simple (ax, aop_log_not); - value->type = builtin_type_int; + value->type = result_type; } @@ -1088,10 +1044,8 @@ static void gen_complement (struct agent_expr *ax, struct axs_value *value) { if (TYPE_CODE (value->type) != TYPE_CODE_INT) - error ("Illegal type of operand to `~'."); + error (_("Invalid type of operand to `~'.")); - gen_usual_unary (ax, value); - gen_integral_promotions (ax, value); ax_simple (ax, aop_bit_not); gen_extend (ax, value->type); } @@ -1108,7 +1062,7 @@ gen_deref (struct agent_expr *ax, struct axs_value *value) this, and we don't know what error message to generate. */ if (TYPE_CODE (value->type) != TYPE_CODE_PTR) internal_error (__FILE__, __LINE__, - "gen_deref: expected a pointer"); + _("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 @@ -1136,10 +1090,10 @@ gen_address_of (struct agent_expr *ax, struct axs_value *value) switch (value->kind) { case axs_rvalue: - error ("Operand of `&' is an rvalue, which has no address."); + error (_("Operand of `&' is an rvalue, which has no address.")); case axs_lvalue_register: - error ("Operand of `&' is in a register, and has no address."); + error (_("Operand of `&' is in a register, and has no address.")); case axs_lvalue_memory: value->kind = axs_rvalue; @@ -1164,21 +1118,24 @@ find_field (struct type *type, char *name) /* Make sure this isn't C++. */ if (TYPE_N_BASECLASSES (type) != 0) internal_error (__FILE__, __LINE__, - "find_field: derived classes supported"); + _("find_field: derived classes supported")); for (i = 0; i < TYPE_NFIELDS (type); i++) { 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'", + error (_("Couldn't find member named `%s' in struct/union `%s'"), name, TYPE_TAG_NAME (type)); return 0; @@ -1248,7 +1205,7 @@ gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value, /* Can we fetch the number of bits requested at all? */ if ((end - start) > ((1 << num_ops) * 8)) internal_error (__FILE__, __LINE__, - "gen_bitfield_ref: bitfield too wide"); + _("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. */ @@ -1317,7 +1274,7 @@ gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value, 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); @@ -1362,7 +1319,7 @@ gen_struct_ref (struct agent_expr *ax, struct axs_value *value, char *field, should at least be consistent. */ while (TYPE_CODE (value->type) == TYPE_CODE_PTR) { - gen_usual_unary (ax, value); + require_rvalue (ax, value); gen_deref (ax, value); } type = check_typedef (value->type); @@ -1370,13 +1327,13 @@ gen_struct_ref (struct agent_expr *ax, struct axs_value *value, char *field, /* This must yield a structure or a union. */ if (TYPE_CODE (type) != TYPE_CODE_STRUCT && TYPE_CODE (type) != TYPE_CODE_UNION) - error ("The left operand of `%s' is not a %s.", + error (_("The left operand of `%s' is not a %s."), 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) - error ("Structure does not live in memory."); + error (_("Structure does not live in memory.")); i = find_field (type, field); @@ -1407,15 +1364,15 @@ gen_struct_ref (struct agent_expr *ax, struct axs_value *value, char *field, stack slots, doing weird things with sizeof, etc. So we require the right operand to be a constant expression. */ static void -gen_repeat (union exp_element **pc, struct agent_expr *ax, - struct axs_value *value) +gen_repeat (struct expression *exp, 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 here. */ - gen_expr (pc, ax, &value1); + gen_expr (exp, pc, ax, &value1); if (value1.kind != axs_lvalue_memory) - error ("Left operand of `@' must be an object in memory."); + error (_("Left operand of `@' must be an object in memory.")); /* Evaluate the length; it had better be a constant. */ { @@ -1423,12 +1380,12 @@ gen_repeat (union exp_element **pc, struct agent_expr *ax, int length; if (!v) - error ("Right operand of `@' must be a constant, in agent expressions."); - if (TYPE_CODE (v->type) != TYPE_CODE_INT) - error ("Right operand of `@' must be an integer."); + 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); if (length <= 0) - error ("Right operand of `@' must be positive."); + error (_("Right operand of `@' must be positive.")); /* 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. */ @@ -1436,7 +1393,7 @@ gen_repeat (union exp_element **pc, struct agent_expr *ax, /* FIXME-type-allocation: need a way to free this type when we are done with it. */ struct type *range - = create_range_type (0, builtin_type_int, 0, length - 1); + = create_range_type (0, builtin_type_int32, 0, length - 1); struct type *array = create_array_type (0, value1.type, range); value->kind = axs_lvalue_memory; @@ -1450,8 +1407,9 @@ gen_repeat (union exp_element **pc, struct agent_expr *ax, *PC should point at the start of the operand expression; we advance it to the first instruction after the operand. */ static void -gen_sizeof (union exp_element **pc, struct agent_expr *ax, - struct axs_value *value) +gen_sizeof (struct expression *exp, union exp_element **pc, + struct agent_expr *ax, struct axs_value *value, + struct type *size_type) { /* We don't care about the value of the operand expression; we only care about its type. However, in the current arrangement, the @@ -1459,24 +1417,25 @@ gen_sizeof (union exp_element **pc, struct agent_expr *ax, 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); + gen_expr (exp, pc, ax, value); /* Throw away the code we just generated. */ ax->len = start; ax_const_l (ax, TYPE_LENGTH (value->type)); value->kind = axs_rvalue; - value->type = builtin_type_int; + value->type = size_type; } /* Generating bytecode from GDB expressions: general recursive thingy */ +/* XXX: i18n */ /* 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 (union exp_element **pc, struct agent_expr *ax, - struct axs_value *value) +gen_expr (struct expression *exp, 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; @@ -1490,7 +1449,7 @@ gen_expr (union exp_element **pc, struct agent_expr *ax, { ax_const_l (ax, value_as_long (v)); value->kind = axs_rvalue; - value->type = check_typedef (VALUE_TYPE (v)); + value->type = check_typedef (value_type (v)); return; } } @@ -1509,18 +1468,40 @@ gen_expr (union exp_element **pc, struct agent_expr *ax, 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); + gen_expr (exp, pc, ax, &value1); + gen_usual_unary (exp, ax, &value1); + gen_expr (exp, pc, ax, &value2); + gen_usual_unary (exp, ax, &value2); + gen_usual_arithmetic (exp, ax, &value1, &value2); switch (op) { case BINOP_ADD: - gen_add (ax, value, &value1, &value2, "addition"); + if (TYPE_CODE (value1.type) == TYPE_CODE_INT + && TYPE_CODE (value2.type) == TYPE_CODE_PTR) + { + /* Swap the values and proceed normally. */ + ax_simple (ax, aop_swap); + gen_ptradd (ax, value, &value2, &value1); + } + else if (TYPE_CODE (value1.type) == TYPE_CODE_PTR + && TYPE_CODE (value2.type) == TYPE_CODE_INT) + gen_ptradd (ax, value, &value1, &value2); + else + gen_binop (ax, value, &value1, &value2, + aop_add, aop_add, 1, "addition"); break; case BINOP_SUB: - gen_sub (ax, value, &value1, &value2); + if (TYPE_CODE (value1.type) == TYPE_CODE_PTR + && TYPE_CODE (value2.type) == TYPE_CODE_INT) + gen_ptrsub (ax,value, &value1, &value2); + else if (TYPE_CODE (value1.type) == TYPE_CODE_PTR + && TYPE_CODE (value2.type) == TYPE_CODE_PTR) + /* FIXME --- result type should be ptrdiff_t */ + gen_ptrdiff (ax, value, &value1, &value2, + builtin_type (exp->gdbarch)->builtin_long); + else + gen_binop (ax, value, &value1, &value2, + aop_sub, aop_sub, 1, "subtraction"); break; case BINOP_MUL: gen_binop (ax, value, &value1, &value2, @@ -1535,9 +1516,9 @@ gen_expr (union exp_element **pc, struct agent_expr *ax, aop_rem_signed, aop_rem_unsigned, 1, "remainder"); break; case BINOP_SUBSCRIPT: - gen_add (ax, value, &value1, &value2, "array subscripting"); + gen_ptradd (ax, value, &value1, &value2); if (TYPE_CODE (value->type) != TYPE_CODE_PTR) - error ("Illegal combination of types in array subscripting."); + error (_("Invalid combination of types in array subscripting.")); gen_deref (ax, value); break; case BINOP_BITWISE_AND: @@ -1559,7 +1540,7 @@ gen_expr (union exp_element **pc, struct agent_expr *ax, /* We should only list operators in the outer case statement that we actually handle in the inner case statement. */ internal_error (__FILE__, __LINE__, - "gen_expr: op case sets don't match"); + _("gen_expr: op case sets don't match")); } break; @@ -1571,12 +1552,12 @@ gen_expr (union exp_element **pc, struct agent_expr *ax, variables it mentions get traced. */ case BINOP_COMMA: (*pc)++; - gen_expr (pc, ax, &value1); + gen_expr (exp, pc, ax, &value1); /* Don't just dispose of the left operand. We might be tracing, in which case we want to emit code to trace it if it's an lvalue. */ gen_traced_pop (ax, &value1); - gen_expr (pc, ax, value); + gen_expr (exp, pc, ax, value); /* It's the consumer's responsibility to trace the right operand. */ break; @@ -1590,35 +1571,44 @@ gen_expr (union exp_element **pc, struct agent_expr *ax, break; case OP_VAR_VALUE: - gen_var_ref (ax, value, (*pc)[2].symbol); + gen_var_ref (exp->gdbarch, ax, value, (*pc)[2].symbol); (*pc) += 4; break; 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 = 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."), + name); value->kind = axs_lvalue_register; value->u.reg = reg; - value->type = register_type (current_gdbarch, reg); + value->type = register_type (exp->gdbarch, reg); } break; case OP_INTERNALVAR: - error ("GDB agent expressions cannot use convenience variables."); + error (_("GDB agent expressions cannot use convenience variables.")); /* Weirdo operator: see comments for gen_repeat for details. */ case BINOP_REPEAT: /* Note that gen_repeat handles its own argument evaluation. */ (*pc)++; - gen_repeat (pc, ax, value); + gen_repeat (exp, pc, ax, value); break; case UNOP_CAST: { struct type *type = (*pc)[1].type; (*pc) += 3; - gen_expr (pc, ax, value); + gen_expr (exp, pc, ax, value); gen_cast (ax, value, type); } break; @@ -1627,7 +1617,7 @@ gen_expr (union exp_element **pc, struct agent_expr *ax, { struct type *type = check_typedef ((*pc)[1].type); (*pc) += 3; - gen_expr (pc, ax, value); + 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 @@ -1635,47 +1625,58 @@ gen_expr (union exp_element **pc, struct agent_expr *ax, if (value->kind != axs_rvalue) /* This would be weird. */ internal_error (__FILE__, __LINE__, - "gen_expr: OP_MEMVAL operand isn't an rvalue???"); + _("gen_expr: OP_MEMVAL operand isn't an rvalue???")); value->type = type; value->kind = axs_lvalue_memory; } break; + case UNOP_PLUS: + (*pc)++; + /* + FOO is equivalent to 0 + FOO, which can be optimized. */ + gen_expr (exp, pc, ax, value); + gen_usual_unary (exp, ax, value); + break; + case UNOP_NEG: (*pc)++; /* -FOO is equivalent to 0 - FOO. */ - gen_int_literal (ax, &value1, (LONGEST) 0, builtin_type_int); - gen_usual_unary (ax, &value1); /* shouldn't do much */ - gen_expr (pc, ax, &value2); - gen_usual_unary (ax, &value2); - gen_usual_arithmetic (ax, &value1, &value2); - gen_sub (ax, value, &value1, &value2); + gen_int_literal (ax, &value1, (LONGEST) 0, builtin_type_int8); + gen_usual_unary (exp, ax, &value1); /* shouldn't do much */ + gen_expr (exp, pc, ax, &value2); + gen_usual_unary (exp, ax, &value2); + gen_usual_arithmetic (exp, ax, &value1, &value2); + gen_binop (ax, value, &value1, &value2, aop_sub, aop_sub, 1, "negation"); break; case UNOP_LOGICAL_NOT: (*pc)++; - gen_expr (pc, ax, value); - gen_logical_not (ax, value); + gen_expr (exp, pc, ax, value); + gen_usual_unary (exp, ax, value); + gen_logical_not (ax, value, + language_bool_type (exp->language_defn, exp->gdbarch)); break; case UNOP_COMPLEMENT: (*pc)++; - gen_expr (pc, ax, value); + gen_expr (exp, pc, ax, value); + gen_usual_unary (exp, ax, value); + gen_integral_promotions (exp, ax, value); gen_complement (ax, value); break; case UNOP_IND: (*pc)++; - gen_expr (pc, ax, value); - gen_usual_unary (ax, value); + gen_expr (exp, pc, ax, value); + gen_usual_unary (exp, ax, value); if (TYPE_CODE (value->type) != TYPE_CODE_PTR) - error ("Argument of unary `*' is not a pointer."); + error (_("Argument of unary `*' is not a pointer.")); gen_deref (ax, value); break; case UNOP_ADDR: (*pc)++; - gen_expr (pc, ax, value); + gen_expr (exp, pc, ax, value); gen_address_of (ax, value); break; @@ -1684,7 +1685,8 @@ gen_expr (union exp_element **pc, struct agent_expr *ax, /* Notice that gen_sizeof handles its own operand, unlike most of the other unary operator functions. This is because we have to throw away the code we generate. */ - gen_sizeof (pc, ax, value); + gen_sizeof (exp, pc, ax, value, + builtin_type (exp->gdbarch)->builtin_int); break; case STRUCTOP_STRUCT: @@ -1694,7 +1696,7 @@ gen_expr (union exp_element **pc, struct agent_expr *ax, char *name = &(*pc)[2].string; (*pc) += 4 + BYTES_TO_EXP_ELEM (length + 1); - gen_expr (pc, ax, value); + gen_expr (exp, pc, ax, value); if (op == STRUCTOP_STRUCT) gen_struct_ref (ax, value, name, ".", "structure or union"); else if (op == STRUCTOP_PTR) @@ -1704,15 +1706,15 @@ gen_expr (union exp_element **pc, struct agent_expr *ax, /* If this `if' chain doesn't handle it, then the case list shouldn't mention it, and we shouldn't be here. */ internal_error (__FILE__, __LINE__, - "gen_expr: unhandled struct case"); + _("gen_expr: unhandled struct case")); } break; case OP_TYPE: - error ("Attempt to use a type name as an expression."); + error (_("Attempt to use a type name as an expression.")); default: - error ("Unsupported operator in expression."); + error (_("Unsupported operator in expression.")); } } @@ -1720,56 +1722,6 @@ gen_expr (union exp_element **pc, struct agent_expr *ax, /* 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 @@ -1787,7 +1739,7 @@ gen_trace_for_expr (CORE_ADDR scope, struct expression *expr) pc = expr->elts; trace_kludge = 1; - gen_expr (&pc, ax, &value); + gen_expr (expr, &pc, ax, &value); /* Make sure we record the final object, and get rid of it. */ gen_traced_pop (ax, &value); @@ -1815,10 +1767,10 @@ agent_command (char *exp, int from_tty) another command, change the error message; the user shouldn't have to know anything about agent expressions. */ if (overlay_debugging) - error ("GDB can't do agent expression translation with overlays."); + error (_("GDB can't do agent expression translation with overlays.")); if (exp == 0) - error_no_arg ("expression to translate"); + error_no_arg (_("expression to translate")); expr = parse_expression (exp); old_chain = make_cleanup (free_current_contents, &expr); @@ -1841,6 +1793,6 @@ void _initialize_ax_gdb (void) { add_cmd ("agent", class_maintenance, agent_command, - "Translate an expression into remote agent bytecode.", + _("Translate an expression into remote agent bytecode."), &maintenancelist); }