/* Perform arithmetic and other operations on values, for GDB.
- Copyright (C) 1986-2013 Free Software Foundation, Inc.
+ Copyright (C) 1986-2017 Free Software Foundation, Inc.
This file is part of GDB.
#include "expression.h"
#include "target.h"
#include "language.h"
-#include "gdb_string.h"
#include "doublest.h"
#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_offs = elt_size * longest_to_int (index - lowerbound);
- struct value *v;
+ ULONGEST elt_size = type_length_units (elt_type);
+ ULONGEST elt_offs = elt_size * (index - lowerbound);
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);
- else
+ if (is_dynamic_type (elt_type))
{
- v = allocate_value (elt_type);
- value_contents_copy (v, value_embedded_offset (v),
- array, value_embedded_offset (array) + elt_offs,
- elt_size);
+ CORE_ADDR address;
+
+ address = value_address (array) + elt_offs;
+ elt_type = resolve_dynamic_type (elt_type, NULL, address);
}
- set_value_component_location (v, array);
- VALUE_REGNUM (v) = VALUE_REGNUM (array);
- VALUE_FRAME_ID (v) = VALUE_FRAME_ID (array);
- set_value_offset (v, value_offset (array) + elt_offs);
- return v;
+ return value_from_component (array, elt_type, elt_offs);
}
\f
return 0;
type1 = check_typedef (type1);
- if (TYPE_CODE (type1) == TYPE_CODE_REF)
+ if (TYPE_IS_REFERENCE (type1))
type1 = check_typedef (TYPE_TARGET_TYPE (type1));
type2 = check_typedef (type2);
- if (TYPE_CODE (type2) == TYPE_CODE_REF)
+ if (TYPE_IS_REFERENCE (type2))
type2 = check_typedef (TYPE_TARGET_TYPE (type2));
return (TYPE_CODE (type1) == TYPE_CODE_STRUCT
if (op == UNOP_ADDR)
return 0;
type1 = check_typedef (value_type (arg1));
- if (TYPE_CODE (type1) == TYPE_CODE_REF)
+ if (TYPE_IS_REFERENCE (type1))
type1 = check_typedef (TYPE_TARGET_TYPE (type1));
return TYPE_CODE (type1) == TYPE_CODE_STRUCT;
}
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));
}
- return call_function_by_hand (argvec[0], 2 - static_memfuncp,
+ return call_function_by_hand (argvec[0], NULL, 2 - static_memfuncp,
argvec + 1);
}
throw_error (NOT_FOUND_ERROR,
}
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));
}
- return call_function_by_hand (argvec[0], nargs, argvec + 1);
+ return call_function_by_hand (argvec[0], NULL, nargs, argvec + 1);
}
throw_error (NOT_FOUND_ERROR,
_("member function %s not found"), tstr);
if (TYPE_CODE (type2) == TYPE_CODE_STRING
|| TYPE_CODE (type2) == TYPE_CODE_CHAR)
{
- struct cleanup *back_to;
-
count = longest_to_int (value_as_long (inval1));
inval2len = TYPE_LENGTH (type2);
- ptr = (char *) xmalloc (count * inval2len);
- back_to = make_cleanup (xfree, ptr);
+ std::vector<char> ptr (count * inval2len);
if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
{
char_type = type2;
value_contents (inval2));
for (idx = 0; idx < count; idx++)
{
- *(ptr + idx) = inchar;
+ ptr[idx] = inchar;
}
}
else
for (idx = 0; idx < count; idx++)
{
- memcpy (ptr + (idx * inval2len), value_contents (inval2),
+ memcpy (&ptr[idx * inval2len], value_contents (inval2),
inval2len);
}
}
- outval = value_string (ptr, count * inval2len, char_type);
- do_cleanups (back_to);
+ outval = value_string (ptr.data (), count * inval2len, char_type);
}
else if (TYPE_CODE (type2) == TYPE_CODE_BOOL)
{
else if (TYPE_CODE (type1) == TYPE_CODE_STRING
|| TYPE_CODE (type1) == TYPE_CODE_CHAR)
{
- struct cleanup *back_to;
-
/* We have two character strings to concatenate. */
if (TYPE_CODE (type2) != TYPE_CODE_STRING
&& TYPE_CODE (type2) != TYPE_CODE_CHAR)
}
inval1len = TYPE_LENGTH (type1);
inval2len = TYPE_LENGTH (type2);
- ptr = (char *) xmalloc (inval1len + inval2len);
- back_to = make_cleanup (xfree, ptr);
+ std::vector<char> ptr (inval1len + inval2len);
if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
{
char_type = type1;
- *ptr = (char) unpack_long (type1, value_contents (inval1));
+ ptr[0] = (char) unpack_long (type1, value_contents (inval1));
}
else
{
char_type = TYPE_TARGET_TYPE (type1);
- memcpy (ptr, value_contents (inval1), inval1len);
+ memcpy (ptr.data (), value_contents (inval1), inval1len);
}
if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
{
- *(ptr + inval1len) =
+ ptr[inval1len] =
(char) unpack_long (type2, value_contents (inval2));
}
else
{
- memcpy (ptr + inval1len, value_contents (inval2), inval2len);
+ memcpy (&ptr[inval1len], value_contents (inval2), inval2len);
}
- outval = value_string (ptr, inval1len + inval2len, char_type);
- do_cleanups (back_to);
+ outval = value_string (ptr.data (), inval1len + inval2len, char_type);
}
else if (TYPE_CODE (type1) == TYPE_CODE_BOOL)
{
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