1 /* Perform arithmetic and other operations on values, for GDB.
3 Copyright (C) 1986-2022 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
27 #include "target-float.h"
29 #include "gdbsupport/byte-vector.h"
32 /* Forward declarations. */
33 static struct value
*value_subscripted_rvalue (struct value
*array
,
37 /* Define whether or not the C operator '/' truncates towards zero for
38 differently signed operands (truncation direction is undefined in C). */
40 #ifndef TRUNCATION_TOWARDS_ZERO
41 #define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
44 /* Given a pointer, return the size of its target.
45 If the pointer type is void *, then return 1.
46 If the target type is incomplete, then error out.
47 This isn't a general purpose function, but just a
48 helper for value_ptradd. */
51 find_size_for_pointer_math (struct type
*ptr_type
)
54 struct type
*ptr_target
;
56 gdb_assert (ptr_type
->code () == TYPE_CODE_PTR
);
57 ptr_target
= check_typedef (TYPE_TARGET_TYPE (ptr_type
));
59 sz
= type_length_units (ptr_target
);
62 if (ptr_type
->code () == TYPE_CODE_VOID
)
68 name
= ptr_target
->name ();
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
);
80 /* Given a pointer ARG1 and an integral value ARG2, return the
81 result of C-style pointer arithmetic ARG1 + ARG2. */
84 value_ptradd (struct value
*arg1
, LONGEST arg2
)
86 struct type
*valptrtype
;
90 arg1
= coerce_array (arg1
);
91 valptrtype
= check_typedef (value_type (arg1
));
92 sz
= find_size_for_pointer_math (valptrtype
);
94 result
= value_from_pointer (valptrtype
,
95 value_as_address (arg1
) + sz
* arg2
);
96 if (VALUE_LVAL (result
) != lval_internalvar
)
97 set_value_component_location (result
, arg1
);
101 /* Given two compatible pointer values ARG1 and ARG2, return the
102 result of C-style pointer arithmetic ARG1 - ARG2. */
105 value_ptrdiff (struct value
*arg1
, struct value
*arg2
)
107 struct type
*type1
, *type2
;
110 arg1
= coerce_array (arg1
);
111 arg2
= coerce_array (arg2
);
112 type1
= check_typedef (value_type (arg1
));
113 type2
= check_typedef (value_type (arg2
));
115 gdb_assert (type1
->code () == TYPE_CODE_PTR
);
116 gdb_assert (type2
->code () == TYPE_CODE_PTR
);
118 if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)))
119 != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2
))))
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."));
124 sz
= type_length_units (check_typedef (TYPE_TARGET_TYPE (type1
)));
127 warning (_("Type size unknown, assuming 1. "
128 "Try casting to a known type, or void *."));
132 return (value_as_long (arg1
) - value_as_long (arg2
)) / sz
;
135 /* Return the value of ARRAY[IDX].
137 ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING. If the
138 current language supports C-style arrays, it may also be TYPE_CODE_PTR.
140 See comments in value_coerce_array() for rationale for reason for
141 doing lower bounds adjustment here rather than there.
142 FIXME: Perhaps we should validate that the index is valid and if
143 verbosity is set, warn about invalid indices (but still use them). */
146 value_subscript (struct value
*array
, LONGEST index
)
148 bool c_style
= current_language
->c_style_arrays_p ();
151 array
= coerce_ref (array
);
152 tarray
= check_typedef (value_type (array
));
154 if (tarray
->code () == TYPE_CODE_ARRAY
155 || tarray
->code () == TYPE_CODE_STRING
)
157 struct type
*range_type
= tarray
->index_type ();
158 gdb::optional
<LONGEST
> lowerbound
= get_discrete_low_bound (range_type
);
159 if (!lowerbound
.has_value ())
162 if (VALUE_LVAL (array
) != lval_memory
)
163 return value_subscripted_rvalue (array
, index
, *lowerbound
);
165 gdb::optional
<LONGEST
> upperbound
166 = get_discrete_high_bound (range_type
);
168 if (!upperbound
.has_value ())
171 if (index
>= *lowerbound
&& index
<= *upperbound
)
172 return value_subscripted_rvalue (array
, index
, *lowerbound
);
176 /* Emit warning unless we have an array of unknown size.
177 An array of unknown size has lowerbound 0 and upperbound -1. */
178 if (*upperbound
> -1)
179 warning (_("array or string index out of range"));
180 /* fall doing C stuff */
184 index
-= *lowerbound
;
185 array
= value_coerce_array (array
);
189 return value_ind (value_ptradd (array
, index
));
191 error (_("not an array or string"));
194 /* Return the value of EXPR[IDX], expr an aggregate rvalue
195 (eg, a vector register). This routine used to promote floats
196 to doubles, but no longer does. */
198 static struct value
*
199 value_subscripted_rvalue (struct value
*array
, LONGEST index
,
202 struct type
*array_type
= check_typedef (value_type (array
));
203 struct type
*elt_type
= TYPE_TARGET_TYPE (array_type
);
204 LONGEST elt_size
= type_length_units (elt_type
);
206 /* Fetch the bit stride and convert it to a byte stride, assuming 8 bits
208 LONGEST stride
= array_type
->bit_stride ();
211 struct gdbarch
*arch
= elt_type
->arch ();
212 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
213 elt_size
= stride
/ (unit_size
* 8);
216 LONGEST elt_offs
= elt_size
* (index
- lowerbound
);
217 bool array_upper_bound_undefined
218 = array_type
->bounds ()->high
.kind () == PROP_UNDEFINED
;
220 if (index
< lowerbound
221 || (!array_upper_bound_undefined
222 && elt_offs
>= type_length_units (array_type
))
223 || (VALUE_LVAL (array
) != lval_memory
&& array_upper_bound_undefined
))
225 if (type_not_associated (array_type
))
226 error (_("no such vector element (vector not associated)"));
227 else if (type_not_allocated (array_type
))
228 error (_("no such vector element (vector not allocated)"));
230 error (_("no such vector element"));
233 if (is_dynamic_type (elt_type
))
237 address
= value_address (array
) + elt_offs
;
238 elt_type
= resolve_dynamic_type (elt_type
, {}, address
);
241 return value_from_component (array
, elt_type
, elt_offs
);
245 /* Check to see if either argument is a structure, or a reference to
246 one. This is called so we know whether to go ahead with the normal
247 binop or look for a user defined function instead.
249 For now, we do not overload the `=' operator. */
252 binop_types_user_defined_p (enum exp_opcode op
,
253 struct type
*type1
, struct type
*type2
)
255 if (op
== BINOP_ASSIGN
)
258 type1
= check_typedef (type1
);
259 if (TYPE_IS_REFERENCE (type1
))
260 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
262 type2
= check_typedef (type2
);
263 if (TYPE_IS_REFERENCE (type2
))
264 type2
= check_typedef (TYPE_TARGET_TYPE (type2
));
266 return (type1
->code () == TYPE_CODE_STRUCT
267 || type2
->code () == TYPE_CODE_STRUCT
);
270 /* Check to see if either argument is a structure, or a reference to
271 one. This is called so we know whether to go ahead with the normal
272 binop or look for a user defined function instead.
274 For now, we do not overload the `=' operator. */
277 binop_user_defined_p (enum exp_opcode op
,
278 struct value
*arg1
, struct value
*arg2
)
280 return binop_types_user_defined_p (op
, value_type (arg1
), value_type (arg2
));
283 /* Check to see if argument is a structure. This is called so
284 we know whether to go ahead with the normal unop or look for a
285 user defined function instead.
287 For now, we do not overload the `&' operator. */
290 unop_user_defined_p (enum exp_opcode op
, struct value
*arg1
)
296 type1
= check_typedef (value_type (arg1
));
297 if (TYPE_IS_REFERENCE (type1
))
298 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
299 return type1
->code () == TYPE_CODE_STRUCT
;
302 /* Try to find an operator named OPERATOR which takes NARGS arguments
303 specified in ARGS. If the operator found is a static member operator
304 *STATIC_MEMFUNP will be set to 1, and otherwise 0.
305 The search if performed through find_overload_match which will handle
306 member operators, non member operators, operators imported implicitly or
307 explicitly, and perform correct overload resolution in all of the above
308 situations or combinations thereof. */
310 static struct value
*
311 value_user_defined_cpp_op (gdb::array_view
<value
*> args
, char *oper
,
312 int *static_memfuncp
, enum noside noside
)
315 struct symbol
*symp
= NULL
;
316 struct value
*valp
= NULL
;
318 find_overload_match (args
, oper
, BOTH
/* could be method */,
320 NULL
/* pass NULL symbol since symbol is unknown */,
321 &valp
, &symp
, static_memfuncp
, 0, noside
);
328 /* This is a non member function and does not
329 expect a reference as its first argument
330 rather the explicit structure. */
331 args
[0] = value_ind (args
[0]);
332 return value_of_variable (symp
, 0);
335 error (_("Could not find %s."), oper
);
338 /* Lookup user defined operator NAME. Return a value representing the
339 function, otherwise return NULL. */
341 static struct value
*
342 value_user_defined_op (struct value
**argp
, gdb::array_view
<value
*> args
,
343 char *name
, int *static_memfuncp
, enum noside noside
)
345 struct value
*result
= NULL
;
347 if (current_language
->la_language
== language_cplus
)
349 result
= value_user_defined_cpp_op (args
, name
, static_memfuncp
,
353 result
= value_struct_elt (argp
, args
, name
, static_memfuncp
,
359 /* We know either arg1 or arg2 is a structure, so try to find the right
360 user defined function. Create an argument vector that calls
361 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
362 binary operator which is legal for GNU C++).
364 OP is the operator, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
365 is the opcode saying how to modify it. Otherwise, OTHEROP is
369 value_x_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
,
370 enum exp_opcode otherop
, enum noside noside
)
376 arg1
= coerce_ref (arg1
);
377 arg2
= coerce_ref (arg2
);
379 /* now we know that what we have to do is construct our
380 arg vector and find the right function to call it with. */
382 if (check_typedef (value_type (arg1
))->code () != TYPE_CODE_STRUCT
)
383 error (_("Can't do that binary op on that type")); /* FIXME be explicit */
385 value
*argvec_storage
[3];
386 gdb::array_view
<value
*> argvec
= argvec_storage
;
388 argvec
[1] = value_addr (arg1
);
391 /* Make the right function name up. */
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
:
468 case BINOP_MOD
: /* invalid */
470 error (_("Invalid binary operation specified."));
473 case BINOP_SUBSCRIPT
:
494 case BINOP_MOD
: /* invalid */
496 error (_("Invalid binary operation specified."));
499 argvec
[0] = value_user_defined_op (&arg1
, argvec
.slice (1), tstr
,
500 &static_memfuncp
, noside
);
506 argvec
[1] = argvec
[0];
507 argvec
= argvec
.slice (1);
509 if (value_type (argvec
[0])->code () == TYPE_CODE_XMETHOD
)
511 /* Static xmethods are not supported yet. */
512 gdb_assert (static_memfuncp
== 0);
513 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
515 struct type
*return_type
516 = result_type_of_xmethod (argvec
[0], argvec
.slice (1));
518 if (return_type
== NULL
)
519 error (_("Xmethod is missing return type."));
520 return value_zero (return_type
, VALUE_LVAL (arg1
));
522 return call_xmethod (argvec
[0], argvec
.slice (1));
524 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
526 struct type
*return_type
;
529 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
530 return value_zero (return_type
, VALUE_LVAL (arg1
));
532 return call_function_by_hand (argvec
[0], NULL
,
533 argvec
.slice (1, 2 - static_memfuncp
));
535 throw_error (NOT_FOUND_ERROR
,
536 _("member function %s not found"), tstr
);
539 /* We know that arg1 is a structure, so try to find a unary user
540 defined operator that matches the operator in question.
541 Create an argument vector that calls arg1.operator @ (arg1)
542 and return that value (where '@' is (almost) any unary operator which
543 is legal for GNU C++). */
546 value_x_unop (struct value
*arg1
, enum exp_opcode op
, enum noside noside
)
548 struct gdbarch
*gdbarch
= value_type (arg1
)->arch ();
550 char tstr
[13], mangle_tstr
[13];
551 int static_memfuncp
, nargs
;
553 arg1
= coerce_ref (arg1
);
555 /* now we know that what we have to do is construct our
556 arg vector and find the right function to call it with. */
558 if (check_typedef (value_type (arg1
))->code () != TYPE_CODE_STRUCT
)
559 error (_("Can't do that unary op on that type")); /* FIXME be explicit */
561 value
*argvec_storage
[3];
562 gdb::array_view
<value
*> argvec
= argvec_storage
;
564 argvec
[1] = value_addr (arg1
);
569 /* Make the right function name up. */
570 strcpy (tstr
, "operator__");
572 strcpy (mangle_tstr
, "__");
575 case UNOP_PREINCREMENT
:
578 case UNOP_PREDECREMENT
:
581 case UNOP_POSTINCREMENT
:
583 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
586 case UNOP_POSTDECREMENT
:
588 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
591 case UNOP_LOGICAL_NOT
:
594 case UNOP_COMPLEMENT
:
610 error (_("Invalid unary operation specified."));
613 argvec
[0] = value_user_defined_op (&arg1
, argvec
.slice (1, nargs
), tstr
,
614 &static_memfuncp
, noside
);
620 argvec
[1] = argvec
[0];
621 argvec
= argvec
.slice (1);
623 if (value_type (argvec
[0])->code () == TYPE_CODE_XMETHOD
)
625 /* Static xmethods are not supported yet. */
626 gdb_assert (static_memfuncp
== 0);
627 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
629 struct type
*return_type
630 = result_type_of_xmethod (argvec
[0], argvec
[1]);
632 if (return_type
== NULL
)
633 error (_("Xmethod is missing return type."));
634 return value_zero (return_type
, VALUE_LVAL (arg1
));
636 return call_xmethod (argvec
[0], argvec
[1]);
638 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
640 struct type
*return_type
;
643 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
644 return value_zero (return_type
, VALUE_LVAL (arg1
));
646 return call_function_by_hand (argvec
[0], NULL
,
647 argvec
.slice (1, nargs
));
649 throw_error (NOT_FOUND_ERROR
,
650 _("member function %s not found"), tstr
);
654 /* Concatenate two values. One value must be an array; and the other
655 value must either be an array with the same element type, or be of
656 the array's element type. */
659 value_concat (struct value
*arg1
, struct value
*arg2
)
661 struct type
*type1
= check_typedef (value_type (arg1
));
662 struct type
*type2
= check_typedef (value_type (arg2
));
664 if (type1
->code () != TYPE_CODE_ARRAY
&& type2
->code () != TYPE_CODE_ARRAY
)
665 error ("no array provided to concatenation");
668 struct type
*elttype1
= type1
;
669 if (elttype1
->code () == TYPE_CODE_ARRAY
)
671 elttype1
= TYPE_TARGET_TYPE (elttype1
);
672 if (!get_array_bounds (type1
, &low1
, &high1
))
673 error (_("could not determine array bounds on left-hand-side of "
674 "array concatenation"));
683 struct type
*elttype2
= type2
;
684 if (elttype2
->code () == TYPE_CODE_ARRAY
)
686 elttype2
= TYPE_TARGET_TYPE (elttype2
);
687 if (!get_array_bounds (type2
, &low2
, &high2
))
688 error (_("could not determine array bounds on right-hand-side of "
689 "array concatenation"));
697 if (!types_equal (elttype1
, elttype2
))
698 error (_("concatenation with different element types"));
700 LONGEST lowbound
= current_language
->c_style_arrays_p () ? 0 : 1;
701 LONGEST n_elts
= (high1
- low1
+ 1) + (high2
- low2
+ 1);
702 struct type
*atype
= lookup_array_range_type (elttype1
,
704 lowbound
+ n_elts
- 1);
706 struct value
*result
= allocate_value (atype
);
707 gdb::array_view
<gdb_byte
> contents
= value_contents_raw (result
);
708 gdb::array_view
<const gdb_byte
> lhs_contents
= value_contents (arg1
);
709 gdb::array_view
<const gdb_byte
> rhs_contents
= value_contents (arg2
);
710 gdb::copy (lhs_contents
, contents
.slice (0, lhs_contents
.size ()));
711 gdb::copy (rhs_contents
, contents
.slice (lhs_contents
.size ()));
716 /* Integer exponentiation: V1**V2, where both arguments are
717 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
720 integer_pow (LONGEST v1
, LONGEST v2
)
725 error (_("Attempt to raise 0 to negative power."));
731 /* The Russian Peasant's Algorithm. */
747 /* Obtain argument values for binary operation, converting from
748 other types if one of them is not floating point. */
750 value_args_as_target_float (struct value
*arg1
, struct value
*arg2
,
751 gdb_byte
*x
, struct type
**eff_type_x
,
752 gdb_byte
*y
, struct type
**eff_type_y
)
754 struct type
*type1
, *type2
;
756 type1
= check_typedef (value_type (arg1
));
757 type2
= check_typedef (value_type (arg2
));
759 /* At least one of the arguments must be of floating-point type. */
760 gdb_assert (is_floating_type (type1
) || is_floating_type (type2
));
762 if (is_floating_type (type1
) && is_floating_type (type2
)
763 && type1
->code () != type2
->code ())
764 /* The DFP extension to the C language does not allow mixing of
765 * decimal float types with other float types in expressions
766 * (see WDTR 24732, page 12). */
767 error (_("Mixing decimal floating types with "
768 "other floating types is not allowed."));
770 /* Obtain value of arg1, converting from other types if necessary. */
772 if (is_floating_type (type1
))
775 memcpy (x
, value_contents (arg1
).data (), TYPE_LENGTH (type1
));
777 else if (is_integral_type (type1
))
780 if (type1
->is_unsigned ())
781 target_float_from_ulongest (x
, *eff_type_x
, value_as_long (arg1
));
783 target_float_from_longest (x
, *eff_type_x
, value_as_long (arg1
));
786 error (_("Don't know how to convert from %s to %s."), type1
->name (),
789 /* Obtain value of arg2, converting from other types if necessary. */
791 if (is_floating_type (type2
))
794 memcpy (y
, value_contents (arg2
).data (), TYPE_LENGTH (type2
));
796 else if (is_integral_type (type2
))
799 if (type2
->is_unsigned ())
800 target_float_from_ulongest (y
, *eff_type_y
, value_as_long (arg2
));
802 target_float_from_longest (y
, *eff_type_y
, value_as_long (arg2
));
805 error (_("Don't know how to convert from %s to %s."), type1
->name (),
809 /* Assuming at last one of ARG1 or ARG2 is a fixed point value,
810 perform the binary operation OP on these two operands, and return
811 the resulting value (also as a fixed point). */
813 static struct value
*
814 fixed_point_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
816 struct type
*type1
= check_typedef (value_type (arg1
));
817 struct type
*type2
= check_typedef (value_type (arg2
));
818 const struct language_defn
*language
= current_language
;
820 struct gdbarch
*gdbarch
= type1
->arch ();
825 gdb_assert (is_fixed_point_type (type1
) || is_fixed_point_type (type2
));
826 if (op
== BINOP_MUL
|| op
== BINOP_DIV
)
828 v1
= value_to_gdb_mpq (arg1
);
829 v2
= value_to_gdb_mpq (arg2
);
831 /* The code below uses TYPE1 for the result type, so make sure
832 it is set properly. */
833 if (!is_fixed_point_type (type1
))
838 if (!is_fixed_point_type (type1
))
840 arg1
= value_cast (type2
, arg1
);
843 if (!is_fixed_point_type (type2
))
845 arg2
= value_cast (type1
, arg2
);
849 v1
.read_fixed_point (value_contents (arg1
),
850 type_byte_order (type1
), type1
->is_unsigned (),
851 type1
->fixed_point_scaling_factor ());
852 v2
.read_fixed_point (value_contents (arg2
),
853 type_byte_order (type2
), type2
->is_unsigned (),
854 type2
->fixed_point_scaling_factor ());
857 auto fixed_point_to_value
= [type1
] (const gdb_mpq
&fp
)
859 value
*fp_val
= allocate_value (type1
);
862 (value_contents_raw (fp_val
),
863 type_byte_order (type1
),
864 type1
->is_unsigned (),
865 type1
->fixed_point_scaling_factor ());
873 mpq_add (res
.val
, v1
.val
, v2
.val
);
874 val
= fixed_point_to_value (res
);
878 mpq_sub (res
.val
, v1
.val
, v2
.val
);
879 val
= fixed_point_to_value (res
);
883 val
= fixed_point_to_value (mpq_cmp (v1
.val
, v2
.val
) < 0 ? v1
: v2
);
887 val
= fixed_point_to_value (mpq_cmp (v1
.val
, v2
.val
) > 0 ? v1
: v2
);
891 mpq_mul (res
.val
, v1
.val
, v2
.val
);
892 val
= fixed_point_to_value (res
);
896 if (mpq_sgn (v2
.val
) == 0)
897 error (_("Division by zero"));
898 mpq_div (res
.val
, v1
.val
, v2
.val
);
899 val
= fixed_point_to_value (res
);
903 val
= value_from_ulongest (language_bool_type (language
, gdbarch
),
904 mpq_cmp (v1
.val
, v2
.val
) == 0 ? 1 : 0);
908 val
= value_from_ulongest (language_bool_type (language
, gdbarch
),
909 mpq_cmp (v1
.val
, v2
.val
) < 0 ? 1 : 0);
913 error (_("Integer-only operation on fixed point number."));
919 /* A helper function that finds the type to use for a binary operation
920 involving TYPE1 and TYPE2. */
923 promotion_type (struct type
*type1
, struct type
*type2
)
925 struct type
*result_type
;
927 if (is_floating_type (type1
) || is_floating_type (type2
))
929 /* If only one type is floating-point, use its type.
930 Otherwise use the bigger type. */
931 if (!is_floating_type (type1
))
933 else if (!is_floating_type (type2
))
935 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
943 if (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
))
945 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
947 else if (type1
->is_unsigned ())
949 else if (type2
->is_unsigned ())
958 static struct value
*scalar_binop (struct value
*arg1
, struct value
*arg2
,
961 /* Perform a binary operation on complex operands. */
963 static struct value
*
964 complex_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
966 struct type
*arg1_type
= check_typedef (value_type (arg1
));
967 struct type
*arg2_type
= check_typedef (value_type (arg2
));
969 struct value
*arg1_real
, *arg1_imag
, *arg2_real
, *arg2_imag
;
970 if (arg1_type
->code () == TYPE_CODE_COMPLEX
)
972 arg1_real
= value_real_part (arg1
);
973 arg1_imag
= value_imaginary_part (arg1
);
978 arg1_imag
= value_zero (arg1_type
, not_lval
);
980 if (arg2_type
->code () == TYPE_CODE_COMPLEX
)
982 arg2_real
= value_real_part (arg2
);
983 arg2_imag
= value_imaginary_part (arg2
);
988 arg2_imag
= value_zero (arg2_type
, not_lval
);
991 struct type
*comp_type
= promotion_type (value_type (arg1_real
),
992 value_type (arg2_real
));
993 if (!can_create_complex_type (comp_type
))
994 error (_("Argument to complex arithmetic operation not supported."));
996 arg1_real
= value_cast (comp_type
, arg1_real
);
997 arg1_imag
= value_cast (comp_type
, arg1_imag
);
998 arg2_real
= value_cast (comp_type
, arg2_real
);
999 arg2_imag
= value_cast (comp_type
, arg2_imag
);
1001 struct type
*result_type
= init_complex_type (nullptr, comp_type
);
1003 struct value
*result_real
, *result_imag
;
1008 result_real
= scalar_binop (arg1_real
, arg2_real
, op
);
1009 result_imag
= scalar_binop (arg1_imag
, arg2_imag
, op
);
1014 struct value
*x1
= scalar_binop (arg1_real
, arg2_real
, op
);
1015 struct value
*x2
= scalar_binop (arg1_imag
, arg2_imag
, op
);
1016 result_real
= scalar_binop (x1
, x2
, BINOP_SUB
);
1018 x1
= scalar_binop (arg1_real
, arg2_imag
, op
);
1019 x2
= scalar_binop (arg1_imag
, arg2_real
, op
);
1020 result_imag
= scalar_binop (x1
, x2
, BINOP_ADD
);
1026 if (arg2_type
->code () == TYPE_CODE_COMPLEX
)
1028 struct value
*conjugate
= value_complement (arg2
);
1029 /* We have to reconstruct ARG1, in case the type was
1031 arg1
= value_literal_complex (arg1_real
, arg1_imag
, result_type
);
1033 struct value
*numerator
= scalar_binop (arg1
, conjugate
,
1035 arg1_real
= value_real_part (numerator
);
1036 arg1_imag
= value_imaginary_part (numerator
);
1038 struct value
*x1
= scalar_binop (arg2_real
, arg2_real
, BINOP_MUL
);
1039 struct value
*x2
= scalar_binop (arg2_imag
, arg2_imag
, BINOP_MUL
);
1040 arg2_real
= scalar_binop (x1
, x2
, BINOP_ADD
);
1043 result_real
= scalar_binop (arg1_real
, arg2_real
, op
);
1044 result_imag
= scalar_binop (arg1_imag
, arg2_real
, op
);
1049 case BINOP_NOTEQUAL
:
1051 struct value
*x1
= scalar_binop (arg1_real
, arg2_real
, op
);
1052 struct value
*x2
= scalar_binop (arg1_imag
, arg2_imag
, op
);
1054 LONGEST v1
= value_as_long (x1
);
1055 LONGEST v2
= value_as_long (x2
);
1057 if (op
== BINOP_EQUAL
)
1062 return value_from_longest (value_type (x1
), v1
);
1067 error (_("Invalid binary operation on numbers."));
1070 return value_literal_complex (result_real
, result_imag
, result_type
);
1073 /* Perform a binary operation on two operands which have reasonable
1074 representations as integers or floats. This includes booleans,
1075 characters, integers, or floats.
1076 Does not support addition and subtraction on pointers;
1077 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
1079 static struct value
*
1080 scalar_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
1083 struct type
*type1
, *type2
, *result_type
;
1085 arg1
= coerce_ref (arg1
);
1086 arg2
= coerce_ref (arg2
);
1088 type1
= check_typedef (value_type (arg1
));
1089 type2
= check_typedef (value_type (arg2
));
1091 if (type1
->code () == TYPE_CODE_COMPLEX
1092 || type2
->code () == TYPE_CODE_COMPLEX
)
1093 return complex_binop (arg1
, arg2
, op
);
1095 if ((!is_floating_value (arg1
)
1096 && !is_integral_type (type1
)
1097 && !is_fixed_point_type (type1
))
1098 || (!is_floating_value (arg2
)
1099 && !is_integral_type (type2
)
1100 && !is_fixed_point_type (type2
)))
1101 error (_("Argument to arithmetic operation not a number or boolean."));
1103 if (is_fixed_point_type (type1
) || is_fixed_point_type (type2
))
1104 return fixed_point_binop (arg1
, arg2
, op
);
1106 if (is_floating_type (type1
) || is_floating_type (type2
))
1108 result_type
= promotion_type (type1
, type2
);
1109 val
= allocate_value (result_type
);
1111 struct type
*eff_type_v1
, *eff_type_v2
;
1112 gdb::byte_vector v1
, v2
;
1113 v1
.resize (TYPE_LENGTH (result_type
));
1114 v2
.resize (TYPE_LENGTH (result_type
));
1116 value_args_as_target_float (arg1
, arg2
,
1117 v1
.data (), &eff_type_v1
,
1118 v2
.data (), &eff_type_v2
);
1119 target_float_binop (op
, v1
.data (), eff_type_v1
,
1120 v2
.data (), eff_type_v2
,
1121 value_contents_raw (val
).data (), result_type
);
1123 else if (type1
->code () == TYPE_CODE_BOOL
1124 || type2
->code () == TYPE_CODE_BOOL
)
1126 LONGEST v1
, v2
, v
= 0;
1128 v1
= value_as_long (arg1
);
1129 v2
= value_as_long (arg2
);
1133 case BINOP_BITWISE_AND
:
1137 case BINOP_BITWISE_IOR
:
1141 case BINOP_BITWISE_XOR
:
1149 case BINOP_NOTEQUAL
:
1154 error (_("Invalid operation on booleans."));
1157 result_type
= type1
;
1159 val
= allocate_value (result_type
);
1160 store_signed_integer (value_contents_raw (val
).data (),
1161 TYPE_LENGTH (result_type
),
1162 type_byte_order (result_type
),
1166 /* Integral operations here. */
1168 /* Determine type length of the result, and if the operation should
1169 be done unsigned. For exponentiation and shift operators,
1170 use the length and type of the left operand. Otherwise,
1171 use the signedness of the operand with the greater length.
1172 If both operands are of equal length, use unsigned operation
1173 if one of the operands is unsigned. */
1174 if (op
== BINOP_RSH
|| op
== BINOP_LSH
|| op
== BINOP_EXP
)
1175 result_type
= type1
;
1177 result_type
= promotion_type (type1
, type2
);
1179 if (result_type
->is_unsigned ())
1181 LONGEST v2_signed
= value_as_long (arg2
);
1182 ULONGEST v1
, v2
, v
= 0;
1184 v1
= (ULONGEST
) value_as_long (arg1
);
1185 v2
= (ULONGEST
) v2_signed
;
1206 error (_("Division by zero"));
1210 v
= uinteger_pow (v1
, v2_signed
);
1217 error (_("Division by zero"));
1221 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1222 v1 mod 0 has a defined value, v1. */
1230 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1243 case BINOP_BITWISE_AND
:
1247 case BINOP_BITWISE_IOR
:
1251 case BINOP_BITWISE_XOR
:
1255 case BINOP_LOGICAL_AND
:
1259 case BINOP_LOGICAL_OR
:
1264 v
= v1
< v2
? v1
: v2
;
1268 v
= v1
> v2
? v1
: v2
;
1275 case BINOP_NOTEQUAL
:
1296 error (_("Invalid binary operation on numbers."));
1299 val
= allocate_value (result_type
);
1300 store_unsigned_integer (value_contents_raw (val
).data (),
1301 TYPE_LENGTH (value_type (val
)),
1302 type_byte_order (result_type
),
1307 LONGEST v1
, v2
, v
= 0;
1309 v1
= value_as_long (arg1
);
1310 v2
= value_as_long (arg2
);
1331 error (_("Division by zero"));
1335 v
= integer_pow (v1
, v2
);
1342 error (_("Division by zero"));
1346 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1347 X mod 0 has a defined value, X. */
1355 /* Compute floor. */
1356 if (TRUNCATION_TOWARDS_ZERO
&& (v
< 0) && ((v1
% v2
) != 0))
1372 case BINOP_BITWISE_AND
:
1376 case BINOP_BITWISE_IOR
:
1380 case BINOP_BITWISE_XOR
:
1384 case BINOP_LOGICAL_AND
:
1388 case BINOP_LOGICAL_OR
:
1393 v
= v1
< v2
? v1
: v2
;
1397 v
= v1
> v2
? v1
: v2
;
1404 case BINOP_NOTEQUAL
:
1425 error (_("Invalid binary operation on numbers."));
1428 val
= allocate_value (result_type
);
1429 store_signed_integer (value_contents_raw (val
).data (),
1430 TYPE_LENGTH (value_type (val
)),
1431 type_byte_order (result_type
),
1439 /* Widen a scalar value SCALAR_VALUE to vector type VECTOR_TYPE by
1440 replicating SCALAR_VALUE for each element of the vector. Only scalar
1441 types that can be cast to the type of one element of the vector are
1442 acceptable. The newly created vector value is returned upon success,
1443 otherwise an error is thrown. */
1446 value_vector_widen (struct value
*scalar_value
, struct type
*vector_type
)
1448 /* Widen the scalar to a vector. */
1449 struct type
*eltype
, *scalar_type
;
1450 struct value
*elval
;
1451 LONGEST low_bound
, high_bound
;
1454 vector_type
= check_typedef (vector_type
);
1456 gdb_assert (vector_type
->code () == TYPE_CODE_ARRAY
1457 && vector_type
->is_vector ());
1459 if (!get_array_bounds (vector_type
, &low_bound
, &high_bound
))
1460 error (_("Could not determine the vector bounds"));
1462 eltype
= check_typedef (TYPE_TARGET_TYPE (vector_type
));
1463 elval
= value_cast (eltype
, scalar_value
);
1465 scalar_type
= check_typedef (value_type (scalar_value
));
1467 /* If we reduced the length of the scalar then check we didn't loose any
1469 if (TYPE_LENGTH (eltype
) < TYPE_LENGTH (scalar_type
)
1470 && !value_equal (elval
, scalar_value
))
1471 error (_("conversion of scalar to vector involves truncation"));
1473 value
*val
= allocate_value (vector_type
);
1474 gdb::array_view
<gdb_byte
> val_contents
= value_contents_writeable (val
);
1475 int elt_len
= TYPE_LENGTH (eltype
);
1477 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1478 /* Duplicate the contents of elval into the destination vector. */
1479 copy (value_contents_all (elval
),
1480 val_contents
.slice (i
* elt_len
, elt_len
));
1485 /* Performs a binary operation on two vector operands by calling scalar_binop
1486 for each pair of vector components. */
1488 static struct value
*
1489 vector_binop (struct value
*val1
, struct value
*val2
, enum exp_opcode op
)
1491 struct type
*type1
, *type2
, *eltype1
, *eltype2
;
1492 int t1_is_vec
, t2_is_vec
, elsize
, i
;
1493 LONGEST low_bound1
, high_bound1
, low_bound2
, high_bound2
;
1495 type1
= check_typedef (value_type (val1
));
1496 type2
= check_typedef (value_type (val2
));
1498 t1_is_vec
= (type1
->code () == TYPE_CODE_ARRAY
1499 && type1
->is_vector ()) ? 1 : 0;
1500 t2_is_vec
= (type2
->code () == TYPE_CODE_ARRAY
1501 && type2
->is_vector ()) ? 1 : 0;
1503 if (!t1_is_vec
|| !t2_is_vec
)
1504 error (_("Vector operations are only supported among vectors"));
1506 if (!get_array_bounds (type1
, &low_bound1
, &high_bound1
)
1507 || !get_array_bounds (type2
, &low_bound2
, &high_bound2
))
1508 error (_("Could not determine the vector bounds"));
1510 eltype1
= check_typedef (TYPE_TARGET_TYPE (type1
));
1511 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
));
1512 elsize
= TYPE_LENGTH (eltype1
);
1514 if (eltype1
->code () != eltype2
->code ()
1515 || elsize
!= TYPE_LENGTH (eltype2
)
1516 || eltype1
->is_unsigned () != eltype2
->is_unsigned ()
1517 || low_bound1
!= low_bound2
|| high_bound1
!= high_bound2
)
1518 error (_("Cannot perform operation on vectors with different types"));
1520 value
*val
= allocate_value (type1
);
1521 gdb::array_view
<gdb_byte
> val_contents
= value_contents_writeable (val
);
1522 value
*mark
= value_mark ();
1523 for (i
= 0; i
< high_bound1
- low_bound1
+ 1; i
++)
1525 value
*tmp
= value_binop (value_subscript (val1
, i
),
1526 value_subscript (val2
, i
), op
);
1527 copy (value_contents_all (tmp
),
1528 val_contents
.slice (i
* elsize
, elsize
));
1530 value_free_to_mark (mark
);
1535 /* Perform a binary operation on two operands. */
1538 value_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
1541 struct type
*type1
= check_typedef (value_type (arg1
));
1542 struct type
*type2
= check_typedef (value_type (arg2
));
1543 int t1_is_vec
= (type1
->code () == TYPE_CODE_ARRAY
1544 && type1
->is_vector ());
1545 int t2_is_vec
= (type2
->code () == TYPE_CODE_ARRAY
1546 && type2
->is_vector ());
1548 if (!t1_is_vec
&& !t2_is_vec
)
1549 val
= scalar_binop (arg1
, arg2
, op
);
1550 else if (t1_is_vec
&& t2_is_vec
)
1551 val
= vector_binop (arg1
, arg2
, op
);
1554 /* Widen the scalar operand to a vector. */
1555 struct value
**v
= t1_is_vec
? &arg2
: &arg1
;
1556 struct type
*t
= t1_is_vec
? type2
: type1
;
1558 if (t
->code () != TYPE_CODE_FLT
1559 && t
->code () != TYPE_CODE_DECFLOAT
1560 && !is_integral_type (t
))
1561 error (_("Argument to operation not a number or boolean."));
1563 /* Replicate the scalar value to make a vector value. */
1564 *v
= value_vector_widen (*v
, t1_is_vec
? type1
: type2
);
1566 val
= vector_binop (arg1
, arg2
, op
);
1575 value_logical_not (struct value
*arg1
)
1581 arg1
= coerce_array (arg1
);
1582 type1
= check_typedef (value_type (arg1
));
1584 if (is_floating_value (arg1
))
1585 return target_float_is_zero (value_contents (arg1
).data (), type1
);
1587 len
= TYPE_LENGTH (type1
);
1588 p
= value_contents (arg1
).data ();
1599 /* Perform a comparison on two string values (whose content are not
1600 necessarily null terminated) based on their length. */
1603 value_strcmp (struct value
*arg1
, struct value
*arg2
)
1605 int len1
= TYPE_LENGTH (value_type (arg1
));
1606 int len2
= TYPE_LENGTH (value_type (arg2
));
1607 const gdb_byte
*s1
= value_contents (arg1
).data ();
1608 const gdb_byte
*s2
= value_contents (arg2
).data ();
1609 int i
, len
= len1
< len2
? len1
: len2
;
1611 for (i
= 0; i
< len
; i
++)
1615 else if (s1
[i
] > s2
[i
])
1623 else if (len1
> len2
)
1629 /* Simulate the C operator == by returning a 1
1630 iff ARG1 and ARG2 have equal contents. */
1633 value_equal (struct value
*arg1
, struct value
*arg2
)
1638 struct type
*type1
, *type2
;
1639 enum type_code code1
;
1640 enum type_code code2
;
1641 int is_int1
, is_int2
;
1643 arg1
= coerce_array (arg1
);
1644 arg2
= coerce_array (arg2
);
1646 type1
= check_typedef (value_type (arg1
));
1647 type2
= check_typedef (value_type (arg2
));
1648 code1
= type1
->code ();
1649 code2
= type2
->code ();
1650 is_int1
= is_integral_type (type1
);
1651 is_int2
= is_integral_type (type2
);
1653 if (is_int1
&& is_int2
)
1654 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1656 else if ((is_floating_value (arg1
) || is_int1
)
1657 && (is_floating_value (arg2
) || is_int2
))
1659 struct type
*eff_type_v1
, *eff_type_v2
;
1660 gdb::byte_vector v1
, v2
;
1661 v1
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1662 v2
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1664 value_args_as_target_float (arg1
, arg2
,
1665 v1
.data (), &eff_type_v1
,
1666 v2
.data (), &eff_type_v2
);
1668 return target_float_compare (v1
.data (), eff_type_v1
,
1669 v2
.data (), eff_type_v2
) == 0;
1672 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1674 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1675 return value_as_address (arg1
) == (CORE_ADDR
) value_as_long (arg2
);
1676 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1677 return (CORE_ADDR
) value_as_long (arg1
) == value_as_address (arg2
);
1679 else if (code1
== code2
1680 && ((len
= (int) TYPE_LENGTH (type1
))
1681 == (int) TYPE_LENGTH (type2
)))
1683 p1
= value_contents (arg1
).data ();
1684 p2
= value_contents (arg2
).data ();
1692 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1694 return value_strcmp (arg1
, arg2
) == 0;
1697 error (_("Invalid type combination in equality test."));
1700 /* Compare values based on their raw contents. Useful for arrays since
1701 value_equal coerces them to pointers, thus comparing just the address
1702 of the array instead of its contents. */
1705 value_equal_contents (struct value
*arg1
, struct value
*arg2
)
1707 struct type
*type1
, *type2
;
1709 type1
= check_typedef (value_type (arg1
));
1710 type2
= check_typedef (value_type (arg2
));
1712 return (type1
->code () == type2
->code ()
1713 && TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
1714 && memcmp (value_contents (arg1
).data (),
1715 value_contents (arg2
).data (),
1716 TYPE_LENGTH (type1
)) == 0);
1719 /* Simulate the C operator < by returning 1
1720 iff ARG1's contents are less than ARG2's. */
1723 value_less (struct value
*arg1
, struct value
*arg2
)
1725 enum type_code code1
;
1726 enum type_code code2
;
1727 struct type
*type1
, *type2
;
1728 int is_int1
, is_int2
;
1730 arg1
= coerce_array (arg1
);
1731 arg2
= coerce_array (arg2
);
1733 type1
= check_typedef (value_type (arg1
));
1734 type2
= check_typedef (value_type (arg2
));
1735 code1
= type1
->code ();
1736 code2
= type2
->code ();
1737 is_int1
= is_integral_type (type1
);
1738 is_int2
= is_integral_type (type2
);
1740 if ((is_int1
&& is_int2
)
1741 || (is_fixed_point_type (type1
) && is_fixed_point_type (type2
)))
1742 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1744 else if ((is_floating_value (arg1
) || is_int1
)
1745 && (is_floating_value (arg2
) || is_int2
))
1747 struct type
*eff_type_v1
, *eff_type_v2
;
1748 gdb::byte_vector v1
, v2
;
1749 v1
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1750 v2
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1752 value_args_as_target_float (arg1
, arg2
,
1753 v1
.data (), &eff_type_v1
,
1754 v2
.data (), &eff_type_v2
);
1756 return target_float_compare (v1
.data (), eff_type_v1
,
1757 v2
.data (), eff_type_v2
) == -1;
1759 else if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
1760 return value_as_address (arg1
) < value_as_address (arg2
);
1762 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1764 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1765 return value_as_address (arg1
) < (CORE_ADDR
) value_as_long (arg2
);
1766 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1767 return (CORE_ADDR
) value_as_long (arg1
) < value_as_address (arg2
);
1768 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1769 return value_strcmp (arg1
, arg2
) < 0;
1772 error (_("Invalid type combination in ordering comparison."));
1777 /* The unary operators +, - and ~. They free the argument ARG1. */
1780 value_pos (struct value
*arg1
)
1784 arg1
= coerce_ref (arg1
);
1785 type
= check_typedef (value_type (arg1
));
1787 if (is_integral_type (type
) || is_floating_value (arg1
)
1788 || (type
->code () == TYPE_CODE_ARRAY
&& type
->is_vector ())
1789 || type
->code () == TYPE_CODE_COMPLEX
)
1790 return value_from_contents (type
, value_contents (arg1
).data ());
1792 error (_("Argument to positive operation not a number."));
1796 value_neg (struct value
*arg1
)
1800 arg1
= coerce_ref (arg1
);
1801 type
= check_typedef (value_type (arg1
));
1803 if (is_integral_type (type
) || is_floating_type (type
))
1804 return value_binop (value_from_longest (type
, 0), arg1
, BINOP_SUB
);
1805 else if (is_fixed_point_type (type
))
1806 return value_binop (value_zero (type
, not_lval
), arg1
, BINOP_SUB
);
1807 else if (type
->code () == TYPE_CODE_ARRAY
&& type
->is_vector ())
1809 struct value
*val
= allocate_value (type
);
1810 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1812 LONGEST low_bound
, high_bound
;
1814 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1815 error (_("Could not determine the vector bounds"));
1817 gdb::array_view
<gdb_byte
> val_contents
= value_contents_writeable (val
);
1818 int elt_len
= TYPE_LENGTH (eltype
);
1820 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1822 value
*tmp
= value_neg (value_subscript (arg1
, i
));
1823 copy (value_contents_all (tmp
),
1824 val_contents
.slice (i
* elt_len
, elt_len
));
1828 else if (type
->code () == TYPE_CODE_COMPLEX
)
1830 struct value
*real
= value_real_part (arg1
);
1831 struct value
*imag
= value_imaginary_part (arg1
);
1833 real
= value_neg (real
);
1834 imag
= value_neg (imag
);
1835 return value_literal_complex (real
, imag
, type
);
1838 error (_("Argument to negate operation not a number."));
1842 value_complement (struct value
*arg1
)
1847 arg1
= coerce_ref (arg1
);
1848 type
= check_typedef (value_type (arg1
));
1850 if (is_integral_type (type
))
1851 val
= value_from_longest (type
, ~value_as_long (arg1
));
1852 else if (type
->code () == TYPE_CODE_ARRAY
&& type
->is_vector ())
1854 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1856 LONGEST low_bound
, high_bound
;
1858 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1859 error (_("Could not determine the vector bounds"));
1861 val
= allocate_value (type
);
1862 gdb::array_view
<gdb_byte
> val_contents
= value_contents_writeable (val
);
1863 int elt_len
= TYPE_LENGTH (eltype
);
1865 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1867 value
*tmp
= value_complement (value_subscript (arg1
, i
));
1868 copy (value_contents_all (tmp
),
1869 val_contents
.slice (i
* elt_len
, elt_len
));
1872 else if (type
->code () == TYPE_CODE_COMPLEX
)
1874 /* GCC has an extension that treats ~complex as the complex
1876 struct value
*real
= value_real_part (arg1
);
1877 struct value
*imag
= value_imaginary_part (arg1
);
1879 imag
= value_neg (imag
);
1880 return value_literal_complex (real
, imag
, type
);
1883 error (_("Argument to complement operation not an integer, boolean."));
1888 /* The INDEX'th bit of SET value whose value_type is TYPE,
1889 and whose value_contents is valaddr.
1890 Return -1 if out of range, -2 other error. */
1893 value_bit_index (struct type
*type
, const gdb_byte
*valaddr
, int index
)
1895 struct gdbarch
*gdbarch
= type
->arch ();
1896 LONGEST low_bound
, high_bound
;
1899 struct type
*range
= type
->index_type ();
1901 if (!get_discrete_bounds (range
, &low_bound
, &high_bound
))
1903 if (index
< low_bound
|| index
> high_bound
)
1905 rel_index
= index
- low_bound
;
1906 word
= extract_unsigned_integer (valaddr
+ (rel_index
/ TARGET_CHAR_BIT
), 1,
1907 type_byte_order (type
));
1908 rel_index
%= TARGET_CHAR_BIT
;
1909 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
1910 rel_index
= TARGET_CHAR_BIT
- 1 - rel_index
;
1911 return (word
>> rel_index
) & 1;
1915 value_in (struct value
*element
, struct value
*set
)
1918 struct type
*settype
= check_typedef (value_type (set
));
1919 struct type
*eltype
= check_typedef (value_type (element
));
1921 if (eltype
->code () == TYPE_CODE_RANGE
)
1922 eltype
= TYPE_TARGET_TYPE (eltype
);
1923 if (settype
->code () != TYPE_CODE_SET
)
1924 error (_("Second argument of 'IN' has wrong type"));
1925 if (eltype
->code () != TYPE_CODE_INT
1926 && eltype
->code () != TYPE_CODE_CHAR
1927 && eltype
->code () != TYPE_CODE_ENUM
1928 && eltype
->code () != TYPE_CODE_BOOL
)
1929 error (_("First argument of 'IN' has wrong type"));
1930 member
= value_bit_index (settype
, value_contents (set
).data (),
1931 value_as_long (element
));
1933 error (_("First argument of 'IN' not in range"));