29#include "gdbsupport/byte-vector.h"
40#ifndef TRUNCATION_TOWARDS_ZERO
41#define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
54 struct type *ptr_target;
56 gdb_assert (ptr_type->
code () == TYPE_CODE_PTR);
62 if (ptr_type->
code () == TYPE_CODE_VOID)
70 error (_(
"Cannot perform pointer math on incomplete types, "
71 "try casting to a known type, or void *."));
73 error (_(
"Cannot perform pointer math on incomplete type \"%s\", "
74 "try casting to a known type, or void *."),
name);
86 struct type *valptrtype;
107 struct type *type1, *type2;
115 gdb_assert (type1->
code () == TYPE_CODE_PTR);
116 gdb_assert (type2->
code () == TYPE_CODE_PTR);
120 error (_(
"First argument of `-' is a pointer and "
121 "second argument is neither\n"
122 "an integer nor a pointer of the same type."));
127 warning (_(
"Type size unknown, assuming 1. "
128 "Try casting to a known type, or void *."));
154 if (tarray->
code () == TYPE_CODE_ARRAY
155 || tarray->
code () == TYPE_CODE_STRING)
159 if (!lowerbound.has_value ())
165 gdb::optional<LONGEST> upperbound
168 if (!upperbound.has_value ())
171 if (index >= *lowerbound && index <= *upperbound)
178 if (*upperbound > -1)
179 warning (_(
"array or string index out of range"));
184 index -= *lowerbound;
191 error (_(
"not an array or string"));
213 elt_size = stride / (unit_size * 8);
216 LONGEST elt_offs = elt_size * (index - lowerbound);
217 bool array_upper_bound_undefined
220 if (index < lowerbound
221 || (!array_upper_bound_undefined
226 error (_(
"no such vector element (vector not associated)"));
228 error (_(
"no such vector element (vector not allocated)"));
230 error (_(
"no such vector element"));
253 struct type *type1,
struct type *type2)
255 if (op == BINOP_ASSIGN)
266 return (type1->
code () == TYPE_CODE_STRUCT
267 || type2->
code () == TYPE_CODE_STRUCT);
299 return type1->
code () == TYPE_CODE_STRUCT;
315 struct symbol *symp = NULL;
316 struct value *valp = NULL;
321 &valp, &symp, static_memfuncp, 0,
noside);
335 error (_(
"Could not find %s."), oper);
345 struct value *result = NULL;
383 error (_(
"Can't do that binary op on that type"));
385 value *argvec_storage[3];
386 gdb::array_view<value *> argvec = argvec_storage;
392 strcpy (tstr,
"operator__");
417 case BINOP_BITWISE_AND:
420 case BINOP_BITWISE_IOR:
423 case BINOP_BITWISE_XOR:
426 case BINOP_LOGICAL_AND:
429 case BINOP_LOGICAL_OR:
441 case BINOP_ASSIGN_MODIFY:
459 case BINOP_BITWISE_AND:
462 case BINOP_BITWISE_IOR:
465 case BINOP_BITWISE_XOR:
470 error (_(
"Invalid binary operation specified."));
473 case BINOP_SUBSCRIPT:
496 error (_(
"Invalid binary operation specified."));
500 &static_memfuncp,
noside);
506 argvec[1] = argvec[0];
507 argvec = argvec.slice (1);
512 gdb_assert (static_memfuncp == 0);
515 struct type *return_type
518 if (return_type == NULL)
519 error (_(
"Xmethod is missing return type."));
526 struct type *return_type;
532 argvec.slice (1, 2 - static_memfuncp));
534 throw_error (NOT_FOUND_ERROR,
535 _(
"member function %s not found"), tstr);
549 char tstr[13], mangle_tstr[13];
550 int static_memfuncp, nargs;
558 error (_(
"Can't do that unary op on that type"));
560 value *argvec_storage[3];
561 gdb::array_view<value *> argvec = argvec_storage;
569 strcpy (tstr,
"operator__");
571 strcpy (mangle_tstr,
"__");
574 case UNOP_PREINCREMENT:
577 case UNOP_PREDECREMENT:
580 case UNOP_POSTINCREMENT:
585 case UNOP_POSTDECREMENT:
590 case UNOP_LOGICAL_NOT:
593 case UNOP_COMPLEMENT:
609 error (_(
"Invalid unary operation specified."));
613 &static_memfuncp,
noside);
619 argvec[1] = argvec[0];
620 argvec = argvec.slice (1);
625 gdb_assert (static_memfuncp == 0);
628 struct type *return_type
631 if (return_type == NULL)
632 error (_(
"Xmethod is missing return type."));
639 struct type *return_type;
645 argvec.slice (1, nargs));
647 throw_error (NOT_FOUND_ERROR,
648 _(
"member function %s not found"), tstr);
662 if (type1->
code () != TYPE_CODE_ARRAY && type2->
code () != TYPE_CODE_ARRAY)
663 error (
"no array provided to concatenation");
666 struct type *elttype1 = type1;
667 if (elttype1->
code () == TYPE_CODE_ARRAY)
671 error (_(
"could not determine array bounds on left-hand-side of "
672 "array concatenation"));
681 struct type *elttype2 = type2;
682 if (elttype2->
code () == TYPE_CODE_ARRAY)
686 error (_(
"could not determine array bounds on right-hand-side of "
687 "array concatenation"));
696 error (_(
"concatenation with different element types"));
699 LONGEST n_elts = (high1 - low1 + 1) + (high2 - low2 + 1);
702 lowbound + n_elts - 1);
706 gdb::array_view<const gdb_byte> lhs_contents =
value_contents (arg1);
707 gdb::array_view<const gdb_byte> rhs_contents =
value_contents (arg2);
708 gdb::copy (lhs_contents,
contents.slice (0, lhs_contents.size ()));
709 gdb::copy (rhs_contents,
contents.slice (lhs_contents.size ()));
723 error (_(
"Attempt to raise 0 to negative power."));
749 gdb_byte *x,
struct type **eff_type_x,
750 gdb_byte *y,
struct type **eff_type_y)
752 struct type *type1, *type2;
761 && type1->
code () != type2->
code ())
765 error (_(
"Mixing decimal floating types with "
766 "other floating types is not allowed."));
784 error (_(
"Don't know how to convert from %s to %s."), type1->
name (),
803 error (_(
"Don't know how to convert from %s to %s."), type1->
name (),
824 if (op == BINOP_MUL || op == BINOP_DIV)
855 auto fixed_point_to_value = [type1] (
const gdb_mpq &fp)
872 val = fixed_point_to_value (res);
877 val = fixed_point_to_value (res);
881 val = fixed_point_to_value (mpq_cmp (v1.
val, v2.
val) < 0 ? v1 : v2);
885 val = fixed_point_to_value (mpq_cmp (v1.
val, v2.
val) > 0 ? v1 : v2);
890 val = fixed_point_to_value (res);
894 if (mpq_sgn (v2.
val) == 0)
895 error (_(
"Division by zero"));
897 val = fixed_point_to_value (res);
902 mpq_cmp (v1.
val, v2.
val) == 0 ? 1 : 0);
907 mpq_cmp (v1.
val, v2.
val) < 0 ? 1 : 0);
911 error (_(
"Integer-only operation on fixed point number."));
923 struct type *result_type;
967 struct value *arg1_real, *arg1_imag, *arg2_real, *arg2_imag;
968 if (arg1_type->
code () == TYPE_CODE_COMPLEX)
978 if (arg2_type->
code () == TYPE_CODE_COMPLEX)
992 error (_(
"Argument to complex arithmetic operation not supported."));
994 arg1_real =
value_cast (comp_type, arg1_real);
995 arg1_imag =
value_cast (comp_type, arg1_imag);
996 arg2_real =
value_cast (comp_type, arg2_real);
997 arg2_imag =
value_cast (comp_type, arg2_imag);
1001 struct value *result_real, *result_imag;
1024 if (arg2_type->
code () == TYPE_CODE_COMPLEX)
1047 case BINOP_NOTEQUAL:
1055 if (op == BINOP_EQUAL)
1065 error (_(
"Invalid binary operation on numbers."));
1091 type *shift_count_type, ULONGEST shift_count)
1093 if (!shift_count_type->
is_unsigned () && (LONGEST) shift_count < 0)
1095 auto error_or_warning = [] (
const char *msg)
1101 error ((
"%s"), msg);
1103 warning ((
"%s"), msg);
1106 if (op == BINOP_RSH)
1107 error_or_warning (_(
"right shift count is negative"));
1109 error_or_warning (_(
"left shift count is negative"));
1120 if (op == BINOP_RSH)
1121 warning (_(
"right shift count >= width of type"));
1123 warning (_(
"left shift count >= width of type"));
1137static struct value *
1141 struct type *type1, *type2, *result_type;
1149 if (type1->
code () == TYPE_CODE_COMPLEX
1150 || type2->
code () == TYPE_CODE_COMPLEX)
1159 error (_(
"Argument to arithmetic operation not a number or boolean."));
1169 struct type *eff_type_v1, *eff_type_v2;
1170 gdb::byte_vector v1, v2;
1171 v1.resize (result_type->
length ());
1172 v2.resize (result_type->
length ());
1175 v1.data (), &eff_type_v1,
1176 v2.data (), &eff_type_v2);
1178 v2.data (), eff_type_v2,
1181 else if (type1->
code () == TYPE_CODE_BOOL
1182 || type2->
code () == TYPE_CODE_BOOL)
1184 LONGEST v1, v2, v = 0;
1191 case BINOP_BITWISE_AND:
1195 case BINOP_BITWISE_IOR:
1199 case BINOP_BITWISE_XOR:
1207 case BINOP_NOTEQUAL:
1212 error (_(
"Invalid operation on booleans."));
1215 result_type = type1;
1232 if (op == BINOP_RSH || op == BINOP_LSH || op == BINOP_EXP)
1233 result_type = type1;
1240 ULONGEST v1, v2, v = 0;
1243 v2 = (ULONGEST) v2_signed;
1264 error (_(
"Division by zero"));
1275 error (_(
"Division by zero"));
1307 case BINOP_BITWISE_AND:
1311 case BINOP_BITWISE_IOR:
1315 case BINOP_BITWISE_XOR:
1319 case BINOP_LOGICAL_AND:
1323 case BINOP_LOGICAL_OR:
1328 v = v1 < v2 ? v1 : v2;
1332 v = v1 > v2 ? v1 : v2;
1339 case BINOP_NOTEQUAL:
1360 error (_(
"Invalid binary operation on numbers."));
1371 LONGEST v1, v2, v = 0;
1386 v = (ULONGEST)v1 - (ULONGEST)v2;
1398 error (_(
"Division by zero"));
1409 error (_(
"Division by zero"));
1443 v = (ULONGEST) v1 << v2;
1468 case BINOP_BITWISE_AND:
1472 case BINOP_BITWISE_IOR:
1476 case BINOP_BITWISE_XOR:
1480 case BINOP_LOGICAL_AND:
1484 case BINOP_LOGICAL_OR:
1489 v = v1 < v2 ? v1 : v2;
1493 v = v1 > v2 ? v1 : v2;
1500 case BINOP_NOTEQUAL:
1521 error (_(
"Invalid binary operation on numbers."));
1545 struct type *eltype, *scalar_type;
1546 struct value *elval;
1547 LONGEST low_bound, high_bound;
1552 gdb_assert (vector_type->
code () == TYPE_CODE_ARRAY
1556 error (_(
"Could not determine the vector bounds"));
1567 error (_(
"conversion of scalar to vector involves truncation"));
1571 int elt_len = eltype->
length ();
1573 for (i = 0; i < high_bound - low_bound + 1; i++)
1576 val_contents.slice (i * elt_len, elt_len));
1584static struct value *
1587 struct type *type1, *type2, *eltype1, *eltype2;
1588 int t1_is_vec, t2_is_vec, elsize, i;
1589 LONGEST low_bound1, high_bound1, low_bound2, high_bound2;
1594 t1_is_vec = (type1->
code () == TYPE_CODE_ARRAY
1596 t2_is_vec = (type2->
code () == TYPE_CODE_ARRAY
1599 if (!t1_is_vec || !t2_is_vec)
1600 error (_(
"Vector operations are only supported among vectors"));
1604 error (_(
"Could not determine the vector bounds"));
1608 elsize = eltype1->
length ();
1610 if (eltype1->
code () != eltype2->
code ()
1611 || elsize != eltype2->
length ()
1613 || low_bound1 != low_bound2 || high_bound1 != high_bound2)
1614 error (_(
"Cannot perform operation on vectors with different types"));
1619 for (i = 0; i < high_bound1 - low_bound1 + 1; i++)
1624 val_contents.slice (i * elsize, elsize));
1638 int t1_is_vec = (type1->
code () == TYPE_CODE_ARRAY
1640 int t2_is_vec = (type2->
code () == TYPE_CODE_ARRAY
1643 if (!t1_is_vec && !t2_is_vec)
1645 else if (t1_is_vec && t2_is_vec)
1650 struct value **v = t1_is_vec ? &arg2 : &arg1;
1651 struct type *t = t1_is_vec ? type2 : type1;
1653 if (t->
code () != TYPE_CODE_FLT
1654 && t->
code () != TYPE_CODE_DECFLOAT
1656 error (_(
"Argument to operation not a number or boolean."));
1704 int i, len = len1 < len2 ? len1 : len2;
1706 for (i = 0; i < len; i++)
1710 else if (
s1[i] >
s2[i])
1718 else if (len1 > len2)
1733 struct type *type1, *type2;
1736 int is_int1, is_int2;
1743 code1 = type1->
code ();
1744 code2 = type2->
code ();
1748 if (is_int1 && is_int2)
1754 struct type *eff_type_v1, *eff_type_v2;
1755 gdb::byte_vector v1, v2;
1756 v1.resize (std::max (type1->
length (), type2->
length ()));
1757 v2.resize (std::max (type1->
length (), type2->
length ()));
1760 v1.data (), &eff_type_v1,
1761 v2.data (), &eff_type_v2);
1764 v2.data (), eff_type_v2) == 0;
1769 else if (code1 == TYPE_CODE_PTR && is_int2)
1771 else if (code2 == TYPE_CODE_PTR && is_int1)
1774 else if (code1 == code2
1775 && ((len = (
int) type1->
length ())
1776 == (
int) type2->
length ()))
1787 else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1792 error (_(
"Invalid type combination in equality test."));
1802 struct type *type1, *type2;
1807 return (type1->
code () == type2->
code ()
1822 struct type *type1, *type2;
1823 int is_int1, is_int2;
1830 code1 = type1->
code ();
1831 code2 = type2->
code ();
1835 if ((is_int1 && is_int2)
1842 struct type *eff_type_v1, *eff_type_v2;
1843 gdb::byte_vector v1, v2;
1844 v1.resize (std::max (type1->
length (), type2->
length ()));
1845 v2.resize (std::max (type1->
length (), type2->
length ()));
1848 v1.data (), &eff_type_v1,
1849 v2.data (), &eff_type_v2);
1852 v2.data (), eff_type_v2) == -1;
1854 else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
1859 else if (code1 == TYPE_CODE_PTR && is_int2)
1861 else if (code2 == TYPE_CODE_PTR && is_int1)
1863 else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1867 error (_(
"Invalid type combination in ordering comparison."));
1884 ||
type->
code () == TYPE_CODE_COMPLEX)
1887 error (_(
"Argument to positive operation not a number."));
1907 LONGEST low_bound, high_bound;
1910 error (_(
"Could not determine the vector bounds"));
1913 int elt_len = eltype->
length ();
1915 for (i = 0; i < high_bound - low_bound + 1; i++)
1919 val_contents.slice (i * elt_len, elt_len));
1923 else if (
type->
code () == TYPE_CODE_COMPLEX)
1933 error (_(
"Argument to negate operation not a number."));
1951 LONGEST low_bound, high_bound;
1954 error (_(
"Could not determine the vector bounds"));
1958 int elt_len = eltype->
length ();
1960 for (i = 0; i < high_bound - low_bound + 1; i++)
1964 val_contents.slice (i * elt_len, elt_len));
1967 else if (
type->
code () == TYPE_CODE_COMPLEX)
1978 error (_(
"Argument to complement operation not an integer, boolean."));
1991 LONGEST low_bound, high_bound;
1998 if (index < low_bound || index > high_bound)
2000 rel_index = index - low_bound;
2003 rel_index %= TARGET_CHAR_BIT;
2005 rel_index = TARGET_CHAR_BIT - 1 - rel_index;
2006 return (word >> rel_index) & 1;
2016 if (eltype->
code () == TYPE_CODE_RANGE)
2018 if (settype->
code () != TYPE_CODE_SET)
2019 error (_(
"Second argument of 'IN' has wrong type"));
2020 if (eltype->
code () != TYPE_CODE_INT
2021 && eltype->
code () != TYPE_CODE_CHAR
2022 && eltype->
code () != TYPE_CODE_ENUM
2023 && eltype->
code () != TYPE_CODE_BOOL)
2024 error (_(
"First argument of 'IN' has wrong type"));
2028 error (_(
"First argument of 'IN' not in range"));
constexpr std::string_view s1
constexpr std::string_view s2
static void store_signed_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, LONGEST val)
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
int longest_to_int(LONGEST)
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
@ EVAL_AVOID_SIDE_EFFECTS
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
int gdbarch_addressable_memory_unit_size(struct gdbarch *gdbarch)
struct type * resolve_dynamic_type(struct type *type, gdb::array_view< const gdb_byte > valaddr, CORE_ADDR addr)
enum bfd_endian type_byte_order(const struct type *type)
int is_integral_type(struct type *t)
int is_floating_type(struct type *t)
int is_dynamic_type(struct type *type)
struct type * lookup_array_range_type(struct type *element_type, LONGEST low_bound, LONGEST high_bound)
bool get_discrete_bounds(struct type *type, LONGEST *lowp, LONGEST *highp)
gdb::optional< LONGEST > get_discrete_high_bound(struct type *type)
gdb::optional< LONGEST > get_discrete_low_bound(struct type *type)
bool get_array_bounds(struct type *type, LONGEST *low_bound, LONGEST *high_bound)
int type_not_associated(const struct type *type)
unsigned int type_length_units(struct type *type)
bool types_equal(struct type *a, struct type *b)
struct type * init_complex_type(const char *name, struct type *target_type)
bool is_fixed_point_type(struct type *type)
int type_not_allocated(const struct type *type)
struct type * check_typedef(struct type *type)
bool can_create_complex_type(struct type *target_type)
#define TYPE_IS_REFERENCE(t)
struct value * call_function_by_hand(struct value *function, type *default_return_type, gdb::array_view< value * > args)
const struct language_defn * current_language
struct type * language_bool_type(const struct language_defn *la, struct gdbarch *gdbarch)
dynamic_prop_kind kind() const
void read_fixed_point(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order, bool unsigned_p, const gdb_mpq &scaling_factor)
enum language la_language
virtual bool c_style_arrays_p() const
struct type * target_type() const
ULONGEST bit_stride() const
const gdb_mpq & fixed_point_scaling_factor()
range_bounds * bounds() const
const char * name() const
type * index_type() const
gdb::unique_xmalloc_ptr< gdb_byte > contents
int target_float_compare(const gdb_byte *x, const struct type *type_x, const gdb_byte *y, const struct type *type_y)
bool target_float_is_zero(const gdb_byte *addr, const struct type *type)
void target_float_binop(enum exp_opcode opcode, const gdb_byte *x, const struct type *type_x, const gdb_byte *y, const struct type *type_y, gdb_byte *res, const struct type *type_res)
void target_float_from_longest(gdb_byte *addr, const struct type *type, LONGEST val)
void target_float_from_ulongest(gdb_byte *addr, const struct type *type, ULONGEST val)
ULONGEST uinteger_pow(ULONGEST v1, LONGEST v2)
static LONGEST find_size_for_pointer_math(struct type *ptr_type)
int value_equal_contents(struct value *arg1, struct value *arg2)
bool value_logical_not(struct value *arg1)
int value_in(struct value *element, struct value *set)
struct value * value_subscript(struct value *array, LONGEST index)
struct value * value_x_binop(struct value *arg1, struct value *arg2, enum exp_opcode op, enum exp_opcode otherop, enum noside noside)
struct value * value_neg(struct value *arg1)
static struct value * complex_binop(struct value *arg1, struct value *arg2, enum exp_opcode op)
static int type_length_bits(type *type)
#define TRUNCATION_TOWARDS_ZERO
static struct type * promotion_type(struct type *type1, struct type *type2)
static struct value * scalar_binop(struct value *arg1, struct value *arg2, enum exp_opcode op)
struct value * value_x_unop(struct value *arg1, enum exp_opcode op, enum noside noside)
static struct value * value_user_defined_op(struct value **argp, gdb::array_view< value * > args, char *name, int *static_memfuncp, enum noside noside)
static struct value * value_subscripted_rvalue(struct value *array, LONGEST index, LONGEST lowerbound)
struct value * value_complement(struct value *arg1)
struct value * value_pos(struct value *arg1)
static struct value * value_user_defined_cpp_op(gdb::array_view< value * > args, char *oper, int *static_memfuncp, enum noside noside)
static int value_strcmp(struct value *arg1, struct value *arg2)
struct value * value_vector_widen(struct value *scalar_value, struct type *vector_type)
int binop_user_defined_p(enum exp_opcode op, struct value *arg1, struct value *arg2)
static struct value * fixed_point_binop(struct value *arg1, struct value *arg2, enum exp_opcode op)
static struct value * vector_binop(struct value *val1, struct value *val2, enum exp_opcode op)
static LONGEST integer_pow(LONGEST v1, LONGEST v2)
int value_equal(struct value *arg1, struct value *arg2)
int binop_types_user_defined_p(enum exp_opcode op, struct type *type1, struct type *type2)
int value_less(struct value *arg1, struct value *arg2)
struct value * value_concat(struct value *arg1, struct value *arg2)
struct value * value_ptradd(struct value *arg1, LONGEST arg2)
LONGEST value_ptrdiff(struct value *arg1, struct value *arg2)
int value_bit_index(struct type *type, const gdb_byte *valaddr, int index)
static void value_args_as_target_float(struct value *arg1, struct value *arg2, gdb_byte *x, struct type **eff_type_x, gdb_byte *y, struct type **eff_type_y)
struct value * value_binop(struct value *arg1, struct value *arg2, enum exp_opcode op)
static bool check_valid_shift_count(int op, type *result_type, type *shift_count_type, ULONGEST shift_count)
int unop_user_defined_p(enum exp_opcode op, struct value *arg1)
struct value * value_coerce_array(struct value *arg1)
struct value * value_struct_elt(struct value **argp, gdb::optional< gdb::array_view< value * > > args, const char *name, int *static_memfuncp, const char *err)
struct value * value_of_variable(struct symbol *var, const struct block *b)
struct value * value_addr(struct value *arg1)
struct value * value_cast(struct type *type, struct value *arg2)
struct value * value_real_part(struct value *value)
struct value * value_ind(struct value *arg1)
struct value * value_literal_complex(struct value *arg1, struct value *arg2, struct type *type)
gdb_mpq value_to_gdb_mpq(struct value *value)
struct value * value_imaginary_part(struct value *value)
int find_overload_match(gdb::array_view< value * > args, const char *name, enum oload_search_type method, struct value **objp, struct symbol *fsym, struct value **valp, struct symbol **symp, int *staticp, const int no_adl, const enum noside noside)
struct type * value_type(const struct value *value)
struct value * value_from_component(struct value *whole, struct type *type, LONGEST offset)
struct value * value_zero(struct type *type, enum lval_type lv)
gdb::array_view< const gdb_byte > value_contents_all(struct value *value)
bool is_floating_value(struct value *val)
struct value * allocate_value(struct type *type)
CORE_ADDR value_as_address(struct value *val)
void set_value_component_location(struct value *component, const struct value *whole)
struct value * value_from_ulongest(struct type *type, ULONGEST num)
CORE_ADDR value_address(const struct value *value)
struct value * value_from_longest(struct type *type, LONGEST num)
gdb::array_view< gdb_byte > value_contents_raw(struct value *value)
struct value * coerce_ref(struct value *arg)
struct value * value_from_contents(struct type *type, const gdb_byte *contents)
struct value * coerce_array(struct value *arg)
gdb::array_view< const gdb_byte > value_contents(struct value *value)
gdb::array_view< gdb_byte > value_contents_writeable(struct value *value)
struct type * result_type_of_xmethod(struct value *method, gdb::array_view< value * > argv)
LONGEST value_as_long(struct value *val)
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
struct value * call_xmethod(struct value *method, gdb::array_view< value * > argv)