/* Evaluate expressions for GDB.
- Copyright (C) 1986-2020 Free Software Foundation, Inc.
+ Copyright (C) 1986-2021 Free Software Foundation, Inc.
This file is part of GDB.
#include "frame.h"
#include "gdbthread.h"
#include "language.h" /* For CAST_IS_CONVERSION. */
-#include "f-lang.h" /* For array bound stuff. */
#include "cp-abi.h"
#include "infcall.h"
#include "objc-lang.h"
#include "objfiles.h"
#include "typeprint.h"
#include <ctype.h>
+#include "expop.h"
+#include "c-exp.h"
/* Prototypes for local functions. */
struct expression *, int *,
enum noside, int);
-static LONGEST init_array_element (struct value *, struct value *,
- struct expression *, int *, enum noside,
- LONGEST, LONGEST);
-
struct value *
evaluate_subexp (struct type *expect_type, struct expression *exp,
int *pos, enum noside noside)
{
- struct value *retval;
-
- gdb::optional<enable_thread_stack_temporaries> stack_temporaries;
- if (*pos == 0 && target_has_execution
- && exp->language_defn->la_language == language_cplus
- && !thread_stack_temporaries_enabled_p (inferior_thread ()))
- stack_temporaries.emplace (inferior_thread ());
-
- retval = (*exp->language_defn->la_exp_desc->evaluate_exp)
- (expect_type, exp, pos, noside);
-
- if (stack_temporaries.has_value ()
- && value_in_thread_stack_temporaries (retval, inferior_thread ()))
- retval = value_non_lval (retval);
-
- return retval;
+ return ((*exp->language_defn->expression_ops ()->evaluate_exp)
+ (expect_type, exp, pos, noside));
}
\f
/* Parse the string EXP as a C expression, evaluate it,
return evaluate_expression (expr.get ());
}
\f
-/* Evaluate an expression in internal prefix form
- such as is constructed by parse.y.
- See expression.h for info on the format of an expression. */
+/* See expression.h. */
struct value *
-evaluate_expression (struct expression *exp)
+expression::evaluate (struct type *expect_type, enum noside noside)
{
- int pc = 0;
+ gdb::optional<enable_thread_stack_temporaries> stack_temporaries;
+ if (target_has_execution ()
+ && language_defn->la_language == language_cplus
+ && !thread_stack_temporaries_enabled_p (inferior_thread ()))
+ stack_temporaries.emplace (inferior_thread ());
+
+ int pos = 0;
+ struct value *retval = evaluate_subexp (expect_type, this, &pos, noside);
- return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL);
+ if (stack_temporaries.has_value ()
+ && value_in_thread_stack_temporaries (retval, inferior_thread ()))
+ retval = value_non_lval (retval);
+
+ return retval;
+}
+
+/* See value.h. */
+
+struct value *
+evaluate_expression (struct expression *exp, struct type *expect_type)
+{
+ return exp->evaluate (expect_type, EVAL_NORMAL);
}
/* Evaluate an expression, avoiding all memory references
struct value *
evaluate_type (struct expression *exp)
{
- int pc = 0;
-
- return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
+ return exp->evaluate (nullptr, EVAL_AVOID_SIDE_EFFECTS);
}
/* Evaluate a subexpression, avoiding all memory references and
struct value *
evaluate_subexpression_type (struct expression *exp, int subexp)
{
- return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS);
+ return evaluate_subexp (nullptr, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS);
}
/* Find the current value of a watchpoint on EXP. Return the value in
fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
struct value **resultp,
std::vector<value_ref_ptr> *val_chain,
- int preserve_errors)
+ bool preserve_errors)
{
struct value *mark, *new_mark, *result;
try
{
- result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL);
+ result = evaluate_subexp (nullptr, exp, pc, EVAL_NORMAL);
}
catch (const gdb_exception &ex)
{
fieldno++;
if (fieldno >= struct_type->num_fields ())
error (_("too many initializers"));
- field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
+ field_type = struct_type->field (fieldno).type ();
if (field_type->code () == TYPE_CODE_UNION
&& TYPE_FIELD_NAME (struct_type, fieldno)[0] == '0')
error (_("don't know which variant you want to set"));
subfieldno is the index of the actual real (named inner) field
in substruct_type. */
- field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
+ field_type = struct_type->field (fieldno).type ();
if (val == 0)
val = evaluate_subexp (field_type, exp, pos, noside);
return struct_val;
}
-/* Recursive helper function for setting elements of array tuples.
- The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
- element value is ELEMENT; EXP, POS and NOSIDE are as usual.
- Evaluates index expressions and sets the specified element(s) of
- ARRAY to ELEMENT. Returns last index value. */
-
-static LONGEST
-init_array_element (struct value *array, struct value *element,
- struct expression *exp, int *pos,
- enum noside noside, LONGEST low_bound, LONGEST high_bound)
-{
- LONGEST index;
- int element_size = TYPE_LENGTH (value_type (element));
-
- if (exp->elts[*pos].opcode == BINOP_COMMA)
- {
- (*pos)++;
- init_array_element (array, element, exp, pos, noside,
- low_bound, high_bound);
- return init_array_element (array, element,
- exp, pos, noside, low_bound, high_bound);
- }
- else
- {
- index = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
- if (index < low_bound || index > high_bound)
- error (_("tuple index out of range"));
- memcpy (value_contents_raw (array) + (index - low_bound) * element_size,
- value_contents (element), element_size);
- }
- return index;
-}
-
-static struct value *
-value_f90_subarray (struct value *array,
- struct expression *exp, int *pos, enum noside noside)
-{
- int pc = (*pos) + 1;
- LONGEST low_bound, high_bound;
- struct type *range = check_typedef (value_type (array)->index_type ());
- enum range_type range_type
- = (enum range_type) longest_to_int (exp->elts[pc].longconst);
-
- *pos += 3;
-
- if (range_type == LOW_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
- low_bound = TYPE_LOW_BOUND (range);
- else
- low_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
-
- if (range_type == HIGH_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
- high_bound = TYPE_HIGH_BOUND (range);
- else
- high_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
-
- return value_slice (array, low_bound, high_bound - low_bound + 1);
-}
-
-
/* Promote value ARG1 as appropriate before performing a unary operation
on this argument.
If the result is not appropriate for any particular language then it
&& !is_integral_type (type2)))
return;
+ if (is_fixed_point_type (type1) || is_fixed_point_type (type2))
+ return;
+
if (type1->code () == TYPE_CODE_DECFLOAT
|| type2->code () == TYPE_CODE_DECFLOAT)
{
const struct builtin_type *builtin = builtin_type (gdbarch);
unsigned int promoted_len1 = TYPE_LENGTH (type1);
unsigned int promoted_len2 = TYPE_LENGTH (type2);
- int is_unsigned1 = TYPE_UNSIGNED (type1);
- int is_unsigned2 = TYPE_UNSIGNED (type2);
+ int is_unsigned1 = type1->is_unsigned ();
+ int is_unsigned2 = type2->is_unsigned ();
unsigned int result_len;
int unsigned_operation;
/* Determine type length and signedness after promotion for
- both operands. */
+ both operands. */
if (promoted_len1 < TYPE_LENGTH (builtin->builtin_int))
{
is_unsigned1 = 0;
return 1;
case TYPE_CODE_ARRAY:
- return TYPE_VECTOR (type) ? 0 : lang->c_style_arrays;
+ return type->is_vector () ? 0 : lang->c_style_arrays_p ();
default:
return 0;
TYPE_LENGTH (type) = 1;
type->set_code (TYPE_CODE_METHOD);
TYPE_CHAIN (type) = type;
- TYPE_INSTANCE_FLAGS (type) = flags;
+ type->set_instance_flags (flags);
if (num_types > 0)
{
if (param_types[num_types - 1] == NULL)
{
--num_types;
- TYPE_VARARGS (type) = 1;
+ type->set_has_varargs (true);
}
else if (check_typedef (param_types[num_types - 1])->code ()
== TYPE_CODE_VOID)
--num_types;
/* Caller should have ensured this. */
gdb_assert (num_types == 0);
- TYPE_PROTOTYPED (type) = 1;
+ type->set_is_prototyped (true);
}
}
((struct field *) xzalloc (sizeof (struct field) * num_types));
while (num_types-- > 0)
- TYPE_FIELD_TYPE (type, num_types) = param_types[num_types];
+ type->field (num_types).set_type (param_types[num_types]);
}
fake_method::~fake_method ()
CORE_ADDR address;
type *the_type = find_minsym_type_and_address (msymbol, objfile, &address);
- if (noside == EVAL_AVOID_SIDE_EFFECTS && !TYPE_GNU_IFUNC (the_type))
+ if (noside == EVAL_AVOID_SIDE_EFFECTS && !the_type->is_gnu_ifunc ())
return value_zero (the_type, not_lval);
else
return value_at_lazy (the_type, address);
return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
}
-/* Evaluate a function call. The function to be called is in
- ARGVEC[0] and the arguments passed to the function are in
- ARGVEC[1..NARGS]. FUNCTION_NAME is the name of the function, if
- known. DEFAULT_RETURN_TYPE is used as the function's return type
- if the return type is unknown. */
+/* See expression.h. */
-static value *
-eval_call (expression *exp, enum noside noside,
- int nargs, value **argvec,
- const char *function_name,
- type *default_return_type)
+value *
+evaluate_subexp_do_call (expression *exp, enum noside noside,
+ value *callee,
+ gdb::array_view<value *> argvec,
+ const char *function_name,
+ type *default_return_type)
{
- if (argvec[0] == NULL)
+ if (callee == NULL)
error (_("Cannot evaluate function -- may be inlined"));
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
call an error. This can happen if somebody tries to turn
a variable into a function call. */
- type *ftype = value_type (argvec[0]);
+ type *ftype = value_type (callee);
if (ftype->code () == TYPE_CODE_INTERNAL_FUNCTION)
{
}
else if (ftype->code () == TYPE_CODE_XMETHOD)
{
- type *return_type
- = result_type_of_xmethod (argvec[0],
- gdb::make_array_view (argvec + 1,
- nargs));
+ type *return_type = result_type_of_xmethod (callee, argvec);
if (return_type == NULL)
error (_("Xmethod is missing return type."));
else if (ftype->code () == TYPE_CODE_FUNC
|| ftype->code () == TYPE_CODE_METHOD)
{
- if (TYPE_GNU_IFUNC (ftype))
+ if (ftype->is_gnu_ifunc ())
{
- CORE_ADDR address = value_address (argvec[0]);
+ CORE_ADDR address = value_address (callee);
type *resolved_type = find_gnu_ifunc_target_type (address);
if (resolved_type != NULL)
error (_("Expression of type other than "
"\"Function returning ...\" used as function"));
}
- switch (value_type (argvec[0])->code ())
+ switch (value_type (callee)->code ())
{
case TYPE_CODE_INTERNAL_FUNCTION:
return call_internal_function (exp->gdbarch, exp->language_defn,
- argvec[0], nargs, argvec + 1);
+ callee, argvec.size (), argvec.data ());
case TYPE_CODE_XMETHOD:
- return call_xmethod (argvec[0], gdb::make_array_view (argvec + 1, nargs));
+ return call_xmethod (callee, argvec);
default:
- return call_function_by_hand (argvec[0], default_return_type,
- gdb::make_array_view (argvec + 1, nargs));
+ return call_function_by_hand (callee, default_return_type, argvec);
}
}
}
else
{
- arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ arg2 = evaluate_subexp (nullptr, exp, pos, noside);
}
/* If the function is a virtual function, then the aggregate
the vtable. Otherwise, it is just along for the ride: call
the function directly. */
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
type *a1_type = check_typedef (value_type (arg1));
if (noside == EVAL_SKIP)
}
else
{
- arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ arg2 = evaluate_subexp (nullptr, exp, pos, noside);
/* Check to see if the operator '->' has been overloaded.
If the operator has been overloaded replace arg2 with the
{
for (; tem <= nargs && tem <= type->num_fields (); tem++)
{
- argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type,
- tem - 1),
+ argvec[tem] = evaluate_subexp (type->field (tem - 1).type (),
exp, pos, noside);
}
}
/* Nothing to be done; argvec already correctly set up. */
}
- return eval_call (exp, noside, nargs, argvec, var_func_name, expect_type);
-}
-
-/* Helper for skipping all the arguments in an undetermined argument list.
- This function was designed for use in the OP_F77_UNDETERMINED_ARGLIST
- case of evaluate_subexp_standard as multiple, but not all, code paths
- require a generic skip. */
-
-static void
-skip_undetermined_arglist (int nargs, struct expression *exp, int *pos,
- enum noside noside)
-{
- for (int i = 0; i < nargs; ++i)
- evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ return evaluate_subexp_do_call (exp, noside, argvec[0],
+ gdb::make_array_view (argvec + 1, nargs),
+ var_func_name, expect_type);
}
/* Return true if type is integral or reference to integral */
&& is_integral_type (TYPE_TARGET_TYPE (type)));
}
+/* Helper function that implements the body of OP_SCOPE. */
+
struct value *
-evaluate_subexp_standard (struct type *expect_type,
- struct expression *exp, int *pos,
- enum noside noside)
+eval_op_scope (struct type *expect_type, struct expression *exp,
+ enum noside noside,
+ struct type *type, const char *string)
{
- enum exp_opcode op;
- int tem, tem2, tem3;
- int pc, oldpos;
- struct value *arg1 = NULL;
- struct value *arg2 = NULL;
- struct value *arg3;
- struct type *type;
- int nargs;
- struct value **argvec;
- int code;
- int ix;
- long mem_offset;
- struct type **arg_types;
-
- pc = (*pos)++;
- op = exp->elts[pc].opcode;
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ struct value *arg1 = value_aggregate_elt (type, string, expect_type,
+ 0, noside);
+ if (arg1 == NULL)
+ error (_("There is no field named %s"), string);
+ return arg1;
+}
- switch (op)
- {
- case OP_SCOPE:
- tem = longest_to_int (exp->elts[pc + 2].longconst);
- (*pos) += 4 + BYTES_TO_EXP_ELEM (tem + 1);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- arg1 = value_aggregate_elt (exp->elts[pc + 1].type,
- &exp->elts[pc + 3].string,
- expect_type, 0, noside);
- if (arg1 == NULL)
- error (_("There is no field named %s"), &exp->elts[pc + 3].string);
- return arg1;
+/* Helper function that implements the body of OP_VAR_ENTRY_VALUE. */
- case OP_LONG:
- (*pos) += 3;
- return value_from_longest (exp->elts[pc + 1].type,
- exp->elts[pc + 2].longconst);
+struct value *
+eval_op_var_entry_value (struct type *expect_type, struct expression *exp,
+ enum noside noside, symbol *sym)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ return value_zero (SYMBOL_TYPE (sym), not_lval);
- case OP_FLOAT:
- (*pos) += 3;
- return value_from_contents (exp->elts[pc + 1].type,
- exp->elts[pc + 2].floatconst);
+ if (SYMBOL_COMPUTED_OPS (sym) == NULL
+ || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
+ error (_("Symbol \"%s\" does not have any specific entry value"),
+ sym->print_name ());
- case OP_ADL_FUNC:
- case OP_VAR_VALUE:
- {
- (*pos) += 3;
- symbol *var = exp->elts[pc + 2].symbol;
- if (SYMBOL_TYPE (var)->code () == TYPE_CODE_ERROR)
- error_unknown_type (var->print_name ());
- if (noside != EVAL_SKIP)
- return evaluate_var_value (noside, exp->elts[pc + 1].block, var);
- else
- {
- /* Return a dummy value of the correct type when skipping, so
- that parent functions know what is to be skipped. */
- return allocate_value (SYMBOL_TYPE (var));
- }
- }
+ struct frame_info *frame = get_selected_frame (NULL);
+ return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
+}
- case OP_VAR_MSYM_VALUE:
- {
- (*pos) += 3;
+/* Helper function that implements the body of OP_VAR_MSYM_VALUE. */
- minimal_symbol *msymbol = exp->elts[pc + 2].msymbol;
- value *val = evaluate_var_msym_value (noside,
- exp->elts[pc + 1].objfile,
- msymbol);
+struct value *
+eval_op_var_msym_value (struct type *expect_type, struct expression *exp,
+ enum noside noside, bool outermost_p,
+ minimal_symbol *msymbol, struct objfile *objfile)
+{
+ value *val = evaluate_var_msym_value (noside, objfile, msymbol);
- type = value_type (val);
- if (type->code () == TYPE_CODE_ERROR
- && (noside != EVAL_AVOID_SIDE_EFFECTS || pc != 0))
- error_unknown_type (msymbol->print_name ());
- return val;
- }
+ struct type *type = value_type (val);
+ if (type->code () == TYPE_CODE_ERROR
+ && (noside != EVAL_AVOID_SIDE_EFFECTS || !outermost_p))
+ error_unknown_type (msymbol->print_name ());
+ return val;
+}
- case OP_VAR_ENTRY_VALUE:
- (*pos) += 2;
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
+/* Helper function that implements the body of OP_FUNC_STATIC_VAR. */
- {
- struct symbol *sym = exp->elts[pc + 1].symbol;
- struct frame_info *frame;
+struct value *
+eval_op_func_static_var (struct type *expect_type, struct expression *exp,
+ enum noside noside,
+ value *func, const char *var)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ CORE_ADDR addr = value_address (func);
+ const block *blk = block_for_pc (addr);
+ struct block_symbol sym = lookup_symbol (var, blk, VAR_DOMAIN, NULL);
+ if (sym.symbol == NULL)
+ error (_("No symbol \"%s\" in specified context."), var);
+ return evaluate_var_value (noside, sym.block, sym.symbol);
+}
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return value_zero (SYMBOL_TYPE (sym), not_lval);
+/* Helper function that implements the body of OP_REGISTER. */
- if (SYMBOL_COMPUTED_OPS (sym) == NULL
- || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
- error (_("Symbol \"%s\" does not have any specific entry value"),
- sym->print_name ());
+struct value *
+eval_op_register (struct type *expect_type, struct expression *exp,
+ enum noside noside, const char *name)
+{
+ int regno;
+ struct value *val;
- frame = get_selected_frame (NULL);
- return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
- }
+ regno = user_reg_map_name_to_regnum (exp->gdbarch,
+ name, strlen (name));
+ if (regno == -1)
+ error (_("Register $%s not available."), name);
+
+ /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
+ a value with the appropriate register type. Unfortunately,
+ we don't have easy access to the type of user registers.
+ So for these registers, we fetch the register value regardless
+ of the evaluation mode. */
+ if (noside == EVAL_AVOID_SIDE_EFFECTS
+ && regno < gdbarch_num_cooked_regs (exp->gdbarch))
+ val = value_zero (register_type (exp->gdbarch, regno), not_lval);
+ else
+ val = value_of_register (regno, get_selected_frame (NULL));
+ if (val == NULL)
+ error (_("Value of register %s not available."), name);
+ else
+ return val;
+}
- case OP_FUNC_STATIC_VAR:
- tem = longest_to_int (exp->elts[pc + 1].longconst);
- (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
+/* Helper function that implements the body of OP_STRING. */
- {
- value *func = evaluate_subexp_standard (NULL, exp, pos, noside);
- CORE_ADDR addr = value_address (func);
+struct value *
+eval_op_string (struct type *expect_type, struct expression *exp,
+ enum noside noside, int len, const char *string)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ struct type *type = language_string_char_type (exp->language_defn,
+ exp->gdbarch);
+ return value_string (string, len, type);
+}
- const block *blk = block_for_pc (addr);
- const char *var = &exp->elts[pc + 2].string;
+/* Helper function that implements the body of OP_OBJC_SELECTOR. */
- struct block_symbol sym = lookup_symbol (var, blk, VAR_DOMAIN, NULL);
+struct value *
+eval_op_objc_selector (struct type *expect_type, struct expression *exp,
+ enum noside noside,
+ const char *sel)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
- if (sym.symbol == NULL)
- error (_("No symbol \"%s\" in specified context."), var);
+ struct type *selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
+ return value_from_longest (selector_type,
+ lookup_child_selector (exp->gdbarch, sel));
+}
- return evaluate_var_value (noside, sym.block, sym.symbol);
- }
+/* Helper function that implements the body of BINOP_CONCAT. */
- case OP_LAST:
- (*pos) += 2;
- return
- access_value_history (longest_to_int (exp->elts[pc + 1].longconst));
+struct value *
+eval_op_concat (struct type *expect_type, struct expression *exp,
+ enum noside noside, struct value *arg1, struct value *arg2)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (binop_user_defined_p (BINOP_CONCAT, arg1, arg2))
+ return value_x_binop (arg1, arg2, BINOP_CONCAT, OP_NULL, noside);
+ else
+ return value_concat (arg1, arg2);
+}
- case OP_REGISTER:
- {
- const char *name = &exp->elts[pc + 2].string;
- int regno;
- struct value *val;
+/* A helper function for TERNOP_SLICE. */
- (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
- regno = user_reg_map_name_to_regnum (exp->gdbarch,
- name, strlen (name));
- if (regno == -1)
- error (_("Register $%s not available."), name);
-
- /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
- a value with the appropriate register type. Unfortunately,
- we don't have easy access to the type of user registers.
- So for these registers, we fetch the register value regardless
- of the evaluation mode. */
- if (noside == EVAL_AVOID_SIDE_EFFECTS
- && regno < gdbarch_num_cooked_regs (exp->gdbarch))
- val = value_zero (register_type (exp->gdbarch, regno), not_lval);
- else
- val = value_of_register (regno, get_selected_frame (NULL));
- if (val == NULL)
- error (_("Value of register %s not available."), name);
- else
- return val;
- }
- case OP_BOOL:
- (*pos) += 2;
- type = language_bool_type (exp->language_defn, exp->gdbarch);
- return value_from_longest (type, exp->elts[pc + 1].longconst);
+struct value *
+eval_op_ternop (struct type *expect_type, struct expression *exp,
+ enum noside noside,
+ struct value *array, struct value *low, struct value *upper)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ int lowbound = value_as_long (low);
+ int upperbound = value_as_long (upper);
+ return value_slice (array, lowbound, upperbound - lowbound + 1);
+}
- case OP_INTERNALVAR:
- (*pos) += 2;
- return value_of_internalvar (exp->gdbarch,
- exp->elts[pc + 1].internalvar);
+/* A helper function for STRUCTOP_STRUCT. */
- case OP_STRING:
- tem = longest_to_int (exp->elts[pc + 1].longconst);
- (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- type = language_string_char_type (exp->language_defn, exp->gdbarch);
- return value_string (&exp->elts[pc + 2].string, tem, type);
+struct value *
+eval_op_structop_struct (struct type *expect_type, struct expression *exp,
+ enum noside noside,
+ struct value *arg1, const char *string)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ struct value *arg3 = value_struct_elt (&arg1, NULL, string,
+ NULL, "structure");
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
+ return arg3;
+}
- case OP_OBJC_NSSTRING: /* Objective C Foundation Class
- NSString constant. */
- tem = longest_to_int (exp->elts[pc + 1].longconst);
- (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1);
+/* A helper function for STRUCTOP_PTR. */
- case OP_ARRAY:
- (*pos) += 3;
- tem2 = longest_to_int (exp->elts[pc + 1].longconst);
- tem3 = longest_to_int (exp->elts[pc + 2].longconst);
- nargs = tem3 - tem2 + 1;
- type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
+struct value *
+eval_op_structop_ptr (struct type *expect_type, struct expression *exp,
+ enum noside noside,
+ struct value *arg1, const char *string)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
- if (expect_type != NULL_TYPE && noside != EVAL_SKIP
- && type->code () == TYPE_CODE_STRUCT)
+ /* Check to see if operator '->' has been overloaded. If so replace
+ arg1 with the value returned by evaluating operator->(). */
+ while (unop_user_defined_p (STRUCTOP_PTR, arg1))
+ {
+ struct value *value = NULL;
+ try
{
- struct value *rec = allocate_value (expect_type);
-
- memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
- return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
+ value = value_x_unop (arg1, STRUCTOP_PTR, noside);
}
- if (expect_type != NULL_TYPE && noside != EVAL_SKIP
- && type->code () == TYPE_CODE_ARRAY)
+ catch (const gdb_exception_error &except)
{
- struct type *range_type = type->index_type ();
- struct type *element_type = TYPE_TARGET_TYPE (type);
- struct value *array = allocate_value (expect_type);
- int element_size = TYPE_LENGTH (check_typedef (element_type));
- LONGEST low_bound, high_bound, index;
+ if (except.error == NOT_FOUND_ERROR)
+ break;
+ else
+ throw;
+ }
- if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
- {
- low_bound = 0;
- high_bound = (TYPE_LENGTH (type) / element_size) - 1;
- }
- index = low_bound;
- memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type));
- for (tem = nargs; --nargs >= 0;)
- {
- struct value *element;
- int index_pc = 0;
+ arg1 = value;
+ }
- element = evaluate_subexp (element_type, exp, pos, noside);
- if (value_type (element) != element_type)
- element = value_cast (element_type, element);
- if (index_pc)
- {
- int continue_pc = *pos;
+ /* JYG: if print object is on we need to replace the base type
+ with rtti type in order to continue on with successful
+ lookup of member / method only available in the rtti type. */
+ {
+ struct type *arg_type = value_type (arg1);
+ struct type *real_type;
+ int full, using_enc;
+ LONGEST top;
+ struct value_print_options opts;
+
+ get_user_print_options (&opts);
+ if (opts.objectprint && TYPE_TARGET_TYPE (arg_type)
+ && (TYPE_TARGET_TYPE (arg_type)->code () == TYPE_CODE_STRUCT))
+ {
+ real_type = value_rtti_indirect_type (arg1, &full, &top,
+ &using_enc);
+ if (real_type)
+ arg1 = value_cast (real_type, arg1);
+ }
+ }
- *pos = index_pc;
- index = init_array_element (array, element, exp, pos, noside,
- low_bound, high_bound);
- *pos = continue_pc;
- }
- else
- {
- if (index > high_bound)
- /* To avoid memory corruption. */
- error (_("Too many array elements"));
- memcpy (value_contents_raw (array)
- + (index - low_bound) * element_size,
- value_contents (element),
- element_size);
- }
- index++;
- }
- return array;
+ struct value *arg3 = value_struct_elt (&arg1, NULL, string,
+ NULL, "structure pointer");
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
+ return arg3;
+}
+
+/* A helper function for STRUCTOP_MEMBER. */
+
+struct value *
+eval_op_member (struct type *expect_type, struct expression *exp,
+ enum noside noside,
+ struct value *arg1, struct value *arg2)
+{
+ long mem_offset;
+
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+
+ struct value *arg3;
+ struct type *type = check_typedef (value_type (arg2));
+ switch (type->code ())
+ {
+ case TYPE_CODE_METHODPTR:
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ return value_zero (TYPE_TARGET_TYPE (type), not_lval);
+ else
+ {
+ arg2 = cplus_method_ptr_to_value (&arg1, arg2);
+ gdb_assert (value_type (arg2)->code () == TYPE_CODE_PTR);
+ return value_ind (arg2);
+ }
+
+ case TYPE_CODE_MEMBERPTR:
+ /* Now, convert these values to an address. */
+ arg1 = value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type)),
+ arg1, 1);
+
+ mem_offset = value_as_long (arg2);
+
+ arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
+ value_as_long (arg1) + mem_offset);
+ return value_ind (arg3);
+
+ default:
+ error (_("non-pointer-to-member value used "
+ "in pointer-to-member construct"));
+ }
+}
+
+/* A helper function for BINOP_ADD. */
+
+struct value *
+eval_op_add (struct type *expect_type, struct expression *exp,
+ enum noside noside,
+ struct value *arg1, struct value *arg2)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (binop_user_defined_p (BINOP_ADD, arg1, arg2))
+ return value_x_binop (arg1, arg2, BINOP_ADD, OP_NULL, noside);
+ else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
+ && is_integral_or_integral_reference (value_type (arg2)))
+ return value_ptradd (arg1, value_as_long (arg2));
+ else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
+ && is_integral_or_integral_reference (value_type (arg1)))
+ return value_ptradd (arg2, value_as_long (arg1));
+ else
+ {
+ binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
+ return value_binop (arg1, arg2, BINOP_ADD);
+ }
+}
+
+/* A helper function for BINOP_SUB. */
+
+struct value *
+eval_op_sub (struct type *expect_type, struct expression *exp,
+ enum noside noside,
+ struct value *arg1, struct value *arg2)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (binop_user_defined_p (BINOP_SUB, arg1, arg2))
+ return value_x_binop (arg1, arg2, BINOP_SUB, OP_NULL, noside);
+ else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
+ && ptrmath_type_p (exp->language_defn, value_type (arg2)))
+ {
+ /* FIXME -- should be ptrdiff_t */
+ struct type *type = builtin_type (exp->gdbarch)->builtin_long;
+ return value_from_longest (type, value_ptrdiff (arg1, arg2));
+ }
+ else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
+ && is_integral_or_integral_reference (value_type (arg2)))
+ return value_ptradd (arg1, - value_as_long (arg2));
+ else
+ {
+ binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
+ return value_binop (arg1, arg2, BINOP_SUB);
+ }
+}
+
+/* Helper function for several different binary operations. */
+
+struct value *
+eval_op_binary (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1, struct value *arg2)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (binop_user_defined_p (op, arg1, arg2))
+ return value_x_binop (arg1, arg2, op, OP_NULL, noside);
+ else
+ {
+ /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
+ fudge arg2 to avoid division-by-zero, the caller is
+ (theoretically) only looking for the type of the result. */
+ if (noside == EVAL_AVOID_SIDE_EFFECTS
+ /* ??? Do we really want to test for BINOP_MOD here?
+ The implementation of value_binop gives it a well-defined
+ value. */
+ && (op == BINOP_DIV
+ || op == BINOP_INTDIV
+ || op == BINOP_REM
+ || op == BINOP_MOD)
+ && value_logical_not (arg2))
+ {
+ struct value *v_one;
+
+ v_one = value_one (value_type (arg2));
+ binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
+ return value_binop (arg1, v_one, op);
+ }
+ else
+ {
+ /* For shift and integer exponentiation operations,
+ only promote the first argument. */
+ if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
+ && is_integral_type (value_type (arg2)))
+ unop_promote (exp->language_defn, exp->gdbarch, &arg1);
+ else
+ binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
+
+ return value_binop (arg1, arg2, op);
+ }
+ }
+}
+
+/* A helper function for BINOP_SUBSCRIPT. */
+
+static struct value *
+eval_op_subscript (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1, struct value *arg2)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (binop_user_defined_p (op, arg1, arg2))
+ return value_x_binop (arg1, arg2, op, OP_NULL, noside);
+ else
+ {
+ /* If the user attempts to subscript something that is not an
+ array or pointer type (like a plain int variable for example),
+ then report this as an error. */
+
+ arg1 = coerce_ref (arg1);
+ struct type *type = check_typedef (value_type (arg1));
+ if (type->code () != TYPE_CODE_ARRAY
+ && type->code () != TYPE_CODE_PTR)
+ {
+ if (type->name ())
+ error (_("cannot subscript something of type `%s'"),
+ type->name ());
+ else
+ error (_("cannot subscript requested type"));
+ }
+
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
+ else
+ return value_subscript (arg1, value_as_long (arg2));
+ }
+}
+
+/* A helper function for BINOP_EQUAL. */
+
+static struct value *
+eval_op_equal (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1, struct value *arg2)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (binop_user_defined_p (op, arg1, arg2))
+ {
+ return value_x_binop (arg1, arg2, op, OP_NULL, noside);
+ }
+ else
+ {
+ binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
+ int tem = value_equal (arg1, arg2);
+ struct type *type = language_bool_type (exp->language_defn,
+ exp->gdbarch);
+ return value_from_longest (type, (LONGEST) tem);
+ }
+}
+
+/* A helper function for BINOP_NOTEQUAL. */
+
+static struct value *
+eval_op_notequal (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1, struct value *arg2)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (binop_user_defined_p (op, arg1, arg2))
+ {
+ return value_x_binop (arg1, arg2, op, OP_NULL, noside);
+ }
+ else
+ {
+ binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
+ int tem = value_equal (arg1, arg2);
+ struct type *type = language_bool_type (exp->language_defn,
+ exp->gdbarch);
+ return value_from_longest (type, (LONGEST) ! tem);
+ }
+}
+
+/* A helper function for BINOP_LESS. */
+
+static struct value *
+eval_op_less (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1, struct value *arg2)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (binop_user_defined_p (op, arg1, arg2))
+ {
+ return value_x_binop (arg1, arg2, op, OP_NULL, noside);
+ }
+ else
+ {
+ binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
+ int tem = value_less (arg1, arg2);
+ struct type *type = language_bool_type (exp->language_defn,
+ exp->gdbarch);
+ return value_from_longest (type, (LONGEST) tem);
+ }
+}
+
+/* A helper function for BINOP_GTR. */
+
+static struct value *
+eval_op_gtr (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1, struct value *arg2)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (binop_user_defined_p (op, arg1, arg2))
+ {
+ return value_x_binop (arg1, arg2, op, OP_NULL, noside);
+ }
+ else
+ {
+ binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
+ int tem = value_less (arg2, arg1);
+ struct type *type = language_bool_type (exp->language_defn,
+ exp->gdbarch);
+ return value_from_longest (type, (LONGEST) tem);
+ }
+}
+
+/* A helper function for BINOP_GEQ. */
+
+static struct value *
+eval_op_geq (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1, struct value *arg2)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (binop_user_defined_p (op, arg1, arg2))
+ {
+ return value_x_binop (arg1, arg2, op, OP_NULL, noside);
+ }
+ else
+ {
+ binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
+ int tem = value_less (arg2, arg1) || value_equal (arg1, arg2);
+ struct type *type = language_bool_type (exp->language_defn,
+ exp->gdbarch);
+ return value_from_longest (type, (LONGEST) tem);
+ }
+}
+
+/* A helper function for BINOP_LEQ. */
+
+static struct value *
+eval_op_leq (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1, struct value *arg2)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (binop_user_defined_p (op, arg1, arg2))
+ {
+ return value_x_binop (arg1, arg2, op, OP_NULL, noside);
+ }
+ else
+ {
+ binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
+ int tem = value_less (arg1, arg2) || value_equal (arg1, arg2);
+ struct type *type = language_bool_type (exp->language_defn,
+ exp->gdbarch);
+ return value_from_longest (type, (LONGEST) tem);
+ }
+}
+
+/* A helper function for BINOP_REPEAT. */
+
+static struct value *
+eval_op_repeat (struct type *expect_type, struct expression *exp,
+ enum noside noside,
+ struct value *arg1, struct value *arg2)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ struct type *type = check_typedef (value_type (arg2));
+ if (type->code () != TYPE_CODE_INT
+ && type->code () != TYPE_CODE_ENUM)
+ error (_("Non-integral right operand for \"@\" operator."));
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ {
+ return allocate_repeat_value (value_type (arg1),
+ longest_to_int (value_as_long (arg2)));
+ }
+ else
+ return value_repeat (arg1, longest_to_int (value_as_long (arg2)));
+}
+
+/* A helper function for UNOP_PLUS. */
+
+static struct value *
+eval_op_plus (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (unop_user_defined_p (op, arg1))
+ return value_x_unop (arg1, op, noside);
+ else
+ {
+ unop_promote (exp->language_defn, exp->gdbarch, &arg1);
+ return value_pos (arg1);
+ }
+}
+
+/* A helper function for UNOP_NEG. */
+
+static struct value *
+eval_op_neg (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (unop_user_defined_p (op, arg1))
+ return value_x_unop (arg1, op, noside);
+ else
+ {
+ unop_promote (exp->language_defn, exp->gdbarch, &arg1);
+ return value_neg (arg1);
+ }
+}
+
+/* A helper function for UNOP_COMPLEMENT. */
+
+static struct value *
+eval_op_complement (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
+ return value_x_unop (arg1, UNOP_COMPLEMENT, noside);
+ else
+ {
+ unop_promote (exp->language_defn, exp->gdbarch, &arg1);
+ return value_complement (arg1);
+ }
+}
+
+/* A helper function for UNOP_LOGICAL_NOT. */
+
+static struct value *
+eval_op_lognot (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (unop_user_defined_p (op, arg1))
+ return value_x_unop (arg1, op, noside);
+ else
+ {
+ struct type *type = language_bool_type (exp->language_defn,
+ exp->gdbarch);
+ return value_from_longest (type, (LONGEST) value_logical_not (arg1));
+ }
+}
+
+/* A helper function for UNOP_IND. */
+
+static struct value *
+eval_op_ind (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1)
+{
+ struct type *type = check_typedef (value_type (arg1));
+ if (type->code () == TYPE_CODE_METHODPTR
+ || type->code () == TYPE_CODE_MEMBERPTR)
+ error (_("Attempt to dereference pointer "
+ "to member without an object"));
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (unop_user_defined_p (op, arg1))
+ return value_x_unop (arg1, op, noside);
+ else if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ {
+ type = check_typedef (value_type (arg1));
+
+ /* If the type pointed to is dynamic then in order to resolve the
+ dynamic properties we must actually dereference the pointer.
+ There is a risk that this dereference will have side-effects
+ in the inferior, but being able to print accurate type
+ information seems worth the risk. */
+ if ((type->code () != TYPE_CODE_PTR
+ && !TYPE_IS_REFERENCE (type))
+ || !is_dynamic_type (TYPE_TARGET_TYPE (type)))
+ {
+ if (type->code () == TYPE_CODE_PTR
+ || TYPE_IS_REFERENCE (type)
+ /* In C you can dereference an array to get the 1st elt. */
+ || type->code () == TYPE_CODE_ARRAY)
+ return value_zero (TYPE_TARGET_TYPE (type),
+ lval_memory);
+ else if (type->code () == TYPE_CODE_INT)
+ /* GDB allows dereferencing an int. */
+ return value_zero (builtin_type (exp->gdbarch)->builtin_int,
+ lval_memory);
+ else
+ error (_("Attempt to take contents of a non-pointer value."));
+ }
+ }
+
+ /* Allow * on an integer so we can cast it to whatever we want.
+ This returns an int, which seems like the most C-like thing to
+ do. "long long" variables are rare enough that
+ BUILTIN_TYPE_LONGEST would seem to be a mistake. */
+ if (type->code () == TYPE_CODE_INT)
+ return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
+ (CORE_ADDR) value_as_address (arg1));
+ return value_ind (arg1);
+}
+
+/* A helper function for UNOP_ALIGNOF. */
+
+static struct value *
+eval_op_alignof (struct type *expect_type, struct expression *exp,
+ enum noside noside,
+ struct value *arg1)
+{
+ struct type *type = value_type (arg1);
+ /* FIXME: This should be size_t. */
+ struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
+ ULONGEST align = type_align (type);
+ if (align == 0)
+ error (_("could not determine alignment of type"));
+ return value_from_longest (size_type, align);
+}
+
+/* A helper function for UNOP_MEMVAL. */
+
+static struct value *
+eval_op_memval (struct type *expect_type, struct expression *exp,
+ enum noside noside,
+ struct value *arg1, struct type *type)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ return value_zero (type, lval_memory);
+ else
+ return value_at_lazy (type, value_as_address (arg1));
+}
+
+/* A helper function for UNOP_PREINCREMENT. */
+
+static struct value *
+eval_op_preinc (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1)
+{
+ if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
+ return arg1;
+ else if (unop_user_defined_p (op, arg1))
+ {
+ return value_x_unop (arg1, op, noside);
+ }
+ else
+ {
+ struct value *arg2;
+ if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
+ arg2 = value_ptradd (arg1, 1);
+ else
+ {
+ struct value *tmp = arg1;
+
+ arg2 = value_one (value_type (arg1));
+ binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
+ arg2 = value_binop (tmp, arg2, BINOP_ADD);
+ }
+
+ return value_assign (arg1, arg2);
+ }
+}
+
+/* A helper function for UNOP_PREDECREMENT. */
+
+static struct value *
+eval_op_predec (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1)
+{
+ if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
+ return arg1;
+ else if (unop_user_defined_p (op, arg1))
+ {
+ return value_x_unop (arg1, op, noside);
+ }
+ else
+ {
+ struct value *arg2;
+ if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
+ arg2 = value_ptradd (arg1, -1);
+ else
+ {
+ struct value *tmp = arg1;
+
+ arg2 = value_one (value_type (arg1));
+ binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
+ arg2 = value_binop (tmp, arg2, BINOP_SUB);
+ }
+
+ return value_assign (arg1, arg2);
+ }
+}
+
+/* A helper function for UNOP_POSTINCREMENT. */
+
+static struct value *
+eval_op_postinc (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1)
+{
+ if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
+ return arg1;
+ else if (unop_user_defined_p (op, arg1))
+ {
+ return value_x_unop (arg1, op, noside);
+ }
+ else
+ {
+ struct value *arg3 = value_non_lval (arg1);
+ struct value *arg2;
+
+ if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
+ arg2 = value_ptradd (arg1, 1);
+ else
+ {
+ struct value *tmp = arg1;
+
+ arg2 = value_one (value_type (arg1));
+ binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
+ arg2 = value_binop (tmp, arg2, BINOP_ADD);
+ }
+
+ value_assign (arg1, arg2);
+ return arg3;
+ }
+}
+
+/* A helper function for UNOP_POSTDECREMENT. */
+
+static struct value *
+eval_op_postdec (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1)
+{
+ if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
+ return arg1;
+ else if (unop_user_defined_p (op, arg1))
+ {
+ return value_x_unop (arg1, op, noside);
+ }
+ else
+ {
+ struct value *arg3 = value_non_lval (arg1);
+ struct value *arg2;
+
+ if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
+ arg2 = value_ptradd (arg1, -1);
+ else
+ {
+ struct value *tmp = arg1;
+
+ arg2 = value_one (value_type (arg1));
+ binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
+ arg2 = value_binop (tmp, arg2, BINOP_SUB);
+ }
+
+ value_assign (arg1, arg2);
+ return arg3;
+ }
+}
+
+/* A helper function for OP_TYPE. */
+
+static struct value *
+eval_op_type (struct type *expect_type, struct expression *exp,
+ enum noside noside, struct type *type)
+{
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ else if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ return allocate_value (type);
+ else
+ error (_("Attempt to use a type name as an expression"));
+}
+
+/* A helper function for BINOP_ASSIGN_MODIFY. */
+
+static struct value *
+eval_binop_assign_modify (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum exp_opcode op,
+ struct value *arg1, struct value *arg2)
+{
+ if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
+ return arg1;
+ if (binop_user_defined_p (op, arg1, arg2))
+ return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
+ else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn,
+ value_type (arg1))
+ && is_integral_type (value_type (arg2)))
+ arg2 = value_ptradd (arg1, value_as_long (arg2));
+ else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn,
+ value_type (arg1))
+ && is_integral_type (value_type (arg2)))
+ arg2 = value_ptradd (arg1, - value_as_long (arg2));
+ else
+ {
+ struct value *tmp = arg1;
+
+ /* For shift and integer exponentiation operations,
+ only promote the first argument. */
+ if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
+ && is_integral_type (value_type (arg2)))
+ unop_promote (exp->language_defn, exp->gdbarch, &tmp);
+ else
+ binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
+
+ arg2 = value_binop (tmp, arg2, op);
+ }
+ return value_assign (arg1, arg2);
+}
+
+/* Note that ARGS needs 2 empty slots up front and must end with a
+ null pointer. */
+static struct value *
+eval_op_objc_msgcall (struct type *expect_type, struct expression *exp,
+ enum noside noside, CORE_ADDR selector,
+ value *target, gdb::array_view<value *> args)
+{
+ CORE_ADDR responds_selector = 0;
+ CORE_ADDR method_selector = 0;
+
+ int struct_return = 0;
+
+ struct value *msg_send = NULL;
+ struct value *msg_send_stret = NULL;
+ int gnu_runtime = 0;
+
+ struct value *method = NULL;
+ struct value *called_method = NULL;
+
+ struct type *selector_type = NULL;
+ struct type *long_type;
+ struct type *type;
+
+ struct value *ret = NULL;
+ CORE_ADDR addr = 0;
+
+ value *argvec[5];
+
+ long_type = builtin_type (exp->gdbarch)->builtin_long;
+ selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
+
+ if (value_as_long (target) == 0)
+ return value_from_longest (long_type, 0);
+
+ if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym)
+ gnu_runtime = 1;
+
+ /* Find the method dispatch (Apple runtime) or method lookup
+ (GNU runtime) function for Objective-C. These will be used
+ to lookup the symbol information for the method. If we
+ can't find any symbol information, then we'll use these to
+ call the method, otherwise we can call the method
+ directly. The msg_send_stret function is used in the special
+ case of a method that returns a structure (Apple runtime
+ only). */
+ if (gnu_runtime)
+ {
+ type = selector_type;
+
+ type = lookup_function_type (type);
+ type = lookup_pointer_type (type);
+ type = lookup_function_type (type);
+ type = lookup_pointer_type (type);
+
+ msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
+ msg_send_stret
+ = find_function_in_inferior ("objc_msg_lookup", NULL);
+
+ msg_send = value_from_pointer (type, value_as_address (msg_send));
+ msg_send_stret = value_from_pointer (type,
+ value_as_address (msg_send_stret));
+ }
+ else
+ {
+ msg_send = find_function_in_inferior ("objc_msgSend", NULL);
+ /* Special dispatcher for methods returning structs. */
+ msg_send_stret
+ = find_function_in_inferior ("objc_msgSend_stret", NULL);
+ }
+
+ /* Verify the target object responds to this method. The
+ standard top-level 'Object' class uses a different name for
+ the verification method than the non-standard, but more
+ often used, 'NSObject' class. Make sure we check for both. */
+
+ responds_selector
+ = lookup_child_selector (exp->gdbarch, "respondsToSelector:");
+ if (responds_selector == 0)
+ responds_selector
+ = lookup_child_selector (exp->gdbarch, "respondsTo:");
+
+ if (responds_selector == 0)
+ error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
+
+ method_selector
+ = lookup_child_selector (exp->gdbarch, "methodForSelector:");
+ if (method_selector == 0)
+ method_selector
+ = lookup_child_selector (exp->gdbarch, "methodFor:");
+
+ if (method_selector == 0)
+ error (_("no 'methodFor:' or 'methodForSelector:' method"));
+
+ /* Call the verification method, to make sure that the target
+ class implements the desired method. */
+
+ argvec[0] = msg_send;
+ argvec[1] = target;
+ argvec[2] = value_from_longest (long_type, responds_selector);
+ argvec[3] = value_from_longest (long_type, selector);
+ argvec[4] = 0;
+
+ ret = call_function_by_hand (argvec[0], NULL, {argvec + 1, 3});
+ if (gnu_runtime)
+ {
+ /* Function objc_msg_lookup returns a pointer. */
+ argvec[0] = ret;
+ ret = call_function_by_hand (argvec[0], NULL, {argvec + 1, 3});
+ }
+ if (value_as_long (ret) == 0)
+ error (_("Target does not respond to this message selector."));
+
+ /* Call "methodForSelector:" method, to get the address of a
+ function method that implements this selector for this
+ class. If we can find a symbol at that address, then we
+ know the return type, parameter types etc. (that's a good
+ thing). */
+
+ argvec[0] = msg_send;
+ argvec[1] = target;
+ argvec[2] = value_from_longest (long_type, method_selector);
+ argvec[3] = value_from_longest (long_type, selector);
+ argvec[4] = 0;
+
+ ret = call_function_by_hand (argvec[0], NULL, {argvec + 1, 3});
+ if (gnu_runtime)
+ {
+ argvec[0] = ret;
+ ret = call_function_by_hand (argvec[0], NULL, {argvec + 1, 3});
+ }
+
+ /* ret should now be the selector. */
+
+ addr = value_as_long (ret);
+ if (addr)
+ {
+ struct symbol *sym = NULL;
+
+ /* The address might point to a function descriptor;
+ resolve it to the actual code address instead. */
+ addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr,
+ current_top_target ());
+
+ /* Is it a high_level symbol? */
+ sym = find_pc_function (addr);
+ if (sym != NULL)
+ method = value_of_variable (sym, 0);
+ }
+
+ /* If we found a method with symbol information, check to see
+ if it returns a struct. Otherwise assume it doesn't. */
+
+ if (method)
+ {
+ CORE_ADDR funaddr;
+ struct type *val_type;
+
+ funaddr = find_function_addr (method, &val_type);
+
+ block_for_pc (funaddr);
+
+ val_type = check_typedef (val_type);
+
+ if ((val_type == NULL)
+ || (val_type->code () == TYPE_CODE_ERROR))
+ {
+ if (expect_type != NULL)
+ val_type = expect_type;
+ }
+
+ struct_return = using_struct_return (exp->gdbarch, method,
+ val_type);
+ }
+ else if (expect_type != NULL)
+ {
+ struct_return = using_struct_return (exp->gdbarch, NULL,
+ check_typedef (expect_type));
+ }
+
+ /* Found a function symbol. Now we will substitute its
+ value in place of the message dispatcher (obj_msgSend),
+ so that we call the method directly instead of thru
+ the dispatcher. The main reason for doing this is that
+ we can now evaluate the return value and parameter values
+ according to their known data types, in case we need to
+ do things like promotion, dereferencing, special handling
+ of structs and doubles, etc.
+
+ We want to use the type signature of 'method', but still
+ jump to objc_msgSend() or objc_msgSend_stret() to better
+ mimic the behavior of the runtime. */
+
+ if (method)
+ {
+ if (value_type (method)->code () != TYPE_CODE_FUNC)
+ error (_("method address has symbol information "
+ "with non-function type; skipping"));
+
+ /* Create a function pointer of the appropriate type, and
+ replace its value with the value of msg_send or
+ msg_send_stret. We must use a pointer here, as
+ msg_send and msg_send_stret are of pointer type, and
+ the representation may be different on systems that use
+ function descriptors. */
+ if (struct_return)
+ called_method
+ = value_from_pointer (lookup_pointer_type (value_type (method)),
+ value_as_address (msg_send_stret));
+ else
+ called_method
+ = value_from_pointer (lookup_pointer_type (value_type (method)),
+ value_as_address (msg_send));
+ }
+ else
+ {
+ if (struct_return)
+ called_method = msg_send_stret;
+ else
+ called_method = msg_send;
+ }
+
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ {
+ /* If the return type doesn't look like a function type,
+ call an error. This can happen if somebody tries to
+ turn a variable into a function call. This is here
+ because people often want to call, eg, strcmp, which
+ gdb doesn't know is a function. If gdb isn't asked for
+ it's opinion (ie. through "whatis"), it won't offer
+ it. */
+
+ struct type *callee_type = value_type (called_method);
+
+ if (callee_type && callee_type->code () == TYPE_CODE_PTR)
+ callee_type = TYPE_TARGET_TYPE (callee_type);
+ callee_type = TYPE_TARGET_TYPE (callee_type);
+
+ if (callee_type)
+ {
+ if ((callee_type->code () == TYPE_CODE_ERROR) && expect_type)
+ return allocate_value (expect_type);
+ else
+ return allocate_value (callee_type);
+ }
+ else
+ error (_("Expression of type other than "
+ "\"method returning ...\" used as a method"));
+ }
+
+ /* Now depending on whether we found a symbol for the method,
+ we will either call the runtime dispatcher or the method
+ directly. */
+
+ args[0] = target;
+ args[1] = value_from_longest (long_type, selector);
+
+ if (gnu_runtime && (method != NULL))
+ {
+ /* Function objc_msg_lookup returns a pointer. */
+ struct type *tem_type = value_type (called_method);
+ tem_type = lookup_pointer_type (lookup_function_type (tem_type));
+ deprecated_set_value_type (called_method, tem_type);
+ called_method = call_function_by_hand (called_method, NULL, args);
+ }
+
+ return call_function_by_hand (called_method, NULL, args);
+}
+
+/* Helper function for MULTI_SUBSCRIPT. */
+
+static struct value *
+eval_multi_subscript (struct type *expect_type, struct expression *exp,
+ enum noside noside, value *arg1,
+ gdb::array_view<value *> args)
+{
+ if (noside == EVAL_SKIP)
+ return arg1;
+ for (value *arg2 : args)
+ {
+ if (binop_user_defined_p (MULTI_SUBSCRIPT, arg1, arg2))
+ {
+ arg1 = value_x_binop (arg1, arg2, MULTI_SUBSCRIPT, OP_NULL, noside);
+ }
+ else
+ {
+ arg1 = coerce_ref (arg1);
+ struct type *type = check_typedef (value_type (arg1));
+
+ switch (type->code ())
+ {
+ case TYPE_CODE_PTR:
+ case TYPE_CODE_ARRAY:
+ case TYPE_CODE_STRING:
+ arg1 = value_subscript (arg1, value_as_long (arg2));
+ break;
+
+ default:
+ if (type->name ())
+ error (_("cannot subscript something of type `%s'"),
+ type->name ());
+ else
+ error (_("cannot subscript requested type"));
+ }
+ }
+ }
+ return (arg1);
+}
+
+struct value *
+evaluate_subexp_standard (struct type *expect_type,
+ struct expression *exp, int *pos,
+ enum noside noside)
+{
+ enum exp_opcode op;
+ int tem, tem2, tem3;
+ int pc, oldpos;
+ struct value *arg1 = NULL;
+ struct value *arg2 = NULL;
+ struct type *type;
+ int nargs;
+ struct value **argvec;
+ int ix;
+ struct type **arg_types;
+
+ pc = (*pos)++;
+ op = exp->elts[pc].opcode;
+
+ switch (op)
+ {
+ case OP_SCOPE:
+ tem = longest_to_int (exp->elts[pc + 2].longconst);
+ (*pos) += 4 + BYTES_TO_EXP_ELEM (tem + 1);
+ return eval_op_scope (expect_type, exp, noside,
+ exp->elts[pc + 1].type,
+ &exp->elts[pc + 3].string);
+
+ case OP_LONG:
+ (*pos) += 3;
+ return value_from_longest (exp->elts[pc + 1].type,
+ exp->elts[pc + 2].longconst);
+
+ case OP_FLOAT:
+ (*pos) += 3;
+ return value_from_contents (exp->elts[pc + 1].type,
+ exp->elts[pc + 2].floatconst);
+
+ case OP_ADL_FUNC:
+ case OP_VAR_VALUE:
+ {
+ (*pos) += 3;
+ symbol *var = exp->elts[pc + 2].symbol;
+ if (SYMBOL_TYPE (var)->code () == TYPE_CODE_ERROR)
+ error_unknown_type (var->print_name ());
+ if (noside != EVAL_SKIP)
+ return evaluate_var_value (noside, exp->elts[pc + 1].block, var);
+ else
+ {
+ /* Return a dummy value of the correct type when skipping, so
+ that parent functions know what is to be skipped. */
+ return allocate_value (SYMBOL_TYPE (var));
+ }
+ }
+
+ case OP_VAR_MSYM_VALUE:
+ {
+ (*pos) += 3;
+
+ minimal_symbol *msymbol = exp->elts[pc + 2].msymbol;
+ return eval_op_var_msym_value (expect_type, exp, noside,
+ pc == 0, msymbol,
+ exp->elts[pc + 1].objfile);
+ }
+
+ case OP_VAR_ENTRY_VALUE:
+ (*pos) += 2;
+
+ {
+ struct symbol *sym = exp->elts[pc + 1].symbol;
+
+ return eval_op_var_entry_value (expect_type, exp, noside, sym);
+ }
+
+ case OP_FUNC_STATIC_VAR:
+ tem = longest_to_int (exp->elts[pc + 1].longconst);
+ (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+
+ {
+ value *func = evaluate_subexp_standard (NULL, exp, pos, noside);
+
+ return eval_op_func_static_var (expect_type, exp, noside, func,
+ &exp->elts[pc + 2].string);
+ }
+
+ case OP_LAST:
+ (*pos) += 2;
+ return
+ access_value_history (longest_to_int (exp->elts[pc + 1].longconst));
+
+ case OP_REGISTER:
+ {
+ const char *name = &exp->elts[pc + 2].string;
+
+ (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
+ return eval_op_register (expect_type, exp, noside, name);
+ }
+ case OP_BOOL:
+ (*pos) += 2;
+ type = language_bool_type (exp->language_defn, exp->gdbarch);
+ return value_from_longest (type, exp->elts[pc + 1].longconst);
+
+ case OP_INTERNALVAR:
+ (*pos) += 2;
+ return value_of_internalvar (exp->gdbarch,
+ exp->elts[pc + 1].internalvar);
+
+ case OP_STRING:
+ tem = longest_to_int (exp->elts[pc + 1].longconst);
+ (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
+ return eval_op_string (expect_type, exp, noside, tem,
+ &exp->elts[pc + 2].string);
+
+ case OP_OBJC_NSSTRING: /* Objective C Foundation Class
+ NSString constant. */
+ tem = longest_to_int (exp->elts[pc + 1].longconst);
+ (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1);
+
+ case OP_ARRAY:
+ (*pos) += 3;
+ tem2 = longest_to_int (exp->elts[pc + 1].longconst);
+ tem3 = longest_to_int (exp->elts[pc + 2].longconst);
+ nargs = tem3 - tem2 + 1;
+ type = expect_type ? check_typedef (expect_type) : nullptr;
+
+ if (expect_type != nullptr && noside != EVAL_SKIP
+ && type->code () == TYPE_CODE_STRUCT)
+ {
+ struct value *rec = allocate_value (expect_type);
+
+ memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
+ return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
+ }
+
+ if (expect_type != nullptr && noside != EVAL_SKIP
+ && type->code () == TYPE_CODE_ARRAY)
+ {
+ struct type *range_type = type->index_type ();
+ struct type *element_type = TYPE_TARGET_TYPE (type);
+ struct value *array = allocate_value (expect_type);
+ int element_size = TYPE_LENGTH (check_typedef (element_type));
+ LONGEST low_bound, high_bound, index;
+
+ if (!get_discrete_bounds (range_type, &low_bound, &high_bound))
+ {
+ low_bound = 0;
+ high_bound = (TYPE_LENGTH (type) / element_size) - 1;
+ }
+ index = low_bound;
+ memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type));
+ for (tem = nargs; --nargs >= 0;)
+ {
+ struct value *element;
+
+ element = evaluate_subexp (element_type, exp, pos, noside);
+ if (value_type (element) != element_type)
+ element = value_cast (element_type, element);
+ if (index > high_bound)
+ /* To avoid memory corruption. */
+ error (_("Too many array elements"));
+ memcpy (value_contents_raw (array)
+ + (index - low_bound) * element_size,
+ value_contents (element),
+ element_size);
+ index++;
+ }
+ return array;
}
- if (expect_type != NULL_TYPE && noside != EVAL_SKIP
+ if (expect_type != nullptr && noside != EVAL_SKIP
&& type->code () == TYPE_CODE_SET)
{
struct value *set = allocate_value (expect_type);
|| check_type->code () == TYPE_CODE_TYPEDEF)
check_type = TYPE_TARGET_TYPE (check_type);
- if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
+ if (!get_discrete_bounds (element_type, &low_bound, &high_bound))
error (_("(power)set type with unknown size"));
memset (valaddr, '\0', TYPE_LENGTH (type));
for (tem = 0; tem < nargs; tem++)
range_low = range_high = value_as_long (elem_val);
/* Check types of elements to avoid mixture of elements from
- different types. Also check if type of element is "compatible"
- with element type of powerset. */
+ different types. Also check if type of element is "compatible"
+ with element type of powerset. */
if (range_low_type->code () == TYPE_CODE_RANGE)
range_low_type = TYPE_TARGET_TYPE (range_low_type);
if (range_high_type->code () == TYPE_CODE_RANGE)
case TERNOP_SLICE:
{
- struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- int lowbound
- = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
- int upper
- = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
-
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- return value_slice (array, lowbound, upper - lowbound + 1);
+ struct value *array = evaluate_subexp (nullptr, exp, pos, noside);
+ struct value *low = evaluate_subexp (nullptr, exp, pos, noside);
+ struct value *upper = evaluate_subexp (nullptr, exp, pos, noside);
+ return eval_op_ternop (expect_type, exp, noside, array, low, upper);
}
case TERNOP_COND:
/* Skip third and second args to evaluate the first one. */
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
if (value_logical_not (arg1))
{
- evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
- return evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ evaluate_subexp (nullptr, exp, pos, EVAL_SKIP);
+ return evaluate_subexp (nullptr, exp, pos, noside);
}
else
{
- arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
+ arg2 = evaluate_subexp (nullptr, exp, pos, noside);
+ evaluate_subexp (nullptr, exp, pos, EVAL_SKIP);
return arg2;
}
{ /* Objective C @selector operator. */
char *sel = &exp->elts[pc + 2].string;
int len = longest_to_int (exp->elts[pc + 1].longconst);
- struct type *selector_type;
(*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
-
if (sel[len] != 0)
sel[len] = 0; /* Make sure it's terminated. */
- selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
- return value_from_longest (selector_type,
- lookup_child_selector (exp->gdbarch, sel));
+ return eval_op_objc_selector (expect_type, exp, noside, sel);
}
case OP_OBJC_MSGCALL:
{ /* Objective C message (method) call. */
-
- CORE_ADDR responds_selector = 0;
- CORE_ADDR method_selector = 0;
-
CORE_ADDR selector = 0;
- int struct_return = 0;
enum noside sub_no_side = EVAL_NORMAL;
- struct value *msg_send = NULL;
- struct value *msg_send_stret = NULL;
- int gnu_runtime = 0;
-
struct value *target = NULL;
- struct value *method = NULL;
- struct value *called_method = NULL;
struct type *selector_type = NULL;
- struct type *long_type;
-
- struct value *ret = NULL;
- CORE_ADDR addr = 0;
selector = exp->elts[pc + 1].longconst;
nargs = exp->elts[pc + 2].longconst;
- argvec = XALLOCAVEC (struct value *, nargs + 5);
+ argvec = XALLOCAVEC (struct value *, nargs + 3);
(*pos) += 3;
- long_type = builtin_type (exp->gdbarch)->builtin_long;
selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
if (noside == EVAL_AVOID_SIDE_EFFECTS)
target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
if (value_as_long (target) == 0)
- return value_from_longest (long_type, 0);
-
- if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym)
- gnu_runtime = 1;
-
- /* Find the method dispatch (Apple runtime) or method lookup
- (GNU runtime) function for Objective-C. These will be used
- to lookup the symbol information for the method. If we
- can't find any symbol information, then we'll use these to
- call the method, otherwise we can call the method
- directly. The msg_send_stret function is used in the special
- case of a method that returns a structure (Apple runtime
- only). */
- if (gnu_runtime)
- {
- type = selector_type;
-
- type = lookup_function_type (type);
- type = lookup_pointer_type (type);
- type = lookup_function_type (type);
- type = lookup_pointer_type (type);
-
- msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
- msg_send_stret
- = find_function_in_inferior ("objc_msg_lookup", NULL);
-
- msg_send = value_from_pointer (type, value_as_address (msg_send));
- msg_send_stret = value_from_pointer (type,
- value_as_address (msg_send_stret));
- }
- else
- {
- msg_send = find_function_in_inferior ("objc_msgSend", NULL);
- /* Special dispatcher for methods returning structs. */
- msg_send_stret
- = find_function_in_inferior ("objc_msgSend_stret", NULL);
- }
-
- /* Verify the target object responds to this method. The
- standard top-level 'Object' class uses a different name for
- the verification method than the non-standard, but more
- often used, 'NSObject' class. Make sure we check for both. */
-
- responds_selector
- = lookup_child_selector (exp->gdbarch, "respondsToSelector:");
- if (responds_selector == 0)
- responds_selector
- = lookup_child_selector (exp->gdbarch, "respondsTo:");
-
- if (responds_selector == 0)
- error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
-
- method_selector
- = lookup_child_selector (exp->gdbarch, "methodForSelector:");
- if (method_selector == 0)
- method_selector
- = lookup_child_selector (exp->gdbarch, "methodFor:");
-
- if (method_selector == 0)
- error (_("no 'methodFor:' or 'methodForSelector:' method"));
-
- /* Call the verification method, to make sure that the target
- class implements the desired method. */
-
- argvec[0] = msg_send;
- argvec[1] = target;
- argvec[2] = value_from_longest (long_type, responds_selector);
- argvec[3] = value_from_longest (long_type, selector);
- argvec[4] = 0;
-
- ret = call_function_by_hand (argvec[0], NULL, {argvec + 1, 3});
- if (gnu_runtime)
- {
- /* Function objc_msg_lookup returns a pointer. */
- argvec[0] = ret;
- ret = call_function_by_hand (argvec[0], NULL, {argvec + 1, 3});
- }
- if (value_as_long (ret) == 0)
- error (_("Target does not respond to this message selector."));
-
- /* Call "methodForSelector:" method, to get the address of a
- function method that implements this selector for this
- class. If we can find a symbol at that address, then we
- know the return type, parameter types etc. (that's a good
- thing). */
-
- argvec[0] = msg_send;
- argvec[1] = target;
- argvec[2] = value_from_longest (long_type, method_selector);
- argvec[3] = value_from_longest (long_type, selector);
- argvec[4] = 0;
-
- ret = call_function_by_hand (argvec[0], NULL, {argvec + 1, 3});
- if (gnu_runtime)
- {
- argvec[0] = ret;
- ret = call_function_by_hand (argvec[0], NULL, {argvec + 1, 3});
- }
-
- /* ret should now be the selector. */
-
- addr = value_as_long (ret);
- if (addr)
- {
- struct symbol *sym = NULL;
-
- /* The address might point to a function descriptor;
- resolve it to the actual code address instead. */
- addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr,
- current_top_target ());
-
- /* Is it a high_level symbol? */
- sym = find_pc_function (addr);
- if (sym != NULL)
- method = value_of_variable (sym, 0);
- }
-
- /* If we found a method with symbol information, check to see
- if it returns a struct. Otherwise assume it doesn't. */
-
- if (method)
- {
- CORE_ADDR funaddr;
- struct type *val_type;
-
- funaddr = find_function_addr (method, &val_type);
-
- block_for_pc (funaddr);
-
- val_type = check_typedef (val_type);
-
- if ((val_type == NULL)
- || (val_type->code () == TYPE_CODE_ERROR))
- {
- if (expect_type != NULL)
- val_type = expect_type;
- }
-
- struct_return = using_struct_return (exp->gdbarch, method,
- val_type);
- }
- else if (expect_type != NULL)
- {
- struct_return = using_struct_return (exp->gdbarch, NULL,
- check_typedef (expect_type));
- }
-
- /* Found a function symbol. Now we will substitute its
- value in place of the message dispatcher (obj_msgSend),
- so that we call the method directly instead of thru
- the dispatcher. The main reason for doing this is that
- we can now evaluate the return value and parameter values
- according to their known data types, in case we need to
- do things like promotion, dereferencing, special handling
- of structs and doubles, etc.
-
- We want to use the type signature of 'method', but still
- jump to objc_msgSend() or objc_msgSend_stret() to better
- mimic the behavior of the runtime. */
-
- if (method)
- {
- if (value_type (method)->code () != TYPE_CODE_FUNC)
- error (_("method address has symbol information "
- "with non-function type; skipping"));
-
- /* Create a function pointer of the appropriate type, and
- replace its value with the value of msg_send or
- msg_send_stret. We must use a pointer here, as
- msg_send and msg_send_stret are of pointer type, and
- the representation may be different on systems that use
- function descriptors. */
- if (struct_return)
- called_method
- = value_from_pointer (lookup_pointer_type (value_type (method)),
- value_as_address (msg_send_stret));
- else
- called_method
- = value_from_pointer (lookup_pointer_type (value_type (method)),
- value_as_address (msg_send));
- }
+ sub_no_side = EVAL_SKIP;
else
- {
- if (struct_return)
- called_method = msg_send_stret;
- else
- called_method = msg_send;
- }
-
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
-
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- {
- /* If the return type doesn't look like a function type,
- call an error. This can happen if somebody tries to
- turn a variable into a function call. This is here
- because people often want to call, eg, strcmp, which
- gdb doesn't know is a function. If gdb isn't asked for
- it's opinion (ie. through "whatis"), it won't offer
- it. */
-
- struct type *callee_type = value_type (called_method);
-
- if (callee_type && callee_type->code () == TYPE_CODE_PTR)
- callee_type = TYPE_TARGET_TYPE (callee_type);
- callee_type = TYPE_TARGET_TYPE (callee_type);
-
- if (callee_type)
- {
- if ((callee_type->code () == TYPE_CODE_ERROR) && expect_type)
- return allocate_value (expect_type);
- else
- return allocate_value (callee_type);
- }
- else
- error (_("Expression of type other than "
- "\"method returning ...\" used as a method"));
- }
+ sub_no_side = noside;
/* Now depending on whether we found a symbol for the method,
we will either call the runtime dispatcher or the method
directly. */
- argvec[0] = called_method;
- argvec[1] = target;
- argvec[2] = value_from_longest (long_type, selector);
+ argvec[0] = nullptr;
+ argvec[1] = nullptr;
/* User-supplied arguments. */
- for (tem = 0; tem < nargs; tem++)
- argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
- argvec[tem + 3] = 0;
-
- auto call_args = gdb::make_array_view (argvec + 1, nargs + 2);
-
- if (gnu_runtime && (method != NULL))
- {
- /* Function objc_msg_lookup returns a pointer. */
- deprecated_set_value_type (argvec[0],
- lookup_pointer_type (lookup_function_type (value_type (argvec[0]))));
- argvec[0] = call_function_by_hand (argvec[0], NULL, call_args);
- }
-
- return call_function_by_hand (argvec[0], NULL, call_args);
- }
- break;
-
- case OP_FUNCALL:
- return evaluate_funcall (expect_type, exp, pos, noside);
-
- case OP_F77_UNDETERMINED_ARGLIST:
-
- /* Remember that in F77, functions, substring ops and
- array subscript operations cannot be disambiguated
- at parse time. We have made all array subscript operations,
- substring operations as well as function calls come here
- and we now have to discover what the heck this thing actually was.
- If it is a function, we process just as if we got an OP_FUNCALL. */
-
- nargs = longest_to_int (exp->elts[pc + 1].longconst);
- (*pos) += 2;
-
- /* First determine the type code we are dealing with. */
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- type = check_typedef (value_type (arg1));
- code = type->code ();
-
- if (code == TYPE_CODE_PTR)
- {
- /* Fortran always passes variable to subroutines as pointer.
- So we need to look into its target type to see if it is
- array, string or function. If it is, we need to switch
- to the target value the original one points to. */
- struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
-
- if (target_type->code () == TYPE_CODE_ARRAY
- || target_type->code () == TYPE_CODE_STRING
- || target_type->code () == TYPE_CODE_FUNC)
- {
- arg1 = value_ind (arg1);
- type = check_typedef (value_type (arg1));
- code = type->code ();
- }
- }
-
- switch (code)
- {
- case TYPE_CODE_ARRAY:
- if (exp->elts[*pos].opcode == OP_RANGE)
- return value_f90_subarray (arg1, exp, pos, noside);
- else
- {
- if (noside == EVAL_SKIP)
- {
- skip_undetermined_arglist (nargs, exp, pos, noside);
- /* Return the dummy value with the correct type. */
- return arg1;
- }
- goto multi_f77_subscript;
- }
-
- case TYPE_CODE_STRING:
- if (exp->elts[*pos].opcode == OP_RANGE)
- return value_f90_subarray (arg1, exp, pos, noside);
- else
- {
- if (noside == EVAL_SKIP)
- {
- skip_undetermined_arglist (nargs, exp, pos, noside);
- /* Return the dummy value with the correct type. */
- return arg1;
- }
- arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
- return value_subscript (arg1, value_as_long (arg2));
- }
+ for (tem = 0; tem < nargs; tem++)
+ argvec[tem + 2] = evaluate_subexp_with_coercion (exp, pos,
+ sub_no_side);
+ argvec[tem + 3] = 0;
- case TYPE_CODE_PTR:
- case TYPE_CODE_FUNC:
- case TYPE_CODE_INTERNAL_FUNCTION:
- /* It's a function call. */
- /* Allocate arg vector, including space for the function to be
- called in argvec[0] and a terminating NULL. */
- argvec = (struct value **)
- alloca (sizeof (struct value *) * (nargs + 2));
- argvec[0] = arg1;
- tem = 1;
- for (; tem <= nargs; tem++)
- {
- argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
- /* Arguments in Fortran are passed by address. Coerce the
- arguments here rather than in value_arg_coerce as otherwise
- the call to malloc to place the non-lvalue parameters in
- target memory is hit by this Fortran specific logic. This
- results in malloc being called with a pointer to an integer
- followed by an attempt to malloc the arguments to malloc in
- target memory. Infinite recursion ensues. */
- if (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC)
- {
- bool is_artificial
- = TYPE_FIELD_ARTIFICIAL (value_type (arg1), tem - 1);
- argvec[tem] = fortran_argument_convert (argvec[tem],
- is_artificial);
- }
- }
- argvec[tem] = 0; /* signal end of arglist */
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- return eval_call (exp, noside, nargs, argvec, NULL, expect_type);
+ auto call_args = gdb::make_array_view (argvec, nargs + 3);
- default:
- error (_("Cannot perform substring on this type"));
- }
+ return eval_op_objc_msgcall (expect_type, exp, noside, selector,
+ target, call_args);
+ }
+ break;
+
+ case OP_FUNCALL:
+ return evaluate_funcall (expect_type, exp, pos, noside);
case OP_COMPLEX:
/* We have a complex number, There should be 2 floating
- point numbers that compose it. */
+ point numbers that compose it. */
(*pos) += 2;
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
+ arg2 = evaluate_subexp (nullptr, exp, pos, noside);
return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type);
case STRUCTOP_STRUCT:
tem = longest_to_int (exp->elts[pc + 1].longconst);
(*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
- NULL, "structure");
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
- return arg3;
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
+ return eval_op_structop_struct (expect_type, exp, noside, arg1,
+ &exp->elts[pc + 2].string);
case STRUCTOP_PTR:
tem = longest_to_int (exp->elts[pc + 1].longconst);
(*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
-
- /* Check to see if operator '->' has been overloaded. If so replace
- arg1 with the value returned by evaluating operator->(). */
- while (unop_user_defined_p (op, arg1))
- {
- struct value *value = NULL;
- try
- {
- value = value_x_unop (arg1, op, noside);
- }
-
- catch (const gdb_exception_error &except)
- {
- if (except.error == NOT_FOUND_ERROR)
- break;
- else
- throw;
- }
-
- arg1 = value;
- }
-
- /* JYG: if print object is on we need to replace the base type
- with rtti type in order to continue on with successful
- lookup of member / method only available in the rtti type. */
- {
- struct type *arg_type = value_type (arg1);
- struct type *real_type;
- int full, using_enc;
- LONGEST top;
- struct value_print_options opts;
-
- get_user_print_options (&opts);
- if (opts.objectprint && TYPE_TARGET_TYPE (arg_type)
- && (TYPE_TARGET_TYPE (arg_type)->code () == TYPE_CODE_STRUCT))
- {
- real_type = value_rtti_indirect_type (arg1, &full, &top,
- &using_enc);
- if (real_type)
- arg1 = value_cast (real_type, arg1);
- }
- }
-
- arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
- NULL, "structure pointer");
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
- return arg3;
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
+ return eval_op_structop_ptr (expect_type, exp, noside, arg1,
+ &exp->elts[pc + 2].string);
case STRUCTOP_MEMBER:
case STRUCTOP_MPTR:
if (op == STRUCTOP_MEMBER)
arg1 = evaluate_subexp_for_address (exp, pos, noside);
else
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
-
- arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
-
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
-
- type = check_typedef (value_type (arg2));
- switch (type->code ())
- {
- case TYPE_CODE_METHODPTR:
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return value_zero (TYPE_TARGET_TYPE (type), not_lval);
- else
- {
- arg2 = cplus_method_ptr_to_value (&arg1, arg2);
- gdb_assert (value_type (arg2)->code () == TYPE_CODE_PTR);
- return value_ind (arg2);
- }
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
- case TYPE_CODE_MEMBERPTR:
- /* Now, convert these values to an address. */
- arg1 = value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type)),
- arg1, 1);
-
- mem_offset = value_as_long (arg2);
+ arg2 = evaluate_subexp (nullptr, exp, pos, noside);
- arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
- value_as_long (arg1) + mem_offset);
- return value_ind (arg3);
-
- default:
- error (_("non-pointer-to-member value used "
- "in pointer-to-member construct"));
- }
+ return eval_op_member (expect_type, exp, noside, arg1, arg2);
case TYPE_INSTANCE:
{
case BINOP_CONCAT:
arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- if (binop_user_defined_p (op, arg1, arg2))
- return value_x_binop (arg1, arg2, op, OP_NULL, noside);
- else
- return value_concat (arg1, arg2);
+ return eval_op_concat (expect_type, exp, noside, arg1, arg2);
case BINOP_ASSIGN:
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
/* Special-case assignments where the left-hand-side is a
convenience variable -- in these, don't bother setting an
expected type. This avoids a weird case where re-assigning a
string or array to an internal variable could error with "Too
many array elements". */
arg2 = evaluate_subexp (VALUE_LVAL (arg1) == lval_internalvar
- ? NULL_TYPE : value_type (arg1),
+ ? nullptr
+ : value_type (arg1),
exp, pos, noside);
if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
case BINOP_ASSIGN_MODIFY:
(*pos) += 2;
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
- if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
- return arg1;
op = exp->elts[pc + 1].opcode;
- if (binop_user_defined_p (op, arg1, arg2))
- return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
- else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn,
- value_type (arg1))
- && is_integral_type (value_type (arg2)))
- arg2 = value_ptradd (arg1, value_as_long (arg2));
- else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn,
- value_type (arg1))
- && is_integral_type (value_type (arg2)))
- arg2 = value_ptradd (arg1, - value_as_long (arg2));
- else
- {
- struct value *tmp = arg1;
-
- /* For shift and integer exponentiation operations,
- only promote the first argument. */
- if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
- && is_integral_type (value_type (arg2)))
- unop_promote (exp->language_defn, exp->gdbarch, &tmp);
- else
- binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
-
- arg2 = value_binop (tmp, arg2, op);
- }
- return value_assign (arg1, arg2);
+ return eval_binop_assign_modify (expect_type, exp, noside, op,
+ arg1, arg2);
case BINOP_ADD:
arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- if (binop_user_defined_p (op, arg1, arg2))
- return value_x_binop (arg1, arg2, op, OP_NULL, noside);
- else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
- && is_integral_or_integral_reference (value_type (arg2)))
- return value_ptradd (arg1, value_as_long (arg2));
- else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
- && is_integral_or_integral_reference (value_type (arg1)))
- return value_ptradd (arg2, value_as_long (arg1));
- else
- {
- binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
- return value_binop (arg1, arg2, BINOP_ADD);
- }
+ return eval_op_add (expect_type, exp, noside, arg1, arg2);
case BINOP_SUB:
arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- if (binop_user_defined_p (op, arg1, arg2))
- return value_x_binop (arg1, arg2, op, OP_NULL, noside);
- else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
- && ptrmath_type_p (exp->language_defn, value_type (arg2)))
- {
- /* FIXME -- should be ptrdiff_t */
- type = builtin_type (exp->gdbarch)->builtin_long;
- return value_from_longest (type, value_ptrdiff (arg1, arg2));
- }
- else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
- && is_integral_or_integral_reference (value_type (arg2)))
- return value_ptradd (arg1, - value_as_long (arg2));
- else
- {
- binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
- return value_binop (arg1, arg2, BINOP_SUB);
- }
+ return eval_op_sub (expect_type, exp, noside, arg1, arg2);
case BINOP_EXP:
case BINOP_MUL:
case BINOP_BITWISE_AND:
case BINOP_BITWISE_IOR:
case BINOP_BITWISE_XOR:
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- if (binop_user_defined_p (op, arg1, arg2))
- return value_x_binop (arg1, arg2, op, OP_NULL, noside);
- else
- {
- /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
- fudge arg2 to avoid division-by-zero, the caller is
- (theoretically) only looking for the type of the result. */
- if (noside == EVAL_AVOID_SIDE_EFFECTS
- /* ??? Do we really want to test for BINOP_MOD here?
- The implementation of value_binop gives it a well-defined
- value. */
- && (op == BINOP_DIV
- || op == BINOP_INTDIV
- || op == BINOP_REM
- || op == BINOP_MOD)
- && value_logical_not (arg2))
- {
- struct value *v_one, *retval;
-
- v_one = value_one (value_type (arg2));
- binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
- retval = value_binop (arg1, v_one, op);
- return retval;
- }
- else
- {
- /* For shift and integer exponentiation operations,
- only promote the first argument. */
- if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
- && is_integral_type (value_type (arg2)))
- unop_promote (exp->language_defn, exp->gdbarch, &arg1);
- else
- binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
-
- return value_binop (arg1, arg2, op);
- }
- }
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
+ arg2 = evaluate_subexp (nullptr, exp, pos, noside);
+ return eval_op_binary (expect_type, exp, noside, op, arg1, arg2);
case BINOP_SUBSCRIPT:
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- if (binop_user_defined_p (op, arg1, arg2))
- return value_x_binop (arg1, arg2, op, OP_NULL, noside);
- else
- {
- /* If the user attempts to subscript something that is not an
- array or pointer type (like a plain int variable for example),
- then report this as an error. */
-
- arg1 = coerce_ref (arg1);
- type = check_typedef (value_type (arg1));
- if (type->code () != TYPE_CODE_ARRAY
- && type->code () != TYPE_CODE_PTR)
- {
- if (type->name ())
- error (_("cannot subscript something of type `%s'"),
- type->name ());
- else
- error (_("cannot subscript requested type"));
- }
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
+ arg2 = evaluate_subexp (nullptr, exp, pos, noside);
+ return eval_op_subscript (expect_type, exp, noside, op, arg1, arg2);
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
- else
- return value_subscript (arg1, value_as_long (arg2));
- }
case MULTI_SUBSCRIPT:
(*pos) += 2;
nargs = longest_to_int (exp->elts[pc + 1].longconst);
arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
- while (nargs-- > 0)
- {
- arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
- /* FIXME: EVAL_SKIP handling may not be correct. */
- if (noside == EVAL_SKIP)
- {
- if (nargs > 0)
- continue;
- return eval_skip_value (exp);
- }
- /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- {
- /* If the user attempts to subscript something that has no target
- type (like a plain int variable for example), then report this
- as an error. */
-
- type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
- if (type != NULL)
- {
- arg1 = value_zero (type, VALUE_LVAL (arg1));
- noside = EVAL_SKIP;
- continue;
- }
- else
- {
- error (_("cannot subscript something of type `%s'"),
- value_type (arg1)->name ());
- }
- }
-
- if (binop_user_defined_p (op, arg1, arg2))
- {
- arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside);
- }
- else
- {
- arg1 = coerce_ref (arg1);
- type = check_typedef (value_type (arg1));
-
- switch (type->code ())
- {
- case TYPE_CODE_PTR:
- case TYPE_CODE_ARRAY:
- case TYPE_CODE_STRING:
- arg1 = value_subscript (arg1, value_as_long (arg2));
- break;
-
- default:
- if (type->name ())
- error (_("cannot subscript something of type `%s'"),
- type->name ());
- else
- error (_("cannot subscript requested type"));
- }
- }
- }
- return (arg1);
-
- multi_f77_subscript:
- {
- LONGEST subscript_array[MAX_FORTRAN_DIMS];
- int ndimensions = 1, i;
- struct value *array = arg1;
-
- if (nargs > MAX_FORTRAN_DIMS)
- error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
-
- ndimensions = calc_f77_array_dims (type);
-
- if (nargs != ndimensions)
- error (_("Wrong number of subscripts"));
-
- gdb_assert (nargs > 0);
-
- /* Now that we know we have a legal array subscript expression
- let us actually find out where this element exists in the array. */
-
- /* Take array indices left to right. */
- for (i = 0; i < nargs; i++)
- {
- /* Evaluate each subscript; it must be a legal integer in F77. */
- arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
-
- /* Fill in the subscript array. */
-
- subscript_array[i] = value_as_long (arg2);
- }
-
- /* Internal type of array is arranged right to left. */
- for (i = nargs; i > 0; i--)
- {
- struct type *array_type = check_typedef (value_type (array));
- LONGEST index = subscript_array[i - 1];
-
- array = value_subscripted_rvalue (array, index,
- f77_get_lowerbound (array_type));
- }
-
- return array;
- }
+ argvec = XALLOCAVEC (struct value *, nargs);
+ for (ix = 0; ix < nargs; ++ix)
+ argvec[ix] = evaluate_subexp_with_coercion (exp, pos, noside);
+ return eval_multi_subscript (expect_type, exp, noside, arg1,
+ gdb::make_array_view (argvec, nargs));
case BINOP_LOGICAL_AND:
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- if (noside == EVAL_SKIP)
- {
- evaluate_subexp (NULL_TYPE, exp, pos, noside);
- return eval_skip_value (exp);
- }
-
- oldpos = *pos;
- arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
- *pos = oldpos;
-
- if (binop_user_defined_p (op, arg1, arg2))
- {
- arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- return value_x_binop (arg1, arg2, op, OP_NULL, noside);
- }
- else
- {
- tem = value_logical_not (arg1);
- arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
- (tem ? EVAL_SKIP : noside));
- type = language_bool_type (exp->language_defn, exp->gdbarch);
- return value_from_longest (type,
- (LONGEST) (!tem && !value_logical_not (arg2)));
- }
-
- case BINOP_LOGICAL_OR:
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
if (noside == EVAL_SKIP)
{
- evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ evaluate_subexp (nullptr, exp, pos, noside);
return eval_skip_value (exp);
}
oldpos = *pos;
- arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
- *pos = oldpos;
-
- if (binop_user_defined_p (op, arg1, arg2))
- {
- arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- return value_x_binop (arg1, arg2, op, OP_NULL, noside);
- }
- else
- {
- tem = value_logical_not (arg1);
- arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
- (!tem ? EVAL_SKIP : noside));
- type = language_bool_type (exp->language_defn, exp->gdbarch);
- return value_from_longest (type,
- (LONGEST) (!tem || !value_logical_not (arg2)));
- }
-
- case BINOP_EQUAL:
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- if (binop_user_defined_p (op, arg1, arg2))
- {
- return value_x_binop (arg1, arg2, op, OP_NULL, noside);
- }
- else
- {
- binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
- tem = value_equal (arg1, arg2);
- type = language_bool_type (exp->language_defn, exp->gdbarch);
- return value_from_longest (type, (LONGEST) tem);
- }
-
- case BINOP_NOTEQUAL:
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- if (binop_user_defined_p (op, arg1, arg2))
- {
- return value_x_binop (arg1, arg2, op, OP_NULL, noside);
- }
- else
- {
- binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
- tem = value_equal (arg1, arg2);
- type = language_bool_type (exp->language_defn, exp->gdbarch);
- return value_from_longest (type, (LONGEST) ! tem);
- }
-
- case BINOP_LESS:
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- if (binop_user_defined_p (op, arg1, arg2))
- {
- return value_x_binop (arg1, arg2, op, OP_NULL, noside);
- }
- else
- {
- binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
- tem = value_less (arg1, arg2);
- type = language_bool_type (exp->language_defn, exp->gdbarch);
- return value_from_longest (type, (LONGEST) tem);
- }
-
- case BINOP_GTR:
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- if (binop_user_defined_p (op, arg1, arg2))
- {
- return value_x_binop (arg1, arg2, op, OP_NULL, noside);
- }
- else
- {
- binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
- tem = value_less (arg2, arg1);
- type = language_bool_type (exp->language_defn, exp->gdbarch);
- return value_from_longest (type, (LONGEST) tem);
- }
-
- case BINOP_GEQ:
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
+ arg2 = evaluate_subexp (nullptr, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
+ *pos = oldpos;
+
if (binop_user_defined_p (op, arg1, arg2))
{
+ arg2 = evaluate_subexp (nullptr, exp, pos, noside);
return value_x_binop (arg1, arg2, op, OP_NULL, noside);
}
else
{
- binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
- tem = value_less (arg2, arg1) || value_equal (arg1, arg2);
+ tem = value_logical_not (arg1);
+ arg2
+ = evaluate_subexp (nullptr, exp, pos, (tem ? EVAL_SKIP : noside));
type = language_bool_type (exp->language_defn, exp->gdbarch);
- return value_from_longest (type, (LONGEST) tem);
+ return value_from_longest (type,
+ (LONGEST) (!tem && !value_logical_not (arg2)));
}
- case BINOP_LEQ:
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
+ case BINOP_LOGICAL_OR:
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
+ {
+ evaluate_subexp (nullptr, exp, pos, noside);
+ return eval_skip_value (exp);
+ }
+
+ oldpos = *pos;
+ arg2 = evaluate_subexp (nullptr, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
+ *pos = oldpos;
+
if (binop_user_defined_p (op, arg1, arg2))
{
+ arg2 = evaluate_subexp (nullptr, exp, pos, noside);
return value_x_binop (arg1, arg2, op, OP_NULL, noside);
}
else
{
- binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
- tem = value_less (arg1, arg2) || value_equal (arg1, arg2);
+ tem = value_logical_not (arg1);
+ arg2
+ = evaluate_subexp (nullptr, exp, pos, (!tem ? EVAL_SKIP : noside));
type = language_bool_type (exp->language_defn, exp->gdbarch);
- return value_from_longest (type, (LONGEST) tem);
+ return value_from_longest (type,
+ (LONGEST) (!tem || !value_logical_not (arg2)));
}
+ case BINOP_EQUAL:
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
+ arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
+ return eval_op_equal (expect_type, exp, noside, op, arg1, arg2);
+
+ case BINOP_NOTEQUAL:
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
+ arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
+ return eval_op_notequal (expect_type, exp, noside, op, arg1, arg2);
+
+ case BINOP_LESS:
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
+ arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
+ return eval_op_less (expect_type, exp, noside, op, arg1, arg2);
+
+ case BINOP_GTR:
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
+ arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
+ return eval_op_gtr (expect_type, exp, noside, op, arg1, arg2);
+
+ case BINOP_GEQ:
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
+ arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
+ return eval_op_geq (expect_type, exp, noside, op, arg1, arg2);
+
+ case BINOP_LEQ:
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
+ arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
+ return eval_op_leq (expect_type, exp, noside, op, arg1, arg2);
+
case BINOP_REPEAT:
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- type = check_typedef (value_type (arg2));
- if (type->code () != TYPE_CODE_INT
- && type->code () != TYPE_CODE_ENUM)
- error (_("Non-integral right operand for \"@\" operator."));
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- {
- return allocate_repeat_value (value_type (arg1),
- longest_to_int (value_as_long (arg2)));
- }
- else
- return value_repeat (arg1, longest_to_int (value_as_long (arg2)));
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
+ arg2 = evaluate_subexp (nullptr, exp, pos, noside);
+ return eval_op_repeat (expect_type, exp, noside, arg1, arg2);
case BINOP_COMMA:
- evaluate_subexp (NULL_TYPE, exp, pos, noside);
- return evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ evaluate_subexp (nullptr, exp, pos, noside);
+ return evaluate_subexp (nullptr, exp, pos, noside);
case UNOP_PLUS:
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- if (unop_user_defined_p (op, arg1))
- return value_x_unop (arg1, op, noside);
- else
- {
- unop_promote (exp->language_defn, exp->gdbarch, &arg1);
- return value_pos (arg1);
- }
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
+ return eval_op_plus (expect_type, exp, noside, op, arg1);
case UNOP_NEG:
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- if (unop_user_defined_p (op, arg1))
- return value_x_unop (arg1, op, noside);
- else
- {
- unop_promote (exp->language_defn, exp->gdbarch, &arg1);
- return value_neg (arg1);
- }
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
+ return eval_op_neg (expect_type, exp, noside, op, arg1);
case UNOP_COMPLEMENT:
/* C++: check for and handle destructor names. */
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
- return value_x_unop (arg1, UNOP_COMPLEMENT, noside);
- else
- {
- unop_promote (exp->language_defn, exp->gdbarch, &arg1);
- return value_complement (arg1);
- }
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
+ return eval_op_complement (expect_type, exp, noside, op, arg1);
case UNOP_LOGICAL_NOT:
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- if (unop_user_defined_p (op, arg1))
- return value_x_unop (arg1, op, noside);
- else
- {
- type = language_bool_type (exp->language_defn, exp->gdbarch);
- return value_from_longest (type, (LONGEST) value_logical_not (arg1));
- }
+ arg1 = evaluate_subexp (nullptr, exp, pos, noside);
+ return eval_op_lognot (expect_type, exp, noside, op, arg1);
case UNOP_IND:
if (expect_type && expect_type->code () == TYPE_CODE_PTR)
expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
arg1 = evaluate_subexp (expect_type, exp, pos, noside);
- type = check_typedef (value_type (arg1));
- if (type->code () == TYPE_CODE_METHODPTR
- || type->code () == TYPE_CODE_MEMBERPTR)
- error (_("Attempt to dereference pointer "
- "to member without an object"));
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- if (unop_user_defined_p (op, arg1))
- return value_x_unop (arg1, op, noside);
- else if (noside == EVAL_AVOID_SIDE_EFFECTS)
- {
- type = check_typedef (value_type (arg1));
- if (type->code () == TYPE_CODE_PTR
- || TYPE_IS_REFERENCE (type)
- /* In C you can dereference an array to get the 1st elt. */
- || type->code () == TYPE_CODE_ARRAY
- )
- return value_zero (TYPE_TARGET_TYPE (type),
- lval_memory);
- else if (type->code () == TYPE_CODE_INT)
- /* GDB allows dereferencing an int. */
- return value_zero (builtin_type (exp->gdbarch)->builtin_int,
- lval_memory);
- else
- error (_("Attempt to take contents of a non-pointer value."));
- }
-
- /* Allow * on an integer so we can cast it to whatever we want.
- This returns an int, which seems like the most C-like thing to
- do. "long long" variables are rare enough that
- BUILTIN_TYPE_LONGEST would seem to be a mistake. */
- if (type->code () == TYPE_CODE_INT)
- return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
- (CORE_ADDR) value_as_address (arg1));
- return value_ind (arg1);
+ return eval_op_ind (expect_type, exp, noside, op, arg1);
case UNOP_ADDR:
/* C++: check for and handle pointer to members. */
if (noside == EVAL_SKIP)
{
- evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
+ evaluate_subexp (nullptr, exp, pos, EVAL_SKIP);
return eval_skip_value (exp);
}
else
- {
- struct value *retvalp = evaluate_subexp_for_address (exp, pos,
- noside);
-
- return retvalp;
- }
+ return evaluate_subexp_for_address (exp, pos, noside);
case UNOP_SIZEOF:
if (noside == EVAL_SKIP)
{
- evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
+ evaluate_subexp (nullptr, exp, pos, EVAL_SKIP);
return eval_skip_value (exp);
}
return evaluate_subexp_for_sizeof (exp, pos, noside);
case UNOP_ALIGNOF:
- {
- type = value_type (evaluate_subexp (NULL_TYPE, exp, pos,
- EVAL_AVOID_SIDE_EFFECTS));
- /* FIXME: This should be size_t. */
- struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
- ULONGEST align = type_align (type);
- if (align == 0)
- error (_("could not determine alignment of type"));
- return value_from_longest (size_type, align);
- }
+ arg1 = evaluate_subexp (nullptr, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
+ return eval_op_alignof (expect_type, exp, noside, arg1);
case UNOP_CAST:
(*pos) += 2;
case UNOP_MEMVAL:
(*pos) += 2;
arg1 = evaluate_subexp (expect_type, exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return value_zero (exp->elts[pc + 1].type, lval_memory);
- else
- return value_at_lazy (exp->elts[pc + 1].type,
- value_as_address (arg1));
+ return eval_op_memval (expect_type, exp, noside, arg1,
+ exp->elts[pc + 1].type);
case UNOP_MEMVAL_TYPE:
arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
type = value_type (arg1);
arg1 = evaluate_subexp (expect_type, exp, pos, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return value_zero (type, lval_memory);
- else
- return value_at_lazy (type, value_as_address (arg1));
+ return eval_op_memval (expect_type, exp, noside, arg1, type);
case UNOP_PREINCREMENT:
arg1 = evaluate_subexp (expect_type, exp, pos, noside);
- if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
- return arg1;
- else if (unop_user_defined_p (op, arg1))
- {
- return value_x_unop (arg1, op, noside);
- }
- else
- {
- if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
- arg2 = value_ptradd (arg1, 1);
- else
- {
- struct value *tmp = arg1;
-
- arg2 = value_one (value_type (arg1));
- binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
- arg2 = value_binop (tmp, arg2, BINOP_ADD);
- }
-
- return value_assign (arg1, arg2);
- }
+ return eval_op_preinc (expect_type, exp, noside, op, arg1);
case UNOP_PREDECREMENT:
arg1 = evaluate_subexp (expect_type, exp, pos, noside);
- if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
- return arg1;
- else if (unop_user_defined_p (op, arg1))
- {
- return value_x_unop (arg1, op, noside);
- }
- else
- {
- if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
- arg2 = value_ptradd (arg1, -1);
- else
- {
- struct value *tmp = arg1;
-
- arg2 = value_one (value_type (arg1));
- binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
- arg2 = value_binop (tmp, arg2, BINOP_SUB);
- }
-
- return value_assign (arg1, arg2);
- }
+ return eval_op_predec (expect_type, exp, noside, op, arg1);
case UNOP_POSTINCREMENT:
arg1 = evaluate_subexp (expect_type, exp, pos, noside);
- if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
- return arg1;
- else if (unop_user_defined_p (op, arg1))
- {
- return value_x_unop (arg1, op, noside);
- }
- else
- {
- arg3 = value_non_lval (arg1);
-
- if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
- arg2 = value_ptradd (arg1, 1);
- else
- {
- struct value *tmp = arg1;
-
- arg2 = value_one (value_type (arg1));
- binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
- arg2 = value_binop (tmp, arg2, BINOP_ADD);
- }
-
- value_assign (arg1, arg2);
- return arg3;
- }
+ return eval_op_postinc (expect_type, exp, noside, op, arg1);
case UNOP_POSTDECREMENT:
arg1 = evaluate_subexp (expect_type, exp, pos, noside);
- if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
- return arg1;
- else if (unop_user_defined_p (op, arg1))
- {
- return value_x_unop (arg1, op, noside);
- }
- else
- {
- arg3 = value_non_lval (arg1);
-
- if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
- arg2 = value_ptradd (arg1, -1);
- else
- {
- struct value *tmp = arg1;
-
- arg2 = value_one (value_type (arg1));
- binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
- arg2 = value_binop (tmp, arg2, BINOP_SUB);
- }
-
- value_assign (arg1, arg2);
- return arg3;
- }
+ return eval_op_postdec (expect_type, exp, noside, op, arg1);
case OP_THIS:
(*pos) += 1;
case OP_TYPE:
/* The value is not supposed to be used. This is here to make it
- easier to accommodate expressions that contain types. */
+ easier to accommodate expressions that contain types. */
(*pos) += 2;
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- else if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return allocate_value (exp->elts[pc + 1].type);
- else
- error (_("Attempt to use a type name as an expression"));
+ return eval_op_type (expect_type, exp, noside, exp->elts[pc + 1].type);
case OP_TYPEOF:
case OP_DECLTYPE:
if (noside == EVAL_SKIP)
{
- evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
+ evaluate_subexp (nullptr, exp, pos, EVAL_SKIP);
return eval_skip_value (exp);
}
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
enum exp_opcode sub_op = exp->elts[*pos].opcode;
struct value *result;
- result = evaluate_subexp (NULL_TYPE, exp, pos,
- EVAL_AVOID_SIDE_EFFECTS);
+ result = evaluate_subexp (nullptr, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
/* 'decltype' has special semantics for lvalues. */
if (op == OP_DECLTYPE
return result;
}
else
- error (_("Attempt to use a type as an expression"));
+ error (_("Attempt to use a type as an expression"));
case OP_TYPEID:
{
enum exp_opcode sub_op = exp->elts[*pos].opcode;
if (sub_op == OP_TYPE || sub_op == OP_DECLTYPE || sub_op == OP_TYPEOF)
- result = evaluate_subexp (NULL_TYPE, exp, pos,
- EVAL_AVOID_SIDE_EFFECTS);
+ result = evaluate_subexp (nullptr, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
else
- result = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ result = evaluate_subexp (nullptr, exp, pos, noside);
if (noside != EVAL_NORMAL)
return allocate_value (cplus_typeid_type (exp->gdbarch));
default:
/* Removing this case and compiling with gcc -Wall reveals that
- a lot of cases are hitting this case. Some of these should
- probably be removed from expression.h; others are legitimate
- expressions which are (apparently) not fully implemented.
+ a lot of cases are hitting this case. Some of these should
+ probably be removed from expression.h; others are legitimate
+ expressions which are (apparently) not fully implemented.
- If there are any cases landing here which mean a user error,
- then they should be separate cases, with more descriptive
- error messages. */
+ If there are any cases landing here which mean a user error,
+ then they should be separate cases, with more descriptive
+ error messages. */
error (_("GDB does not (yet) know how to "
"evaluate that kind of expression"));
gdb_assert_not_reached ("missed return?");
}
\f
+/* Helper for evaluate_subexp_for_address. */
+
+static value *
+evaluate_subexp_for_address_base (struct expression *exp, enum noside noside,
+ value *x)
+{
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ {
+ struct type *type = check_typedef (value_type (x));
+
+ if (TYPE_IS_REFERENCE (type))
+ return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
+ not_lval);
+ else if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
+ return value_zero (lookup_pointer_type (value_type (x)),
+ not_lval);
+ else
+ error (_("Attempt to take address of "
+ "value not located in memory."));
+ }
+ return value_addr (x);
+}
+
/* Evaluate a subexpression of EXP, at index *POS,
and return the address of that subexpression.
Advance *POS over the subexpression.
{
case UNOP_IND:
(*pos)++;
- x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ x = evaluate_subexp (nullptr, exp, pos, noside);
/* We can't optimize out "&*" if there's a user-defined operator*. */
if (unop_user_defined_p (op, x))
case UNOP_MEMVAL:
(*pos) += 3;
return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
- evaluate_subexp (NULL_TYPE, exp, pos, noside));
+ evaluate_subexp (nullptr, exp, pos, noside));
case UNOP_MEMVAL_TYPE:
{
struct type *type;
(*pos) += 1;
- x = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
+ x = evaluate_subexp (nullptr, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
type = value_type (x);
return value_cast (lookup_pointer_type (type),
- evaluate_subexp (NULL_TYPE, exp, pos, noside));
+ evaluate_subexp (nullptr, exp, pos, noside));
}
case OP_VAR_VALUE:
default:
default_case:
- x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ x = evaluate_subexp (nullptr, exp, pos, noside);
default_case_after_eval:
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- {
- struct type *type = check_typedef (value_type (x));
+ return evaluate_subexp_for_address_base (exp, noside, x);
+ }
+}
- if (TYPE_IS_REFERENCE (type))
- return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
- not_lval);
- else if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
- return value_zero (lookup_pointer_type (value_type (x)),
- not_lval);
- else
- error (_("Attempt to take address of "
- "value not located in memory."));
- }
- return value_addr (x);
+namespace expr
+{
+
+value *
+operation::evaluate_for_cast (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside)
+{
+ value *val = evaluate (expect_type, exp, noside);
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+ return value_cast (expect_type, val);
+}
+
+value *
+operation::evaluate_for_address (struct expression *exp, enum noside noside)
+{
+ value *val = evaluate (nullptr, exp, noside);
+ return evaluate_subexp_for_address_base (exp, noside, val);
+}
+
+value *
+scope_operation::evaluate_for_address (struct expression *exp,
+ enum noside noside)
+{
+ value *x = value_aggregate_elt (std::get<0> (m_storage),
+ std::get<1> (m_storage).c_str (),
+ NULL, 1, noside);
+ if (x == NULL)
+ error (_("There is no field named %s"), std::get<1> (m_storage).c_str ());
+ return x;
+}
+
+value *
+var_msym_value_operation::evaluate_for_address (struct expression *exp,
+ enum noside noside)
+{
+ value *val = evaluate_var_msym_value (noside,
+ std::get<1> (m_storage),
+ std::get<0> (m_storage));
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ {
+ struct type *type = lookup_pointer_type (value_type (val));
+ return value_zero (type, not_lval);
}
+ else
+ return value_addr (val);
+}
+
}
/* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
var = exp->elts[pc + 2].symbol;
type = check_typedef (SYMBOL_TYPE (var));
if (type->code () == TYPE_CODE_ARRAY
- && !TYPE_VECTOR (type)
+ && !type->is_vector ()
&& CAST_IS_CONVERSION (exp->language_defn))
{
(*pos) += 4;
/* FALLTHROUGH */
default:
- return evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ return evaluate_subexp (nullptr, exp, pos, noside);
}
}
+/* Helper function for evaluating the size of a type. */
+
+static value *
+evaluate_subexp_for_sizeof_base (struct expression *exp, struct type *type)
+{
+ /* FIXME: This should be size_t. */
+ struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
+ /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
+ "When applied to a reference or a reference type, the result is
+ the size of the referenced type." */
+ type = check_typedef (type);
+ if (exp->language_defn->la_language == language_cplus
+ && (TYPE_IS_REFERENCE (type)))
+ type = check_typedef (TYPE_TARGET_TYPE (type));
+ return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
+}
+
/* Evaluate a subexpression of EXP, at index *POS,
and return a value for the size of that subexpression.
Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
switch (op)
{
/* This case is handled specially
- so that we avoid creating a value for the result type.
- If the result type is very big, it's desirable not to
- create a value unnecessarily. */
+ so that we avoid creating a value for the result type.
+ If the result type is very big, it's desirable not to
+ create a value unnecessarily. */
case UNOP_IND:
(*pos)++;
- val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
+ val = evaluate_subexp (nullptr, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
type = check_typedef (value_type (val));
if (type->code () != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type)
type = SYMBOL_TYPE (exp->elts[pc + 2].symbol);
if (is_dynamic_type (type))
{
- val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
+ val = evaluate_subexp (nullptr, exp, pos, EVAL_NORMAL);
type = value_type (val);
- if (type->code () == TYPE_CODE_ARRAY
- && is_dynamic_type (type->index_type ())
- && TYPE_HIGH_BOUND_UNDEFINED (type->index_type ()))
- return allocate_optimized_out_value (size_type);
+ if (type->code () == TYPE_CODE_ARRAY)
+ {
+ if (type_not_allocated (type) || type_not_associated (type))
+ return value_zero (size_type, not_lval);
+ else if (is_dynamic_type (type->index_type ())
+ && type->bounds ()->high.kind () == PROP_UNDEFINED)
+ return allocate_optimized_out_value (size_type);
+ }
}
else
(*pos) += 4;
{
int npc = (*pos) + 1;
- val = evaluate_subexp (NULL_TYPE, exp, &npc, EVAL_AVOID_SIDE_EFFECTS);
+ val = evaluate_subexp (nullptr, exp, &npc, EVAL_AVOID_SIDE_EFFECTS);
type = check_typedef (value_type (val));
if (type->code () == TYPE_CODE_ARRAY)
{
type = type->index_type ();
/* Only re-evaluate the right hand side if the resulting type
is a variable length type. */
- if (TYPE_RANGE_DATA (type)->flag_bound_evaluated)
+ if (type->bounds ()->flag_bound_evaluated)
{
- val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
+ val = evaluate_subexp (nullptr, exp, pos, EVAL_NORMAL);
return value_from_longest
(size_type, (LONGEST) TYPE_LENGTH (value_type (val)));
}
/* Fall through. */
default:
- val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
+ val = evaluate_subexp (nullptr, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
type = value_type (val);
break;
}
- /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
- "When applied to a reference or a reference type, the result is
- the size of the referenced type." */
- type = check_typedef (type);
- if (exp->language_defn->la_language == language_cplus
- && (TYPE_IS_REFERENCE (type)))
- type = check_typedef (TYPE_TARGET_TYPE (type));
- return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
+ return evaluate_subexp_for_sizeof_base (exp, type);
+}
+
+namespace expr
+{
+
+value *
+operation::evaluate_for_sizeof (struct expression *exp, enum noside noside)
+{
+ value *val = evaluate (nullptr, exp, EVAL_AVOID_SIDE_EFFECTS);
+ return evaluate_subexp_for_sizeof_base (exp, value_type (val));
+}
+
+value *
+var_msym_value_operation::evaluate_for_sizeof (struct expression *exp,
+ enum noside noside)
+
+{
+ minimal_symbol *msymbol = std::get<0> (m_storage);
+ value *mval = evaluate_var_msym_value (noside,
+ std::get<1> (m_storage),
+ msymbol);
+
+ struct type *type = value_type (mval);
+ if (type->code () == TYPE_CODE_ERROR)
+ error_unknown_type (msymbol->print_name ());
+
+ /* FIXME: This should be size_t. */
+ struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
+ return value_from_longest (size_type, TYPE_LENGTH (type));
+}
+
}
/* Evaluate a subexpression of EXP, at index *POS, and return a value
return value_cast (to_type, val);
}
+namespace expr
+{
+
+value *
+var_msym_value_operation::evaluate_for_cast (struct type *to_type,
+ struct expression *exp,
+ enum noside noside)
+{
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ return value_zero (to_type, not_lval);
+
+ value *val = evaluate_var_msym_value (noside,
+ std::get<1> (m_storage),
+ std::get<0> (m_storage));
+
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+
+ val = value_cast (to_type, val);
+
+ /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
+ if (VALUE_LVAL (val) == lval_memory)
+ {
+ if (value_lazy (val))
+ value_fetch_lazy (val);
+ VALUE_LVAL (val) = not_lval;
+ }
+ return val;
+}
+
+}
+
/* Parse a type expression in the string [P..P+LENGTH). */
struct type *
-parse_and_eval_type (char *p, int length)
+parse_and_eval_type (const char *p, int length)
{
char *tmp = (char *) alloca (length + 4);
tmp[length + 2] = '0';
tmp[length + 3] = '\0';
expression_up expr = parse_expression (tmp);
- if (expr->elts[0].opcode != UNOP_CAST)
+ if (expr->first_opcode () != UNOP_CAST)
error (_("Internal error in eval_type."));
return expr->elts[1].type;
}
-
-int
-calc_f77_array_dims (struct type *array_type)
-{
- int ndimen = 1;
- struct type *tmp_type;
-
- if ((array_type->code () != TYPE_CODE_ARRAY))
- error (_("Can't get dimensions for a non-array type"));
-
- tmp_type = array_type;
-
- while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
- {
- if (tmp_type->code () == TYPE_CODE_ARRAY)
- ++ndimen;
- }
- return ndimen;
-}
projects / deliverable / binutils-gdb.git / blobdiff