/* Evaluate expressions for GDB.
- Copyright (C) 1986-2018 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 Free Software Foundation, Inc.
This file is part of GDB.
#include "typeprint.h"
#include <ctype.h>
-/* This is defined in valops.c */
-extern int overload_resolution;
-
/* Prototypes for local functions. */
static struct value *evaluate_subexp_for_sizeof (struct expression *, int *,
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_ptid))
- stack_temporaries.emplace (inferior_ptid);
+ && !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_ptid))
+ && value_in_thread_stack_temporaries (retval, inferior_thread ()))
retval = value_non_lval (retval);
return retval;
struct value *
parse_to_comma_and_eval (const char **expp)
{
- expression_up expr = parse_exp_1 (expp, 0, (struct block *) 0, 1);
+ expression_up expr = parse_exp_1 (expp, 0, nullptr, 1);
return evaluate_expression (expr.get ());
}
mark = value_mark ();
result = NULL;
- TRY
+ try
{
result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL);
}
- CATCH (ex, RETURN_MASK_ALL)
+ catch (const gdb_exception &ex)
{
/* Ignore memory errors if we want watchpoints pointing at
inaccessible memory to still be created; otherwise, throw the
case MEMORY_ERROR:
if (!preserve_errors)
break;
+ /* Fall through. */
default:
- throw_exception (ex);
+ throw;
break;
}
}
- END_CATCH
new_mark = value_mark ();
if (mark == new_mark)
else
{
- TRY
+ try
{
value_fetch_lazy (result);
*valp = result;
}
- CATCH (except, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &except)
{
}
- END_CATCH
}
}
fieldno++;
/* Skip static fields. */
- while (fieldno < TYPE_NFIELDS (struct_type)
- && field_is_static (&TYPE_FIELD (struct_type,
- fieldno)))
+ while (fieldno < struct_type->num_fields ()
+ && field_is_static (&struct_type->field (fieldno)))
fieldno++;
- if (fieldno >= TYPE_NFIELDS (struct_type))
+ if (fieldno >= struct_type->num_fields ())
error (_("too many initializers"));
field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
- if (TYPE_CODE (field_type) == TYPE_CODE_UNION
+ 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"));
/* 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 expresions and sets the specified element(s) of
+ Evaluates index expressions and sets the specified element(s) of
ARRAY to ELEMENT. Returns last index value. */
static LONGEST
{
default:
/* Perform integral promotion for ANSI C/C++.
- If not appropropriate for any particular language
+ If not appropriate for any particular language
it needs to modify this function. */
{
struct type *builtin_int = builtin_type (gdbarch)->builtin_int;
type1 = check_typedef (value_type (*arg1));
type2 = check_typedef (value_type (*arg2));
- if ((TYPE_CODE (type1) != TYPE_CODE_FLT
- && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
+ if ((type1->code () != TYPE_CODE_FLT
+ && type1->code () != TYPE_CODE_DECFLOAT
&& !is_integral_type (type1))
- || (TYPE_CODE (type2) != TYPE_CODE_FLT
- && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
+ || (type2->code () != TYPE_CODE_FLT
+ && type2->code () != TYPE_CODE_DECFLOAT
&& !is_integral_type (type2)))
return;
- if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
- || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
+ if (type1->code () == TYPE_CODE_DECFLOAT
+ || type2->code () == TYPE_CODE_DECFLOAT)
{
/* No promotion required. */
}
- else if (TYPE_CODE (type1) == TYPE_CODE_FLT
- || TYPE_CODE (type2) == TYPE_CODE_FLT)
+ else if (type1->code () == TYPE_CODE_FLT
+ || type2->code () == TYPE_CODE_FLT)
{
switch (language->la_language)
{
break;
}
}
- else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
- && TYPE_CODE (type2) == TYPE_CODE_BOOL)
+ else if (type1->code () == TYPE_CODE_BOOL
+ && type2->code () == TYPE_CODE_BOOL)
{
/* No promotion required. */
}
break;
case language_opencl:
if (result_len <= TYPE_LENGTH (lookup_signed_typename
- (language, gdbarch, "int")))
+ (language, "int")))
{
promoted_type =
(unsigned_operation
- ? lookup_unsigned_typename (language, gdbarch, "int")
- : lookup_signed_typename (language, gdbarch, "int"));
+ ? lookup_unsigned_typename (language, "int")
+ : lookup_signed_typename (language, "int"));
}
else if (result_len <= TYPE_LENGTH (lookup_signed_typename
- (language, gdbarch, "long")))
+ (language, "long")))
{
promoted_type =
(unsigned_operation
- ? lookup_unsigned_typename (language, gdbarch, "long")
- : lookup_signed_typename (language, gdbarch,"long"));
+ ? lookup_unsigned_typename (language, "long")
+ : lookup_signed_typename (language,"long"));
}
break;
default:
if (TYPE_IS_REFERENCE (type))
type = TYPE_TARGET_TYPE (type);
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_PTR:
case TYPE_CODE_FUNC:
TYPE_MAIN_TYPE (type) = &m_main_type;
TYPE_LENGTH (type) = 1;
- TYPE_CODE (type) = TYPE_CODE_METHOD;
+ type->set_code (TYPE_CODE_METHOD);
TYPE_CHAIN (type) = type;
TYPE_INSTANCE_FLAGS (type) = flags;
if (num_types > 0)
--num_types;
TYPE_VARARGS (type) = 1;
}
- else if (TYPE_CODE (check_typedef (param_types[num_types - 1]))
+ else if (check_typedef (param_types[num_types - 1])->code ()
== TYPE_CODE_VOID)
{
--num_types;
}
}
- TYPE_NFIELDS (type) = num_types;
- TYPE_FIELDS (type) = (struct field *)
- TYPE_ZALLOC (type, sizeof (struct field) * num_types);
+ /* We don't use TYPE_ZALLOC here to allocate space as TYPE is owned by
+ neither an objfile nor a gdbarch. As a result we must manually
+ allocate memory for auxiliary fields, and free the memory ourselves
+ when we are done with it. */
+ type->set_num_fields (num_types);
+ type->set_fields
+ ((struct field *) xzalloc (sizeof (struct field) * num_types));
while (num_types-- > 0)
TYPE_FIELD_TYPE (type, num_types) = param_types[num_types];
fake_method::~fake_method ()
{
- xfree (TYPE_FIELDS (&m_type));
+ xfree (m_type.fields ());
}
/* Helper for evaluating an OP_VAR_VALUE. */
struct value *ret = NULL;
- TRY
+ try
{
ret = value_of_variable (var, blk);
}
- CATCH (except, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &except)
{
if (noside != EVAL_AVOID_SIDE_EFFECTS)
- throw_exception (except);
+ throw;
ret = value_zero (SYMBOL_TYPE (var), not_lval);
}
- END_CATCH
return ret;
}
type *ftype = value_type (argvec[0]);
- if (TYPE_CODE (ftype) == TYPE_CODE_INTERNAL_FUNCTION)
+ if (ftype->code () == TYPE_CODE_INTERNAL_FUNCTION)
{
/* We don't know anything about what the internal
function might return, but we have to return
return value_zero (builtin_type (exp->gdbarch)->builtin_int,
not_lval);
}
- else if (TYPE_CODE (ftype) == TYPE_CODE_XMETHOD)
+ else if (ftype->code () == TYPE_CODE_XMETHOD)
{
type *return_type
- = result_type_of_xmethod (argvec[0], nargs, argvec + 1);
+ = result_type_of_xmethod (argvec[0],
+ gdb::make_array_view (argvec + 1,
+ nargs));
if (return_type == NULL)
error (_("Xmethod is missing return type."));
return value_zero (return_type, not_lval);
}
- else if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
- || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
+ else if (ftype->code () == TYPE_CODE_FUNC
+ || ftype->code () == TYPE_CODE_METHOD)
{
if (TYPE_GNU_IFUNC (ftype))
{
error (_("Expression of type other than "
"\"Function returning ...\" used as function"));
}
- switch (TYPE_CODE (value_type (argvec[0])))
+ switch (value_type (argvec[0])->code ())
{
case TYPE_CODE_INTERNAL_FUNCTION:
return call_internal_function (exp->gdbarch, exp->language_defn,
argvec[0], nargs, argvec + 1);
case TYPE_CODE_XMETHOD:
- return call_xmethod (argvec[0], nargs, argvec + 1);
+ return call_xmethod (argvec[0], gdb::make_array_view (argvec + 1, nargs));
default:
return call_function_by_hand (argvec[0], default_return_type,
- nargs, argvec + 1);
+ gdb::make_array_view (argvec + 1, nargs));
}
}
if (noside == EVAL_SKIP)
tem = 1; /* Set it to the right arg index so that all
arguments can also be skipped. */
- else if (TYPE_CODE (a1_type) == TYPE_CODE_METHODPTR)
+ else if (a1_type->code () == TYPE_CODE_METHODPTR)
{
if (noside == EVAL_AVOID_SIDE_EFFECTS)
arg1 = value_zero (TYPE_TARGET_TYPE (a1_type), not_lval);
tem = 2;
argvec[1] = arg2;
}
- else if (TYPE_CODE (a1_type) == TYPE_CODE_MEMBERPTR)
+ else if (a1_type->code () == TYPE_CODE_MEMBERPTR)
{
struct type *type_ptr
= lookup_pointer_type (TYPE_SELF_TYPE (a1_type));
while (unop_user_defined_p (op, arg2))
{
struct value *value = NULL;
- TRY
+ try
{
value = value_x_unop (arg2, op, noside);
}
- CATCH (except, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &except)
{
if (except.error == NOT_FOUND_ERROR)
break;
else
- throw_exception (except);
+ throw;
}
- END_CATCH
arg2 = value;
}
function = NULL;
function_name = NULL;
- if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
+ if (type->code () == TYPE_CODE_NAMESPACE)
{
- function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type),
+ function = cp_lookup_symbol_namespace (type->name (),
name,
get_selected_block (0),
VAR_DOMAIN).symbol;
if (function == NULL)
error (_("No symbol \"%s\" in namespace \"%s\"."),
- name, TYPE_TAG_NAME (type));
+ name, type->name ());
tem = 1;
/* arg2 is left as NULL on purpose. */
}
else
{
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
- || TYPE_CODE (type) == TYPE_CODE_UNION);
+ gdb_assert (type->code () == TYPE_CODE_STRUCT
+ || type->code () == TYPE_CODE_UNION);
function_name = name;
/* We need a properly typed value for method lookup. For
if (op == OP_VAR_MSYM_VALUE)
{
minimal_symbol *msym = exp->elts[*pos + 2].msymbol;
- var_func_name = MSYMBOL_PRINT_NAME (msym);
+ var_func_name = msym->print_name ();
}
else if (op == OP_VAR_VALUE)
{
symbol *sym = exp->elts[*pos + 2].symbol;
- var_func_name = SYMBOL_PRINT_NAME (sym);
+ var_func_name = sym->print_name ();
}
argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
type *type = value_type (argvec[0]);
- if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
+ if (type && type->code () == TYPE_CODE_PTR)
type = TYPE_TARGET_TYPE (type);
- if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
+ if (type && type->code () == TYPE_CODE_FUNC)
{
- for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
+ for (; tem <= nargs && tem <= type->num_fields (); tem++)
{
argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type,
tem - 1),
func_name = (char *) alloca (name_len + 1);
strcpy (func_name, &exp->elts[string_pc + 1].string);
- find_overload_match (&argvec[1], nargs, func_name,
+ find_overload_match (gdb::make_array_view (&argvec[1], nargs),
+ func_name,
NON_METHOD, /* not method */
NULL, NULL, /* pass NULL symbol since
symbol is unknown */
evaluation. */
struct value *valp = NULL;
- (void) find_overload_match (&argvec[1], nargs, tstr,
+ (void) find_overload_match (gdb::make_array_view (&argvec[1], nargs),
+ tstr,
METHOD, /* method */
&arg2, /* the object */
NULL, &valp, NULL,
if (op == OP_VAR_VALUE)
function = exp->elts[save_pos1+2].symbol;
- (void) find_overload_match (&argvec[1], nargs,
+ (void) find_overload_match (gdb::make_array_view (&argvec[1], nargs),
NULL, /* no need for name */
NON_METHOD, /* not method */
NULL, function, /* the function */
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 true if type is integral or reference to integral */
+
+static bool
+is_integral_or_integral_reference (struct type *type)
+{
+ if (is_integral_type (type))
+ return true;
+
+ type = check_typedef (type);
+ return (type != nullptr
+ && TYPE_IS_REFERENCE (type)
+ && is_integral_type (TYPE_TARGET_TYPE (type)));
+}
+
struct value *
evaluate_subexp_standard (struct type *expect_type,
struct expression *exp, int *pos,
case OP_ADL_FUNC:
case OP_VAR_VALUE:
- (*pos) += 3;
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
-
{
+ (*pos) += 3;
symbol *var = exp->elts[pc + 2].symbol;
- if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_ERROR)
- error_unknown_type (SYMBOL_PRINT_NAME (var));
-
- return evaluate_var_value (noside, exp->elts[pc + 1].block, var);
+ 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:
msymbol);
type = value_type (val);
- if (TYPE_CODE (type) == TYPE_CODE_ERROR
+ if (type->code () == TYPE_CODE_ERROR
&& (noside != EVAL_AVOID_SIDE_EFFECTS || pc != 0))
- error_unknown_type (MSYMBOL_PRINT_NAME (msymbol));
+ error_unknown_type (msymbol->print_name ());
return val;
}
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"),
- SYMBOL_PRINT_NAME (sym));
+ sym->print_name ());
frame = get_selected_frame (NULL);
return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
So for these registers, we fetch the register value regardless
of the evaluation mode. */
if (noside == EVAL_AVOID_SIDE_EFFECTS
- && regno < gdbarch_num_regs (exp->gdbarch)
- + gdbarch_num_pseudo_regs (exp->gdbarch))
+ && 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));
type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
if (expect_type != NULL_TYPE && noside != EVAL_SKIP
- && TYPE_CODE (type) == TYPE_CODE_STRUCT)
+ && type->code () == TYPE_CODE_STRUCT)
{
struct value *rec = allocate_value (expect_type);
}
if (expect_type != NULL_TYPE && noside != EVAL_SKIP
- && TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ && type->code () == TYPE_CODE_ARRAY)
{
struct type *range_type = TYPE_INDEX_TYPE (type);
struct type *element_type = TYPE_TARGET_TYPE (type);
}
if (expect_type != NULL_TYPE && noside != EVAL_SKIP
- && TYPE_CODE (type) == TYPE_CODE_SET)
+ && type->code () == TYPE_CODE_SET)
{
struct value *set = allocate_value (expect_type);
gdb_byte *valaddr = value_contents_raw (set);
LONGEST low_bound, high_bound;
/* Get targettype of elementtype. */
- while (TYPE_CODE (check_type) == TYPE_CODE_RANGE
- || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
+ while (check_type->code () == TYPE_CODE_RANGE
+ || check_type->code () == TYPE_CODE_TYPEDEF)
check_type = TYPE_TARGET_TYPE (check_type);
if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
/* 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. */
- if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
+ if (range_low_type->code () == TYPE_CODE_RANGE)
range_low_type = TYPE_TARGET_TYPE (range_low_type);
- if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
+ if (range_high_type->code () == TYPE_CODE_RANGE)
range_high_type = TYPE_TARGET_TYPE (range_high_type);
- if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type))
- || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM
+ if ((range_low_type->code () != range_high_type->code ())
+ || (range_low_type->code () == TYPE_CODE_ENUM
&& (range_low_type != range_high_type)))
/* different element modes. */
error (_("POWERSET tuple elements of different mode"));
- if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type))
- || (TYPE_CODE (check_type) == TYPE_CODE_ENUM
+ if ((check_type->code () != range_low_type->code ())
+ || (check_type->code () == TYPE_CODE_ENUM
&& range_low_type != check_type))
error (_("incompatible POWERSET tuple elements"));
if (range_low > range_high)
{
int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
- if (gdbarch_bits_big_endian (exp->gdbarch))
+ if (gdbarch_byte_order (exp->gdbarch) == BFD_ENDIAN_BIG)
bit_index = TARGET_CHAR_BIT - 1 - bit_index;
valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
|= 1 << bit_index;
only). */
if (gnu_runtime)
{
- struct type *type = selector_type;
+ type = selector_type;
type = lookup_function_type (type);
type = lookup_pointer_type (type);
argvec[3] = value_from_longest (long_type, selector);
argvec[4] = 0;
- ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
+ 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, 3, argvec + 1);
+ 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."));
argvec[3] = value_from_longest (long_type, selector);
argvec[4] = 0;
- ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
+ 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, 3, argvec + 1);
+ ret = call_function_by_hand (argvec[0], NULL, {argvec + 1, 3});
}
/* ret should now be the selector. */
/* 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,
- ¤t_target);
+ current_top_target ());
/* Is it a high_level symbol? */
sym = find_pc_function (addr);
block_for_pc (funaddr);
val_type = check_typedef (val_type);
-
- if ((val_type == NULL)
- || (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
+
+ 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, 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
if (method)
{
- if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
+ if (value_type (method)->code () != TYPE_CODE_FUNC)
error (_("method address has symbol information "
"with non-function type; skipping"));
it's opinion (ie. through "whatis"), it won't offer
it. */
- struct type *type = value_type (called_method);
+ struct type *callee_type = value_type (called_method);
- if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
- type = TYPE_TARGET_TYPE (type);
- type = TYPE_TARGET_TYPE (type);
+ if (callee_type && callee_type->code () == TYPE_CODE_PTR)
+ callee_type = TYPE_TARGET_TYPE (callee_type);
+ callee_type = TYPE_TARGET_TYPE (callee_type);
- if (type)
+ if (callee_type)
{
- if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type)
+ if ((callee_type->code () == TYPE_CODE_ERROR) && expect_type)
return allocate_value (expect_type);
else
- return allocate_value (type);
+ return allocate_value (callee_type);
}
else
error (_("Expression of type other than "
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, nargs + 2, argvec + 1);
+ argvec[0] = call_function_by_hand (argvec[0], NULL, call_args);
}
- ret = call_function_by_hand (argvec[0], NULL, nargs + 2, argvec + 1);
- return ret;
+ return call_function_by_hand (argvec[0], NULL, call_args);
}
break;
/* 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 (type);
+ code = type->code ();
if (code == TYPE_CODE_PTR)
{
to the target value the original one points to. */
struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
- if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
- || TYPE_CODE (target_type) == TYPE_CODE_STRING
- || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
+ 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 (type);
+ code = type->code ();
}
}
if (exp->elts[*pos].opcode == OP_RANGE)
return value_f90_subarray (arg1, exp, pos, noside);
else
- goto multi_f77_subscript;
+ {
+ 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));
}
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[0] = arg1;
tem = 1;
for (; tem <= nargs; tem++)
- argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
+ {
+ 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);
while (unop_user_defined_p (op, arg1))
{
struct value *value = NULL;
- TRY
+ try
{
value = value_x_unop (arg1, op, noside);
}
- CATCH (except, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &except)
{
if (except.error == NOT_FOUND_ERROR)
break;
else
- throw_exception (except);
+ throw;
}
- END_CATCH
arg1 = value;
}
with rtti type in order to continue on with successful
lookup of member / method only available in the rtti type. */
{
- struct type *type = value_type (arg1);
+ 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(type)
- && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
+ 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);
return eval_skip_value (exp);
type = check_typedef (value_type (arg2));
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_METHODPTR:
if (noside == EVAL_AVOID_SIDE_EFFECTS)
else
{
arg2 = cplus_method_ptr_to_value (&arg1, arg2);
- gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR);
+ gdb_assert (value_type (arg2)->code () == TYPE_CODE_PTR);
return value_ind (arg2);
}
for (ix = 0; ix < nargs; ++ix)
arg_types[ix] = exp->elts[pc + 2 + ix + 1].type;
- fake_method expect_type (flags, nargs, arg_types);
+ fake_method fake_expect_type (flags, nargs, arg_types);
*(pos) += 4 + nargs;
- return evaluate_subexp_standard (expect_type.type (), exp, pos, noside);
+ return evaluate_subexp_standard (fake_expect_type.type (), exp, pos,
+ noside);
}
case BINOP_CONCAT:
case BINOP_ASSIGN:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (value_type (arg1), 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),
+ exp, pos, noside);
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, op, OP_NULL, noside);
else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
- && is_integral_type (value_type (arg2)))
+ && 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_type (value_type (arg1)))
+ && is_integral_or_integral_reference (value_type (arg1)))
return value_ptradd (arg2, value_as_long (arg1));
else
{
return value_from_longest (type, value_ptrdiff (arg1, arg2));
}
else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
- && is_integral_type (value_type (arg2)))
+ && is_integral_or_integral_reference (value_type (arg2)))
return value_ptradd (arg1, - value_as_long (arg2));
else
{
arg1 = coerce_ref (arg1);
type = check_typedef (value_type (arg1));
- if (TYPE_CODE (type) != TYPE_CODE_ARRAY
- && TYPE_CODE (type) != TYPE_CODE_PTR)
+ if (type->code () != TYPE_CODE_ARRAY
+ && type->code () != TYPE_CODE_PTR)
{
- if (TYPE_NAME (type))
+ if (type->name ())
error (_("cannot subscript something of type `%s'"),
- TYPE_NAME (type));
+ type->name ());
else
error (_("cannot subscript requested type"));
}
else
{
error (_("cannot subscript something of type `%s'"),
- TYPE_NAME (value_type (arg1)));
+ value_type (arg1)->name ());
}
}
arg1 = coerce_ref (arg1);
type = check_typedef (value_type (arg1));
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_PTR:
case TYPE_CODE_ARRAY:
break;
default:
- if (TYPE_NAME (type))
+ if (type->name ())
error (_("cannot subscript something of type `%s'"),
- TYPE_NAME (type));
+ type->name ());
else
error (_("cannot subscript requested type"));
}
if (noside == EVAL_SKIP)
return eval_skip_value (exp);
type = check_typedef (value_type (arg2));
- if (TYPE_CODE (type) != TYPE_CODE_INT
- && TYPE_CODE (type) != TYPE_CODE_ENUM)
+ if (type->code () != TYPE_CODE_INT
+ && type->code () != TYPE_CODE_ENUM)
error (_("Non-integral right operand for \"@\" operator."));
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
}
case UNOP_IND:
- if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
+ 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) == TYPE_CODE_METHODPTR
- || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
+ 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)
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
type = check_typedef (value_type (arg1));
- if (TYPE_CODE (type) == TYPE_CODE_PTR
+ 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) == TYPE_CODE_ARRAY
+ || type->code () == TYPE_CODE_ARRAY
)
return value_zero (TYPE_TARGET_TYPE (type),
lval_memory);
- else if (TYPE_CODE (type) == TYPE_CODE_INT)
+ else if (type->code () == TYPE_CODE_INT)
/* GDB allows dereferencing an int. */
return value_zero (builtin_type (exp->gdbarch)->builtin_int,
lval_memory);
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) == TYPE_CODE_INT)
+ 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);
case UNOP_ALIGNOF:
{
- struct type *type
- = value_type (evaluate_subexp (NULL_TYPE, exp, pos,
- EVAL_AVOID_SIDE_EFFECTS));
+ 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);
|| sub_op == STRUCTOP_PTR
|| sub_op == OP_SCOPE))
{
- struct type *type = value_type (result);
+ type = value_type (result);
if (!TYPE_IS_REFERENCE (type))
{
case OP_VAR_VALUE:
var = exp->elts[pc + 2].symbol;
type = check_typedef (SYMBOL_TYPE (var));
- if (TYPE_CODE (type) == TYPE_CODE_ARRAY
+ if (type->code () == TYPE_CODE_ARRAY
&& !TYPE_VECTOR (type)
&& CAST_IS_CONVERSION (exp->language_defn))
{
(*pos)++;
val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
type = check_typedef (value_type (val));
- if (TYPE_CODE (type) != TYPE_CODE_PTR
+ if (type->code () != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type)
- && TYPE_CODE (type) != TYPE_CODE_ARRAY)
+ && type->code () != TYPE_CODE_ARRAY)
error (_("Attempt to take contents of a non-pointer value."));
type = TYPE_TARGET_TYPE (type);
if (is_dynamic_type (type))
{
val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
type = value_type (val);
+ if (type->code () == TYPE_CODE_ARRAY
+ && is_dynamic_type (TYPE_INDEX_TYPE (type))
+ && TYPE_HIGH_BOUND_UNDEFINED (TYPE_INDEX_TYPE (type)))
+ return allocate_optimized_out_value (size_type);
}
else
(*pos) += 4;
(*pos) += 4;
minimal_symbol *msymbol = exp->elts[pc + 2].msymbol;
- value *val = evaluate_var_msym_value (noside,
- exp->elts[pc + 1].objfile,
- msymbol);
+ value *mval = evaluate_var_msym_value (noside,
+ exp->elts[pc + 1].objfile,
+ msymbol);
- type = value_type (val);
- if (TYPE_CODE (type) == TYPE_CODE_ERROR)
- error_unknown_type (MSYMBOL_PRINT_NAME (msymbol));
+ type = value_type (mval);
+ if (type->code () == TYPE_CODE_ERROR)
+ error_unknown_type (msymbol->print_name ());
return value_from_longest (size_type, TYPE_LENGTH (type));
}
/* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
type of the subscript is a variable length array type. In this case we
- must re-evaluate the right hand side of the subcription to allow
+ must re-evaluate the right hand side of the subscription to allow
side-effects. */
case BINOP_SUBSCRIPT:
if (noside == EVAL_NORMAL)
{
- int pc = (*pos) + 1;
+ int npc = (*pos) + 1;
- val = evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
+ val = evaluate_subexp (NULL_TYPE, exp, &npc, EVAL_AVOID_SIDE_EFFECTS);
type = check_typedef (value_type (val));
- if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ if (type->code () == TYPE_CODE_ARRAY)
{
type = check_typedef (TYPE_TARGET_TYPE (type));
- if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ if (type->code () == TYPE_CODE_ARRAY)
{
type = TYPE_INDEX_TYPE (type);
/* Only re-evaluate the right hand side if the resulting type
int ndimen = 1;
struct type *tmp_type;
- if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
+ 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 (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY)
+ if (tmp_type->code () == TYPE_CODE_ARRAY)
++ndimen;
}
return ndimen;
projects / deliverable / binutils-gdb.git / blobdiff