/* Perform non-arithmetic operations on values, for GDB.
- Copyright (C) 1986-2019 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 Free Software Foundation, Inc.
This file is part of GDB.
#include "observable.h"
#include "objfiles.h"
#include "extension.h"
-#include "byte-vector.h"
+#include "gdbtypes.h"
+#include "gdbsupport/byte-vector.h"
-extern unsigned int overload_debug;
/* Local functions. */
static int typecmp (int staticp, int varargs, int nargs,
static struct value *cast_into_complex (struct type *, struct value *);
-int overload_resolution = 0;
+bool overload_resolution = false;
static void
show_overload_resolution (struct ui_file *file, int from_tty,
struct cmd_list_element *c,
"divide object size in cast"));
/* FIXME-type-allocation: need a way to free this type when
we are done with it. */
- range_type = create_static_range_type ((struct type *) NULL,
+ range_type = create_static_range_type (NULL,
TYPE_TARGET_TYPE (range_type),
low_bound,
new_length + low_bound - 1);
deprecated_set_value_type (arg2,
- create_array_type ((struct type *) NULL,
+ create_array_type (NULL,
element_type,
range_type));
return arg2;
if (code2 == TYPE_CODE_PTR)
longest = extract_unsigned_integer
(value_contents (arg2), TYPE_LENGTH (type2),
- gdbarch_byte_order (get_type_arch (type2)));
+ type_byte_order (type2));
else
longest = value_as_long (arg2);
return value_from_longest (to_type, convert_to_boolean ?
return value_at_lazy (to_type, value_address (arg2));
else
{
+ if (current_language->la_language == language_ada)
+ error (_("Invalid type conversion."));
error (_("Invalid cast."));
- return 0;
}
}
/* Return a value with type TYPE located at ADDR.
Call value_at only if the data needs to be fetched immediately;
- if we can be 'lazy' and defer the fetch, perhaps indefinately, call
+ if we can be 'lazy' and defer the fetch, perhaps indefinitely, call
value_at_lazy instead. value_at_lazy simply records the address of
the data and sets the lazy-evaluation-required flag. The lazy flag
is tested in the value_contents macro, which is used if and when
error (_("Address requested for identifier "
"\"%s\" which is in register $%s"),
- SYMBOL_PRINT_NAME (var), regname);
+ var->print_name (), regname);
break;
}
default:
error (_("Can't take address of \"%s\" which isn't an lvalue."),
- SYMBOL_PRINT_NAME (var));
+ var->print_name ());
break;
}
return val;
}
-/* Return one if VAL does not live in target memory, but should in order
- to operate on it. Otherwise return zero. */
+/* See value.h. */
-int
+bool
value_must_coerce_to_target (struct value *val)
{
struct type *valtype;
if (VALUE_LVAL (val) != not_lval
&& VALUE_LVAL (val) != lval_internalvar
&& VALUE_LVAL (val) != lval_xcallable)
- return 0;
+ return false;
valtype = check_typedef (value_type (val));
case TYPE_CODE_ARRAY:
return TYPE_VECTOR (valtype) ? 0 : 1;
case TYPE_CODE_STRING:
- return 1;
+ return true;
default:
- return 0;
+ return false;
}
}
int i;
struct value *v;
int name_matched = 0;
- char dem_opname[64];
type = check_typedef (type);
for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
{
const char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
- /* FIXME! May need to check for ARM demangling here. */
- if (startswith (t_field_name, "__") ||
- startswith (t_field_name, "op") ||
- startswith (t_field_name, "type"))
- {
- if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
- t_field_name = dem_opname;
- else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
- t_field_name = dem_opname;
- }
if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
{
int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
if (fsym)
{
- qualified_name = SYMBOL_NATURAL_NAME (fsym);
+ qualified_name = fsym->natural_name ();
/* If we have a function with a C++ name, try to extract just
the function part. Do not try this for non-functions (e.g.
contained in QUALIFIED_NAME until it either finds a good match or
runs out of namespaces. It stores the overloaded functions in
*OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. If NO_ADL,
- argument dependent lookup is not performned. */
+ argument dependent lookup is not performed. */
static int
find_oload_champ_namespace (gdb::array_view<value *> args,
bv = rank_function (parm_types,
args.slice (static_offset));
+ if (overload_debug)
+ {
+ if (methods != NULL)
+ fprintf_filtered (gdb_stderr,
+ "Overloaded method instance %s, # of parms %d\n",
+ methods[ix].physname, (int) parm_types.size ());
+ else if (xmethods != NULL)
+ fprintf_filtered (gdb_stderr,
+ "Xmethod worker, # of parms %d\n",
+ (int) parm_types.size ());
+ else
+ fprintf_filtered (gdb_stderr,
+ "Overloaded function instance "
+ "%s # of parms %d\n",
+ functions[ix]->demangled_name (),
+ (int) parm_types.size ());
+
+ fprintf_filtered (gdb_stderr,
+ "...Badness of length : {%d, %d}\n",
+ bv[0].rank, bv[0].subrank);
+
+ for (jj = 1; jj < bv.size (); jj++)
+ fprintf_filtered (gdb_stderr,
+ "...Badness of arg %d : {%d, %d}\n",
+ jj, bv[jj].rank, bv[jj].subrank);
+ }
+
if (oload_champ_bv->empty ())
{
*oload_champ_bv = std::move (bv);
break;
}
if (overload_debug)
- {
- if (methods != NULL)
- fprintf_filtered (gdb_stderr,
- "Overloaded method instance %s, # of parms %d\n",
- methods[ix].physname, (int) parm_types.size ());
- else if (xmethods != NULL)
- fprintf_filtered (gdb_stderr,
- "Xmethod worker, # of parms %d\n",
- (int) parm_types.size ());
- else
- fprintf_filtered (gdb_stderr,
- "Overloaded function instance "
- "%s # of parms %d\n",
- SYMBOL_DEMANGLED_NAME (functions[ix]),
- (int) parm_types.size ());
- for (jj = 0; jj < args.size () - static_offset; jj++)
- fprintf_filtered (gdb_stderr,
- "...Badness @ %d : %d\n",
- jj, bv[jj].rank);
- fprintf_filtered (gdb_stderr, "Overload resolution "
- "champion is %d, ambiguous? %d\n",
- oload_champ, oload_ambiguous);
- }
+ fprintf_filtered (gdb_stderr, "Overload resolution "
+ "champion is %d, ambiguous? %d\n",
+ oload_champ, oload_ambiguous);
}
return oload_champ;
for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
{
const char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
- char dem_opname[64];
- if (startswith (t_field_name, "__")
- || startswith (t_field_name, "op")
- || startswith (t_field_name, "type"))
- {
- if (cplus_demangle_opname (t_field_name,
- dem_opname, DMGL_ANSI))
- t_field_name = dem_opname;
- else if (cplus_demangle_opname (t_field_name,
- dem_opname, 0))
- t_field_name = dem_opname;
- }
if (t_field_name && strcmp (t_field_name, name) == 0)
{
int j;
else if (TYPE_CODE (type) == TYPE_CODE_PTR)
{
- TRY
+ try
{
target = value_ind (v);
}
- CATCH (except, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &except)
{
if (except.error == MEMORY_ERROR)
{
type. */
return NULL;
}
- throw_exception (except);
+ throw;
}
- END_CATCH
}
else
return NULL;
{
struct value *ret = NULL;
- TRY
+ try
{
ret = value_of_this (lang);
}
- CATCH (except, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &except)
{
}
- END_CATCH
return ret;
}
&& TYPE_CODE (array_type) != TYPE_CODE_STRING)
error (_("cannot take slice of non-array"));
+ if (type_not_allocated (array_type))
+ error (_("array not allocated"));
+ if (type_not_associated (array_type))
+ error (_("array not associated"));
+
range_type = TYPE_INDEX_TYPE (array_type);
if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
error (_("slice from bad array or bitstring"));
/* FIXME-type-allocation: need a way to free this type when we are
done with it. */
- slice_range_type = create_static_range_type ((struct type *) NULL,
+ slice_range_type = create_static_range_type (NULL,
TYPE_TARGET_TYPE (range_type),
lowbound,
lowbound + length - 1);
LONGEST offset
= (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
- slice_type = create_array_type ((struct type *) NULL,
+ slice_type = create_array_type (NULL,
element_type,
slice_range_type);
TYPE_CODE (slice_type) = TYPE_CODE (array_type);
/* Create a value for a FORTRAN complex number. Currently most of the
time values are coerced to COMPLEX*16 (i.e. a complex number
composed of 2 doubles. This really should be a smarter routine
- that figures out precision inteligently as opposed to assuming
+ that figures out precision intelligently as opposed to assuming
doubles. FIXME: fmb */
struct value *
projects / deliverable / binutils-gdb.git / blobdiff