ax-gdb: Use ax->gdbarch instead of exp->gdbarch, remove unused parameters
In many ax generation functions, the "expression *exp" parameter is only used to access the gdbarch. The same value can be found in the "agent_expr *ax" parameter, which needs to be passed in any case. By using ax->gdbarch instead of exp->gdbarch, we can avoid passing exp in many of these functions. gdb/ChangeLog: * ax-gdb.c (gen_usual_unary): Remove exp parameter, get gdbarch from ax, update calls. (gen_usual_arithmetic): Likewise. (gen_integral_promotions): Likewise. (gen_bitfield_ref): Likewise. (gen_primitive_field): Likewise. (gen_struct_ref_recursive): Likewise. (gen_struct_ref): Likewise. (gen_maybe_namespace_elt): Likewise. (gen_struct_elt_for_reference): Likewise. (gen_namespace_elt): Likewise. (gen_aggregate_elt_ref): Likewise. (gen_expr): Get gdbarch from ax, update calls. (gen_expr_binop_rest): Likewise.
This commit is contained in:
Simon Marchi
parent
ee77ed019f
commit
6661ad4873
@ -1,3 +1,20 @@
|
||||
2017-07-14 Simon Marchi <simon.marchi@ericsson.com>
|
||||
|
||||
* ax-gdb.c (gen_usual_unary): Remove exp parameter, get gdbarch
|
||||
from ax, update calls.
|
||||
(gen_usual_arithmetic): Likewise.
|
||||
(gen_integral_promotions): Likewise.
|
||||
(gen_bitfield_ref): Likewise.
|
||||
(gen_primitive_field): Likewise.
|
||||
(gen_struct_ref_recursive): Likewise.
|
||||
(gen_struct_ref): Likewise.
|
||||
(gen_maybe_namespace_elt): Likewise.
|
||||
(gen_struct_elt_for_reference): Likewise.
|
||||
(gen_namespace_elt): Likewise.
|
||||
(gen_aggregate_elt_ref): Likewise.
|
||||
(gen_expr): Get gdbarch from ax, update calls.
|
||||
(gen_expr_binop_rest): Likewise.
|
||||
|
||||
2017-07-13 Pedro Alves <palves@redhat.com>
|
||||
|
||||
* amd64-darwin-tdep.c (x86_darwin_init_abi_64): Pass tdesc_amd64
|
||||
|
||||
164
gdb/ax-gdb.c
164
gdb/ax-gdb.c
@ -98,19 +98,16 @@ static void gen_int_literal (struct agent_expr *ax,
|
||||
struct axs_value *value,
|
||||
LONGEST k, struct type *type);
|
||||
|
||||
static void gen_usual_unary (struct expression *exp, 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 expression *exp,
|
||||
struct agent_expr *ax,
|
||||
static void gen_usual_arithmetic (struct agent_expr *ax,
|
||||
struct axs_value *value1,
|
||||
struct axs_value *value2);
|
||||
static void gen_integral_promotions (struct expression *exp,
|
||||
struct agent_expr *ax,
|
||||
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);
|
||||
@ -135,19 +132,16 @@ 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 void gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
|
||||
struct axs_value *value,
|
||||
static void gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value,
|
||||
struct type *type, int start, int end);
|
||||
static void gen_primitive_field (struct expression *exp,
|
||||
struct agent_expr *ax,
|
||||
static void gen_primitive_field (struct agent_expr *ax,
|
||||
struct axs_value *value,
|
||||
int offset, int fieldno, struct type *type);
|
||||
static int gen_struct_ref_recursive (struct expression *exp,
|
||||
struct agent_expr *ax,
|
||||
static int gen_struct_ref_recursive (struct agent_expr *ax,
|
||||
struct axs_value *value,
|
||||
const char *field, int offset,
|
||||
struct type *type);
|
||||
static void gen_struct_ref (struct expression *exp, struct agent_expr *ax,
|
||||
static void gen_struct_ref (struct agent_expr *ax,
|
||||
struct axs_value *value,
|
||||
const char *field,
|
||||
const char *operator_name,
|
||||
@ -818,8 +812,7 @@ require_rvalue (struct agent_expr *ax, struct axs_value *value)
|
||||
lvalue through unchanged, and let `+' raise an error. */
|
||||
|
||||
static void
|
||||
gen_usual_unary (struct expression *exp, 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
|
||||
@ -934,8 +927,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 expression *exp, struct agent_expr *ax,
|
||||
struct axs_value *value1, struct axs_value *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
|
||||
@ -946,7 +939,7 @@ gen_usual_arithmetic (struct expression *exp, struct agent_expr *ax,
|
||||
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 (exp->gdbarch)->builtin_int,
|
||||
struct type *target = max_type (builtin_type (ax->gdbarch)->builtin_int,
|
||||
max_type (value1->type, value2->type));
|
||||
|
||||
/* Deal with value2, on the top of the stack. */
|
||||
@ -971,10 +964,9 @@ gen_usual_arithmetic (struct expression *exp, struct agent_expr *ax,
|
||||
the value on the top of the stack, as described by VALUE. Assume
|
||||
the value has integral type. */
|
||||
static void
|
||||
gen_integral_promotions (struct expression *exp, struct agent_expr *ax,
|
||||
struct axs_value *value)
|
||||
gen_integral_promotions (struct agent_expr *ax, struct axs_value *value)
|
||||
{
|
||||
const struct builtin_type *builtin = builtin_type (exp->gdbarch);
|
||||
const struct builtin_type *builtin = builtin_type (ax->gdbarch);
|
||||
|
||||
if (!type_wider_than (value->type, builtin->builtin_int))
|
||||
{
|
||||
@ -1249,9 +1241,8 @@ gen_address_of (struct agent_expr *ax, struct axs_value *value)
|
||||
starting and one-past-ending *bit* numbers of the field within the
|
||||
structure. */
|
||||
static void
|
||||
gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
|
||||
struct axs_value *value, struct type *type,
|
||||
int start, int 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[]
|
||||
@ -1376,7 +1367,7 @@ gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
|
||||
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 (gdbarch_byte_order (exp->gdbarch) == BFD_ENDIAN_BIG)
|
||||
if (gdbarch_byte_order (ax->gdbarch) == BFD_ENDIAN_BIG)
|
||||
gen_left_shift (ax, end - (offset + op_size));
|
||||
else
|
||||
gen_left_shift (ax, offset - start);
|
||||
@ -1409,13 +1400,12 @@ gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
|
||||
generally follow value_primitive_field. */
|
||||
|
||||
static void
|
||||
gen_primitive_field (struct expression *exp,
|
||||
struct agent_expr *ax, struct axs_value *value,
|
||||
gen_primitive_field (struct agent_expr *ax, struct axs_value *value,
|
||||
int offset, int fieldno, struct type *type)
|
||||
{
|
||||
/* Is this a bitfield? */
|
||||
if (TYPE_FIELD_PACKED (type, fieldno))
|
||||
gen_bitfield_ref (exp, ax, value, TYPE_FIELD_TYPE (type, fieldno),
|
||||
gen_bitfield_ref (ax, value, TYPE_FIELD_TYPE (type, fieldno),
|
||||
(offset * TARGET_CHAR_BIT
|
||||
+ TYPE_FIELD_BITPOS (type, fieldno)),
|
||||
(offset * TARGET_CHAR_BIT
|
||||
@ -1434,8 +1424,7 @@ gen_primitive_field (struct expression *exp,
|
||||
base classes. Return 1 if found, 0 if not. */
|
||||
|
||||
static int
|
||||
gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax,
|
||||
struct axs_value *value,
|
||||
gen_struct_ref_recursive (struct agent_expr *ax, struct axs_value *value,
|
||||
const char *field, int offset, struct type *type)
|
||||
{
|
||||
int i, rslt;
|
||||
@ -1457,7 +1446,7 @@ gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax,
|
||||
being handled as a global. */
|
||||
if (field_is_static (&TYPE_FIELD (type, i)))
|
||||
{
|
||||
gen_static_field (exp->gdbarch, ax, value, type, i);
|
||||
gen_static_field (ax->gdbarch, ax, value, type, i);
|
||||
if (value->optimized_out)
|
||||
error (_("static field `%s' has been "
|
||||
"optimized out, cannot use"),
|
||||
@ -1465,7 +1454,7 @@ gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax,
|
||||
return 1;
|
||||
}
|
||||
|
||||
gen_primitive_field (exp, ax, value, offset, i, type);
|
||||
gen_primitive_field (ax, value, offset, i, type);
|
||||
return 1;
|
||||
}
|
||||
#if 0 /* is this right? */
|
||||
@ -1481,7 +1470,7 @@ gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax,
|
||||
{
|
||||
struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
|
||||
|
||||
rslt = gen_struct_ref_recursive (exp, ax, value, field,
|
||||
rslt = gen_struct_ref_recursive (ax, value, field,
|
||||
offset + TYPE_BASECLASS_BITPOS (type, i)
|
||||
/ TARGET_CHAR_BIT,
|
||||
basetype);
|
||||
@ -1499,9 +1488,9 @@ gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax,
|
||||
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 (struct expression *exp, struct agent_expr *ax,
|
||||
struct axs_value *value, const char *field,
|
||||
const char *operator_name, const char *operand_name)
|
||||
gen_struct_ref (struct agent_expr *ax, struct axs_value *value,
|
||||
const char *field, const char *operator_name,
|
||||
const char *operand_name)
|
||||
{
|
||||
struct type *type;
|
||||
int found;
|
||||
@ -1528,7 +1517,7 @@ gen_struct_ref (struct expression *exp, struct agent_expr *ax,
|
||||
error (_("Structure does not live in memory."));
|
||||
|
||||
/* Search through fields and base classes recursively. */
|
||||
found = gen_struct_ref_recursive (exp, ax, value, field, 0, type);
|
||||
found = gen_struct_ref_recursive (ax, value, field, 0, type);
|
||||
|
||||
if (!found)
|
||||
error (_("Couldn't find member named `%s' in struct/union/class `%s'"),
|
||||
@ -1536,12 +1525,10 @@ gen_struct_ref (struct expression *exp, struct agent_expr *ax,
|
||||
}
|
||||
|
||||
static int
|
||||
gen_namespace_elt (struct expression *exp,
|
||||
struct agent_expr *ax, struct axs_value *value,
|
||||
gen_namespace_elt (struct agent_expr *ax, struct axs_value *value,
|
||||
const struct type *curtype, char *name);
|
||||
static int
|
||||
gen_maybe_namespace_elt (struct expression *exp,
|
||||
struct agent_expr *ax, struct axs_value *value,
|
||||
gen_maybe_namespace_elt (struct agent_expr *ax, struct axs_value *value,
|
||||
const struct type *curtype, char *name);
|
||||
|
||||
static void
|
||||
@ -1579,8 +1566,7 @@ gen_static_field (struct gdbarch *gdbarch,
|
||||
}
|
||||
|
||||
static int
|
||||
gen_struct_elt_for_reference (struct expression *exp,
|
||||
struct agent_expr *ax, struct axs_value *value,
|
||||
gen_struct_elt_for_reference (struct agent_expr *ax, struct axs_value *value,
|
||||
struct type *type, char *fieldname)
|
||||
{
|
||||
struct type *t = type;
|
||||
@ -1599,7 +1585,7 @@ gen_struct_elt_for_reference (struct expression *exp,
|
||||
{
|
||||
if (field_is_static (&TYPE_FIELD (t, i)))
|
||||
{
|
||||
gen_static_field (exp->gdbarch, ax, value, t, i);
|
||||
gen_static_field (ax->gdbarch, ax, value, t, i);
|
||||
if (value->optimized_out)
|
||||
error (_("static field `%s' has been "
|
||||
"optimized out, cannot use"),
|
||||
@ -1618,18 +1604,17 @@ gen_struct_elt_for_reference (struct expression *exp,
|
||||
/* FIXME add other scoped-reference cases here */
|
||||
|
||||
/* Do a last-ditch lookup. */
|
||||
return gen_maybe_namespace_elt (exp, ax, value, type, fieldname);
|
||||
return gen_maybe_namespace_elt (ax, value, type, fieldname);
|
||||
}
|
||||
|
||||
/* C++: Return the member NAME of the namespace given by the type
|
||||
CURTYPE. */
|
||||
|
||||
static int
|
||||
gen_namespace_elt (struct expression *exp,
|
||||
struct agent_expr *ax, struct axs_value *value,
|
||||
gen_namespace_elt (struct agent_expr *ax, struct axs_value *value,
|
||||
const struct type *curtype, char *name)
|
||||
{
|
||||
int found = gen_maybe_namespace_elt (exp, ax, value, curtype, name);
|
||||
int found = gen_maybe_namespace_elt (ax, value, curtype, name);
|
||||
|
||||
if (!found)
|
||||
error (_("No symbol \"%s\" in namespace \"%s\"."),
|
||||
@ -1645,8 +1630,7 @@ gen_namespace_elt (struct expression *exp,
|
||||
to, say, some base class of CURTYPE). */
|
||||
|
||||
static int
|
||||
gen_maybe_namespace_elt (struct expression *exp,
|
||||
struct agent_expr *ax, struct axs_value *value,
|
||||
gen_maybe_namespace_elt (struct agent_expr *ax, struct axs_value *value,
|
||||
const struct type *curtype, char *name)
|
||||
{
|
||||
const char *namespace_name = TYPE_TAG_NAME (curtype);
|
||||
@ -1659,7 +1643,7 @@ gen_maybe_namespace_elt (struct expression *exp,
|
||||
if (sym.symbol == NULL)
|
||||
return 0;
|
||||
|
||||
gen_var_ref (exp->gdbarch, ax, value, sym.symbol);
|
||||
gen_var_ref (ax->gdbarch, ax, value, sym.symbol);
|
||||
|
||||
if (value->optimized_out)
|
||||
error (_("`%s' has been optimized out, cannot use"),
|
||||
@ -1670,8 +1654,7 @@ gen_maybe_namespace_elt (struct expression *exp,
|
||||
|
||||
|
||||
static int
|
||||
gen_aggregate_elt_ref (struct expression *exp,
|
||||
struct agent_expr *ax, struct axs_value *value,
|
||||
gen_aggregate_elt_ref (struct agent_expr *ax, struct axs_value *value,
|
||||
struct type *type, char *field,
|
||||
const char *operator_name,
|
||||
const char *operand_name)
|
||||
@ -1680,10 +1663,10 @@ gen_aggregate_elt_ref (struct expression *exp,
|
||||
{
|
||||
case TYPE_CODE_STRUCT:
|
||||
case TYPE_CODE_UNION:
|
||||
return gen_struct_elt_for_reference (exp, ax, value, type, field);
|
||||
return gen_struct_elt_for_reference (ax, value, type, field);
|
||||
break;
|
||||
case TYPE_CODE_NAMESPACE:
|
||||
return gen_namespace_elt (exp, ax, value, type, field);
|
||||
return gen_namespace_elt (ax, value, type, field);
|
||||
break;
|
||||
default:
|
||||
internal_error (__FILE__, __LINE__,
|
||||
@ -1784,7 +1767,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
||||
struct axs_value value1, value2, value3;
|
||||
enum exp_opcode op = (*pc)[0].opcode, op2;
|
||||
int if1, go1, if2, go2, end;
|
||||
struct type *int_type = builtin_type (exp->gdbarch)->builtin_int;
|
||||
struct type *int_type = builtin_type (ax->gdbarch)->builtin_int;
|
||||
|
||||
/* If we're looking at a constant expression, just push its value. */
|
||||
{
|
||||
@ -1822,7 +1805,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
||||
case BINOP_GEQ:
|
||||
(*pc)++;
|
||||
gen_expr (exp, pc, ax, &value1);
|
||||
gen_usual_unary (exp, ax, &value1);
|
||||
gen_usual_unary (ax, &value1);
|
||||
gen_expr_binop_rest (exp, op, pc, ax, value, &value1, &value2);
|
||||
break;
|
||||
|
||||
@ -1830,12 +1813,12 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
||||
(*pc)++;
|
||||
/* Generate the obvious sequence of tests and jumps. */
|
||||
gen_expr (exp, pc, ax, &value1);
|
||||
gen_usual_unary (exp, ax, &value1);
|
||||
gen_usual_unary (ax, &value1);
|
||||
if1 = ax_goto (ax, aop_if_goto);
|
||||
go1 = ax_goto (ax, aop_goto);
|
||||
ax_label (ax, if1, ax->len);
|
||||
gen_expr (exp, pc, ax, &value2);
|
||||
gen_usual_unary (exp, ax, &value2);
|
||||
gen_usual_unary (ax, &value2);
|
||||
if2 = ax_goto (ax, aop_if_goto);
|
||||
go2 = ax_goto (ax, aop_goto);
|
||||
ax_label (ax, if2, ax->len);
|
||||
@ -1853,10 +1836,10 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
||||
(*pc)++;
|
||||
/* Generate the obvious sequence of tests and jumps. */
|
||||
gen_expr (exp, pc, ax, &value1);
|
||||
gen_usual_unary (exp, ax, &value1);
|
||||
gen_usual_unary (ax, &value1);
|
||||
if1 = ax_goto (ax, aop_if_goto);
|
||||
gen_expr (exp, pc, ax, &value2);
|
||||
gen_usual_unary (exp, ax, &value2);
|
||||
gen_usual_unary (ax, &value2);
|
||||
if2 = ax_goto (ax, aop_if_goto);
|
||||
ax_const_l (ax, 0);
|
||||
end = ax_goto (ax, aop_goto);
|
||||
@ -1871,7 +1854,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
||||
case TERNOP_COND:
|
||||
(*pc)++;
|
||||
gen_expr (exp, pc, ax, &value1);
|
||||
gen_usual_unary (exp, ax, &value1);
|
||||
gen_usual_unary (ax, &value1);
|
||||
/* For (A ? B : C), it's easiest to generate subexpression
|
||||
bytecodes in order, but if_goto jumps on true, so we invert
|
||||
the sense of A. Then we can do B by dropping through, and
|
||||
@ -1879,11 +1862,11 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
||||
gen_logical_not (ax, &value1, int_type);
|
||||
if1 = ax_goto (ax, aop_if_goto);
|
||||
gen_expr (exp, pc, ax, &value2);
|
||||
gen_usual_unary (exp, ax, &value2);
|
||||
gen_usual_unary (ax, &value2);
|
||||
end = ax_goto (ax, aop_goto);
|
||||
ax_label (ax, if1, ax->len);
|
||||
gen_expr (exp, pc, ax, &value3);
|
||||
gen_usual_unary (exp, ax, &value3);
|
||||
gen_usual_unary (ax, &value3);
|
||||
ax_label (ax, end, ax->len);
|
||||
/* This is arbitary - what if B and C are incompatible types? */
|
||||
value->type = value2.type;
|
||||
@ -1934,7 +1917,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
||||
ax_tsv (ax, aop_tracev, tsv->number);
|
||||
/* Trace state variables are always 64-bit integers. */
|
||||
value1.kind = axs_rvalue;
|
||||
value1.type = builtin_type (exp->gdbarch)->builtin_long_long;
|
||||
value1.type = builtin_type (ax->gdbarch)->builtin_long_long;
|
||||
/* Now do right half of expression. */
|
||||
gen_expr_binop_rest (exp, op2, pc, ax, value, &value1, &value2);
|
||||
/* We have a result of the binary op, set the tsv. */
|
||||
@ -1962,7 +1945,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
||||
/* 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 (exp->gdbarch, ax, &value1);
|
||||
gen_traced_pop (ax->gdbarch, ax, &value1);
|
||||
gen_expr (exp, pc, ax, value);
|
||||
/* It's the consumer's responsibility to trace the right operand. */
|
||||
break;
|
||||
@ -1978,7 +1961,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
||||
break;
|
||||
|
||||
case OP_VAR_VALUE:
|
||||
gen_var_ref (exp->gdbarch, ax, value, (*pc)[2].symbol);
|
||||
gen_var_ref (ax->gdbarch, ax, value, (*pc)[2].symbol);
|
||||
|
||||
if (value->optimized_out)
|
||||
error (_("`%s' has been optimized out, cannot use"),
|
||||
@ -1993,19 +1976,19 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
||||
int reg;
|
||||
|
||||
(*pc) += 4 + BYTES_TO_EXP_ELEM ((*pc)[1].longconst + 1);
|
||||
reg = user_reg_map_name_to_regnum (exp->gdbarch, name, strlen (name));
|
||||
reg = user_reg_map_name_to_regnum (ax->gdbarch, name, strlen (name));
|
||||
if (reg == -1)
|
||||
internal_error (__FILE__, __LINE__,
|
||||
_("Register $%s not available"), name);
|
||||
/* No support for tracing user registers yet. */
|
||||
if (reg >= gdbarch_num_regs (exp->gdbarch)
|
||||
+ gdbarch_num_pseudo_regs (exp->gdbarch))
|
||||
if (reg >= gdbarch_num_regs (ax->gdbarch)
|
||||
+ gdbarch_num_pseudo_regs (ax->gdbarch))
|
||||
error (_("'%s' is a user-register; "
|
||||
"GDB cannot yet trace user-register contents."),
|
||||
name);
|
||||
value->kind = axs_lvalue_register;
|
||||
value->u.reg = reg;
|
||||
value->type = register_type (exp->gdbarch, reg);
|
||||
value->type = register_type (ax->gdbarch, reg);
|
||||
}
|
||||
break;
|
||||
|
||||
@ -2024,7 +2007,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
||||
ax_tsv (ax, aop_tracev, tsv->number);
|
||||
/* Trace state variables are always 64-bit integers. */
|
||||
value->kind = axs_rvalue;
|
||||
value->type = builtin_type (exp->gdbarch)->builtin_long_long;
|
||||
value->type = builtin_type (ax->gdbarch)->builtin_long_long;
|
||||
}
|
||||
else if (! compile_internalvar_to_ax (var, ax, value))
|
||||
error (_("$%s is not a trace state variable; GDB agent "
|
||||
@ -2113,40 +2096,40 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
||||
(*pc)++;
|
||||
/* + FOO is equivalent to 0 + FOO, which can be optimized. */
|
||||
gen_expr (exp, pc, ax, value);
|
||||
gen_usual_unary (exp, ax, value);
|
||||
gen_usual_unary (ax, value);
|
||||
break;
|
||||
|
||||
case UNOP_NEG:
|
||||
(*pc)++;
|
||||
/* -FOO is equivalent to 0 - FOO. */
|
||||
gen_int_literal (ax, &value1, 0,
|
||||
builtin_type (exp->gdbarch)->builtin_int);
|
||||
gen_usual_unary (exp, ax, &value1); /* shouldn't do much */
|
||||
builtin_type (ax->gdbarch)->builtin_int);
|
||||
gen_usual_unary (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_usual_unary (ax, &value2);
|
||||
gen_usual_arithmetic (ax, &value1, &value2);
|
||||
gen_binop (ax, value, &value1, &value2, aop_sub, aop_sub, 1, "negation");
|
||||
break;
|
||||
|
||||
case UNOP_LOGICAL_NOT:
|
||||
(*pc)++;
|
||||
gen_expr (exp, pc, ax, value);
|
||||
gen_usual_unary (exp, ax, value);
|
||||
gen_usual_unary (ax, value);
|
||||
gen_logical_not (ax, value, int_type);
|
||||
break;
|
||||
|
||||
case UNOP_COMPLEMENT:
|
||||
(*pc)++;
|
||||
gen_expr (exp, pc, ax, value);
|
||||
gen_usual_unary (exp, ax, value);
|
||||
gen_integral_promotions (exp, ax, value);
|
||||
gen_usual_unary (ax, value);
|
||||
gen_integral_promotions (ax, value);
|
||||
gen_complement (ax, value);
|
||||
break;
|
||||
|
||||
case UNOP_IND:
|
||||
(*pc)++;
|
||||
gen_expr (exp, pc, ax, value);
|
||||
gen_usual_unary (exp, ax, value);
|
||||
gen_usual_unary (ax, value);
|
||||
if (!pointer_type (value->type))
|
||||
error (_("Argument of unary `*' is not a pointer."));
|
||||
gen_deref (ax, value);
|
||||
@ -2164,7 +2147,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
||||
of the other unary operator functions. This is because we
|
||||
have to throw away the code we generate. */
|
||||
gen_sizeof (exp, pc, ax, value,
|
||||
builtin_type (exp->gdbarch)->builtin_int);
|
||||
builtin_type (ax->gdbarch)->builtin_int);
|
||||
break;
|
||||
|
||||
case STRUCTOP_STRUCT:
|
||||
@ -2176,9 +2159,9 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
||||
(*pc) += 4 + BYTES_TO_EXP_ELEM (length + 1);
|
||||
gen_expr (exp, pc, ax, value);
|
||||
if (op == STRUCTOP_STRUCT)
|
||||
gen_struct_ref (exp, ax, value, name, ".", "structure or union");
|
||||
gen_struct_ref (ax, value, name, ".", "structure or union");
|
||||
else if (op == STRUCTOP_PTR)
|
||||
gen_struct_ref (exp, ax, value, name, "->",
|
||||
gen_struct_ref (ax, value, name, "->",
|
||||
"pointer to a structure or union");
|
||||
else
|
||||
/* If this `if' chain doesn't handle it, then the case list
|
||||
@ -2202,7 +2185,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
||||
if (!sym)
|
||||
error (_("no `%s' found"), lang->la_name_of_this);
|
||||
|
||||
gen_var_ref (exp->gdbarch, ax, value, sym);
|
||||
gen_var_ref (ax->gdbarch, ax, value, sym);
|
||||
|
||||
if (value->optimized_out)
|
||||
error (_("`%s' has been optimized out, cannot use"),
|
||||
@ -2219,8 +2202,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
||||
char *name = &(*pc)[3].string;
|
||||
int found;
|
||||
|
||||
found = gen_aggregate_elt_ref (exp, ax, value, type, name,
|
||||
"?", "??");
|
||||
found = gen_aggregate_elt_ref (ax, value, type, name, "?", "??");
|
||||
if (!found)
|
||||
error (_("There is no field named %s"), name);
|
||||
(*pc) += 5 + BYTES_TO_EXP_ELEM (length + 1);
|
||||
@ -2248,11 +2230,11 @@ gen_expr_binop_rest (struct expression *exp,
|
||||
struct agent_expr *ax, struct axs_value *value,
|
||||
struct axs_value *value1, struct axs_value *value2)
|
||||
{
|
||||
struct type *int_type = builtin_type (exp->gdbarch)->builtin_int;
|
||||
struct type *int_type = builtin_type (ax->gdbarch)->builtin_int;
|
||||
|
||||
gen_expr (exp, pc, ax, value2);
|
||||
gen_usual_unary (exp, ax, value2);
|
||||
gen_usual_arithmetic (exp, ax, value1, value2);
|
||||
gen_usual_unary (ax, value2);
|
||||
gen_usual_arithmetic (ax, value1, value2);
|
||||
switch (op)
|
||||
{
|
||||
case BINOP_ADD:
|
||||
@ -2278,7 +2260,7 @@ gen_expr_binop_rest (struct expression *exp,
|
||||
&& pointer_type (value2->type))
|
||||
/* FIXME --- result type should be ptrdiff_t */
|
||||
gen_ptrdiff (ax, value, value1, value2,
|
||||
builtin_type (exp->gdbarch)->builtin_long);
|
||||
builtin_type (ax->gdbarch)->builtin_long);
|
||||
else
|
||||
gen_binop (ax, value, value1, value2,
|
||||
aop_sub, aop_sub, 1, "subtraction");
|
||||
|
||||
Loading…
Reference in New Issue
Block a user