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);
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,
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
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
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. */
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))
{
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[]
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);
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
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;
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"),
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? */
{
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);
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;
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'"),
}
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
}
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;
{
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"),
/* 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\"."),
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);
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"),
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)
{
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__,
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. */
{
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;
(*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);
(*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);
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
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;
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. */
/* 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;
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"),
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;
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 "
(*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);
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:
(*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
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"),
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);
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:
&& 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");
projects / external / binutils.git / commitdiff