/* Perform arithmetic and other operations on values, for GDB.
- Copyright (C) 1986-2014 Free Software Foundation, Inc.
+ Copyright (C) 1986-2016 Free Software Foundation, Inc.
This file is part of GDB.
#include "dfp.h"
#include <math.h>
#include "infcall.h"
-#include "exceptions.h"
/* Define whether or not the C operator '/' truncates towards zero for
differently signed operands (truncation direction is undefined in C). */
gdb_assert (TYPE_CODE (ptr_type) == TYPE_CODE_PTR);
ptr_target = check_typedef (TYPE_TARGET_TYPE (ptr_type));
- sz = TYPE_LENGTH (ptr_target);
+ sz = type_length_units (ptr_target);
if (sz == 0)
{
if (TYPE_CODE (ptr_type) == TYPE_CODE_VOID)
"second argument is neither\n"
"an integer nor a pointer of the same type."));
- sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
+ sz = type_length_units (check_typedef (TYPE_TARGET_TYPE (type1)));
if (sz == 0)
{
warning (_("Type size unknown, assuming 1. "
{
struct type *array_type = check_typedef (value_type (array));
struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
- unsigned int elt_size = TYPE_LENGTH (elt_type);
+ unsigned int elt_size = type_length_units (elt_type);
unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
struct value *v;
if (index < lowerbound || (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type)
- && elt_offs >= TYPE_LENGTH (array_type)))
- error (_("no such vector element"));
+ && elt_offs >= type_length_units (array_type)))
+ {
+ if (type_not_associated (array_type))
+ error (_("no such vector element (vector not associated)"));
+ else if (type_not_allocated (array_type))
+ error (_("no such vector element (vector not allocated)"));
+ else
+ error (_("no such vector element"));
+ }
if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
v = allocate_value_lazy (elt_type);
situations or combinations thereof. */
static struct value *
-value_user_defined_cpp_op (struct value **args, int nargs, char *operator,
- int *static_memfuncp)
+value_user_defined_cpp_op (struct value **args, int nargs, char *oper,
+ int *static_memfuncp, enum noside noside)
{
struct symbol *symp = NULL;
struct value *valp = NULL;
- find_overload_match (args, nargs, operator, BOTH /* could be method */,
+ find_overload_match (args, nargs, oper, BOTH /* could be method */,
&args[0] /* objp */,
NULL /* pass NULL symbol since symbol is unknown */,
- &valp, &symp, static_memfuncp, 0);
+ &valp, &symp, static_memfuncp, 0, noside);
if (valp)
return valp;
return value_of_variable (symp, 0);
}
- error (_("Could not find %s."), operator);
+ error (_("Could not find %s."), oper);
}
/* Lookup user defined operator NAME. Return a value representing the
static struct value *
value_user_defined_op (struct value **argp, struct value **args, char *name,
- int *static_memfuncp, int nargs)
+ int *static_memfuncp, int nargs, enum noside noside)
{
struct value *result = NULL;
if (current_language->la_language == language_cplus)
- result = value_user_defined_cpp_op (args, nargs, name, static_memfuncp);
+ {
+ result = value_user_defined_cpp_op (args, nargs, name, static_memfuncp,
+ noside);
+ }
else
result = value_struct_elt (argp, args, name, static_memfuncp,
"structure");
}
argvec[0] = value_user_defined_op (&arg1, argvec + 1, tstr,
- &static_memfuncp, 2);
+ &static_memfuncp, 2, noside);
if (argvec[0])
{
argvec[1] = argvec[0];
argvec++;
}
+ if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_XMETHOD)
+ {
+ /* Static xmethods are not supported yet. */
+ gdb_assert (static_memfuncp == 0);
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ {
+ struct type *return_type
+ = result_type_of_xmethod (argvec[0], 2, argvec + 1);
+
+ if (return_type == NULL)
+ error (_("Xmethod is missing return type."));
+ return value_zero (return_type, VALUE_LVAL (arg1));
+ }
+ return call_xmethod (argvec[0], 2, argvec + 1);
+ }
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
struct type *return_type;
= TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
return value_zero (return_type, VALUE_LVAL (arg1));
}
-
- if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_XMETHOD)
- {
- /* Static xmethods are not supported yet. */
- gdb_assert (static_memfuncp == 0);
- return call_xmethod (argvec[0], 2, argvec + 1);
- }
- else
- return call_function_by_hand (argvec[0], 2 - static_memfuncp,
- argvec + 1);
+ return call_function_by_hand (argvec[0], 2 - static_memfuncp,
+ argvec + 1);
}
throw_error (NOT_FOUND_ERROR,
_("member function %s not found"), tstr);
}
argvec[0] = value_user_defined_op (&arg1, argvec + 1, tstr,
- &static_memfuncp, nargs);
+ &static_memfuncp, nargs, noside);
if (argvec[0])
{
nargs --;
argvec++;
}
+ if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_XMETHOD)
+ {
+ /* Static xmethods are not supported yet. */
+ gdb_assert (static_memfuncp == 0);
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ {
+ struct type *return_type
+ = result_type_of_xmethod (argvec[0], 1, argvec + 1);
+
+ if (return_type == NULL)
+ error (_("Xmethod is missing return type."));
+ return value_zero (return_type, VALUE_LVAL (arg1));
+ }
+ return call_xmethod (argvec[0], 1, argvec + 1);
+ }
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
struct type *return_type;
= TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
return value_zero (return_type, VALUE_LVAL (arg1));
}
- if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_XMETHOD)
- {
- /* Static xmethods are not supported yet. */
- gdb_assert (static_memfuncp == 0);
- return call_xmethod (argvec[0], 1, argvec + 1);
- }
- else
- return call_function_by_hand (argvec[0], nargs, argvec + 1);
+ return call_function_by_hand (argvec[0], nargs, argvec + 1);
}
throw_error (NOT_FOUND_ERROR,
_("member function %s not found"), tstr);
LONGEST low_bound, high_bound;
int i;
- CHECK_TYPEDEF (vector_type);
+ vector_type = check_typedef (vector_type);
gdb_assert (TYPE_CODE (vector_type) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (vector_type));
projects / deliverable / binutils-gdb.git / blobdiff