aboutsummaryrefslogtreecommitdiff
path: root/gdb/ax-gdb.c
diff options
context:
space:
mode:
Diffstat (limited to 'gdb/ax-gdb.c')
-rw-r--r--gdb/ax-gdb.c164
1 files changed, 73 insertions, 91 deletions
diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c
index fae2e2d..3ec87af 100644
--- a/gdb/ax-gdb.c
+++ b/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");
generated by cgit v1.1 at 2024-12-02 14:01:30 +0000