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 /* Return the type's length in bits. */
1076 type_length_bits (type
*type
)
1078 int unit_size
= gdbarch_addressable_memory_unit_size (type
->arch ());
1079 return unit_size
* 8 * TYPE_LENGTH (type
);
1082 /* Check whether the RHS value of a shift is valid in C/C++ semantics.
1083 SHIFT_COUNT is the shift amount, SHIFT_COUNT_TYPE is the type of
1084 the shift count value, used to determine whether the type is
1085 signed, and RESULT_TYPE is the result type. This is used to avoid
1086 both negative and too-large shift amounts, which are undefined, and
1087 would crash a GDB built with UBSan. Depending on the current
1088 language, if the shift is not valid, this either warns and returns
1089 false, or errors out. Returns true if valid. */
1092 check_valid_shift_count (int op
, type
*result_type
,
1093 type
*shift_count_type
, ULONGEST shift_count
)
1095 if (!shift_count_type
->is_unsigned () && (LONGEST
) shift_count
< 0)
1097 auto error_or_warning
= [] (const char *msg
)
1099 /* Shifts by a negative amount are always an error in Go. Other
1100 languages are more permissive and their compilers just warn or
1101 have modes to disable the errors. */
1102 if (current_language
->la_language
== language_go
)
1103 error (("%s"), msg
);
1105 warning (("%s"), msg
);
1108 if (op
== BINOP_RSH
)
1109 error_or_warning (_("right shift count is negative"));
1111 error_or_warning (_("left shift count is negative"));
1115 if (shift_count
>= type_length_bits (result_type
))
1117 /* In Go, shifting by large amounts is defined. Be silent and
1118 still return false, as the caller's error path does the right
1120 if (current_language
->la_language
!= language_go
)
1122 if (op
== BINOP_RSH
)
1123 warning (_("right shift count >= width of type"));
1125 warning (_("left shift count >= width of type"));
1133 /* Perform a binary operation on two operands which have reasonable
1134 representations as integers or floats. This includes booleans,
1135 characters, integers, or floats.
1136 Does not support addition and subtraction on pointers;
1137 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
1139 static struct value
*
1140 scalar_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
1143 struct type
*type1
, *type2
, *result_type
;
1145 arg1
= coerce_ref (arg1
);
1146 arg2
= coerce_ref (arg2
);
1148 type1
= check_typedef (value_type (arg1
));
1149 type2
= check_typedef (value_type (arg2
));
1151 if (type1
->code () == TYPE_CODE_COMPLEX
1152 || type2
->code () == TYPE_CODE_COMPLEX
)
1153 return complex_binop (arg1
, arg2
, op
);
1155 if ((!is_floating_value (arg1
)
1156 && !is_integral_type (type1
)
1157 && !is_fixed_point_type (type1
))
1158 || (!is_floating_value (arg2
)
1159 && !is_integral_type (type2
)
1160 && !is_fixed_point_type (type2
)))
1161 error (_("Argument to arithmetic operation not a number or boolean."));
1163 if (is_fixed_point_type (type1
) || is_fixed_point_type (type2
))
1164 return fixed_point_binop (arg1
, arg2
, op
);
1166 if (is_floating_type (type1
) || is_floating_type (type2
))
1168 result_type
= promotion_type (type1
, type2
);
1169 val
= allocate_value (result_type
);
1171 struct type
*eff_type_v1
, *eff_type_v2
;
1172 gdb::byte_vector v1
, v2
;
1173 v1
.resize (TYPE_LENGTH (result_type
));
1174 v2
.resize (TYPE_LENGTH (result_type
));
1176 value_args_as_target_float (arg1
, arg2
,
1177 v1
.data (), &eff_type_v1
,
1178 v2
.data (), &eff_type_v2
);
1179 target_float_binop (op
, v1
.data (), eff_type_v1
,
1180 v2
.data (), eff_type_v2
,
1181 value_contents_raw (val
).data (), result_type
);
1183 else if (type1
->code () == TYPE_CODE_BOOL
1184 || type2
->code () == TYPE_CODE_BOOL
)
1186 LONGEST v1
, v2
, v
= 0;
1188 v1
= value_as_long (arg1
);
1189 v2
= value_as_long (arg2
);
1193 case BINOP_BITWISE_AND
:
1197 case BINOP_BITWISE_IOR
:
1201 case BINOP_BITWISE_XOR
:
1209 case BINOP_NOTEQUAL
:
1214 error (_("Invalid operation on booleans."));
1217 result_type
= type1
;
1219 val
= allocate_value (result_type
);
1220 store_signed_integer (value_contents_raw (val
).data (),
1221 TYPE_LENGTH (result_type
),
1222 type_byte_order (result_type
),
1226 /* Integral operations here. */
1228 /* Determine type length of the result, and if the operation should
1229 be done unsigned. For exponentiation and shift operators,
1230 use the length and type of the left operand. Otherwise,
1231 use the signedness of the operand with the greater length.
1232 If both operands are of equal length, use unsigned operation
1233 if one of the operands is unsigned. */
1234 if (op
== BINOP_RSH
|| op
== BINOP_LSH
|| op
== BINOP_EXP
)
1235 result_type
= type1
;
1237 result_type
= promotion_type (type1
, type2
);
1239 if (result_type
->is_unsigned ())
1241 LONGEST v2_signed
= value_as_long (arg2
);
1242 ULONGEST v1
, v2
, v
= 0;
1244 v1
= (ULONGEST
) value_as_long (arg1
);
1245 v2
= (ULONGEST
) v2_signed
;
1266 error (_("Division by zero"));
1270 v
= uinteger_pow (v1
, v2_signed
);
1277 error (_("Division by zero"));
1281 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1282 v1 mod 0 has a defined value, v1. */
1290 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1296 if (!check_valid_shift_count (op
, result_type
, type2
, v2
))
1303 if (!check_valid_shift_count (op
, result_type
, type2
, v2
))
1309 case BINOP_BITWISE_AND
:
1313 case BINOP_BITWISE_IOR
:
1317 case BINOP_BITWISE_XOR
:
1321 case BINOP_LOGICAL_AND
:
1325 case BINOP_LOGICAL_OR
:
1330 v
= v1
< v2
? v1
: v2
;
1334 v
= v1
> v2
? v1
: v2
;
1341 case BINOP_NOTEQUAL
:
1362 error (_("Invalid binary operation on numbers."));
1365 val
= allocate_value (result_type
);
1366 store_unsigned_integer (value_contents_raw (val
).data (),
1367 TYPE_LENGTH (value_type (val
)),
1368 type_byte_order (result_type
),
1373 LONGEST v1
, v2
, v
= 0;
1375 v1
= value_as_long (arg1
);
1376 v2
= value_as_long (arg2
);
1397 error (_("Division by zero"));
1401 v
= integer_pow (v1
, v2
);
1408 error (_("Division by zero"));
1412 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1413 X mod 0 has a defined value, X. */
1421 /* Compute floor. */
1422 if (TRUNCATION_TOWARDS_ZERO
&& (v
< 0) && ((v1
% v2
) != 0))
1431 if (!check_valid_shift_count (op
, result_type
, type2
, v2
))
1435 /* Cast to unsigned to avoid undefined behavior on
1436 signed shift overflow (unless C++20 or later),
1437 which would crash GDB when built with UBSan.
1438 Note we don't warn on left signed shift overflow,
1439 because starting with C++20, that is actually
1440 defined behavior. Also, note GDB assumes 2's
1441 complement throughout. */
1442 v
= (ULONGEST
) v1
<< v2
;
1447 if (!check_valid_shift_count (op
, result_type
, type2
, v2
))
1449 /* Pretend the too-large shift was decomposed in a
1450 number of smaller shifts. An arithmetic signed
1451 right shift of a negative number always yields -1
1452 with such semantics. This is the right thing to
1453 do for Go, and we might as well do it for
1454 languages where it is undefined. Also, pretend a
1455 shift by a negative number was a shift by the
1456 negative number cast to unsigned, which is the
1457 same as shifting by a too-large number. */
1467 case BINOP_BITWISE_AND
:
1471 case BINOP_BITWISE_IOR
:
1475 case BINOP_BITWISE_XOR
:
1479 case BINOP_LOGICAL_AND
:
1483 case BINOP_LOGICAL_OR
:
1488 v
= v1
< v2
? v1
: v2
;
1492 v
= v1
> v2
? v1
: v2
;
1499 case BINOP_NOTEQUAL
:
1520 error (_("Invalid binary operation on numbers."));
1523 val
= allocate_value (result_type
);
1524 store_signed_integer (value_contents_raw (val
).data (),
1525 TYPE_LENGTH (value_type (val
)),
1526 type_byte_order (result_type
),
1534 /* Widen a scalar value SCALAR_VALUE to vector type VECTOR_TYPE by
1535 replicating SCALAR_VALUE for each element of the vector. Only scalar
1536 types that can be cast to the type of one element of the vector are
1537 acceptable. The newly created vector value is returned upon success,
1538 otherwise an error is thrown. */
1541 value_vector_widen (struct value
*scalar_value
, struct type
*vector_type
)
1543 /* Widen the scalar to a vector. */
1544 struct type
*eltype
, *scalar_type
;
1545 struct value
*elval
;
1546 LONGEST low_bound
, high_bound
;
1549 vector_type
= check_typedef (vector_type
);
1551 gdb_assert (vector_type
->code () == TYPE_CODE_ARRAY
1552 && vector_type
->is_vector ());
1554 if (!get_array_bounds (vector_type
, &low_bound
, &high_bound
))
1555 error (_("Could not determine the vector bounds"));
1557 eltype
= check_typedef (TYPE_TARGET_TYPE (vector_type
));
1558 elval
= value_cast (eltype
, scalar_value
);
1560 scalar_type
= check_typedef (value_type (scalar_value
));
1562 /* If we reduced the length of the scalar then check we didn't loose any
1564 if (TYPE_LENGTH (eltype
) < TYPE_LENGTH (scalar_type
)
1565 && !value_equal (elval
, scalar_value
))
1566 error (_("conversion of scalar to vector involves truncation"));
1568 value
*val
= allocate_value (vector_type
);
1569 gdb::array_view
<gdb_byte
> val_contents
= value_contents_writeable (val
);
1570 int elt_len
= TYPE_LENGTH (eltype
);
1572 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1573 /* Duplicate the contents of elval into the destination vector. */
1574 copy (value_contents_all (elval
),
1575 val_contents
.slice (i
* elt_len
, elt_len
));
1580 /* Performs a binary operation on two vector operands by calling scalar_binop
1581 for each pair of vector components. */
1583 static struct value
*
1584 vector_binop (struct value
*val1
, struct value
*val2
, enum exp_opcode op
)
1586 struct type
*type1
, *type2
, *eltype1
, *eltype2
;
1587 int t1_is_vec
, t2_is_vec
, elsize
, i
;
1588 LONGEST low_bound1
, high_bound1
, low_bound2
, high_bound2
;
1590 type1
= check_typedef (value_type (val1
));
1591 type2
= check_typedef (value_type (val2
));
1593 t1_is_vec
= (type1
->code () == TYPE_CODE_ARRAY
1594 && type1
->is_vector ()) ? 1 : 0;
1595 t2_is_vec
= (type2
->code () == TYPE_CODE_ARRAY
1596 && type2
->is_vector ()) ? 1 : 0;
1598 if (!t1_is_vec
|| !t2_is_vec
)
1599 error (_("Vector operations are only supported among vectors"));
1601 if (!get_array_bounds (type1
, &low_bound1
, &high_bound1
)
1602 || !get_array_bounds (type2
, &low_bound2
, &high_bound2
))
1603 error (_("Could not determine the vector bounds"));
1605 eltype1
= check_typedef (TYPE_TARGET_TYPE (type1
));
1606 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
));
1607 elsize
= TYPE_LENGTH (eltype1
);
1609 if (eltype1
->code () != eltype2
->code ()
1610 || elsize
!= TYPE_LENGTH (eltype2
)
1611 || eltype1
->is_unsigned () != eltype2
->is_unsigned ()
1612 || low_bound1
!= low_bound2
|| high_bound1
!= high_bound2
)
1613 error (_("Cannot perform operation on vectors with different types"));
1615 value
*val
= allocate_value (type1
);
1616 gdb::array_view
<gdb_byte
> val_contents
= value_contents_writeable (val
);
1617 value
*mark
= value_mark ();
1618 for (i
= 0; i
< high_bound1
- low_bound1
+ 1; i
++)
1620 value
*tmp
= value_binop (value_subscript (val1
, i
),
1621 value_subscript (val2
, i
), op
);
1622 copy (value_contents_all (tmp
),
1623 val_contents
.slice (i
* elsize
, elsize
));
1625 value_free_to_mark (mark
);
1630 /* Perform a binary operation on two operands. */
1633 value_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
1636 struct type
*type1
= check_typedef (value_type (arg1
));
1637 struct type
*type2
= check_typedef (value_type (arg2
));
1638 int t1_is_vec
= (type1
->code () == TYPE_CODE_ARRAY
1639 && type1
->is_vector ());
1640 int t2_is_vec
= (type2
->code () == TYPE_CODE_ARRAY
1641 && type2
->is_vector ());
1643 if (!t1_is_vec
&& !t2_is_vec
)
1644 val
= scalar_binop (arg1
, arg2
, op
);
1645 else if (t1_is_vec
&& t2_is_vec
)
1646 val
= vector_binop (arg1
, arg2
, op
);
1649 /* Widen the scalar operand to a vector. */
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
1655 && !is_integral_type (t
))
1656 error (_("Argument to operation not a number or boolean."));
1658 /* Replicate the scalar value to make a vector value. */
1659 *v
= value_vector_widen (*v
, t1_is_vec
? type1
: type2
);
1661 val
= vector_binop (arg1
, arg2
, op
);
1670 value_logical_not (struct value
*arg1
)
1676 arg1
= coerce_array (arg1
);
1677 type1
= check_typedef (value_type (arg1
));
1679 if (is_floating_value (arg1
))
1680 return target_float_is_zero (value_contents (arg1
).data (), type1
);
1682 len
= TYPE_LENGTH (type1
);
1683 p
= value_contents (arg1
).data ();
1694 /* Perform a comparison on two string values (whose content are not
1695 necessarily null terminated) based on their length. */
1698 value_strcmp (struct value
*arg1
, struct value
*arg2
)
1700 int len1
= TYPE_LENGTH (value_type (arg1
));
1701 int len2
= TYPE_LENGTH (value_type (arg2
));
1702 const gdb_byte
*s1
= value_contents (arg1
).data ();
1703 const gdb_byte
*s2
= value_contents (arg2
).data ();
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
)
1724 /* Simulate the C operator == by returning a 1
1725 iff ARG1 and ARG2 have equal contents. */
1728 value_equal (struct value
*arg1
, struct value
*arg2
)
1733 struct type
*type1
, *type2
;
1734 enum type_code code1
;
1735 enum type_code code2
;
1736 int is_int1
, is_int2
;
1738 arg1
= coerce_array (arg1
);
1739 arg2
= coerce_array (arg2
);
1741 type1
= check_typedef (value_type (arg1
));
1742 type2
= check_typedef (value_type (arg2
));
1743 code1
= type1
->code ();
1744 code2
= type2
->code ();
1745 is_int1
= is_integral_type (type1
);
1746 is_int2
= is_integral_type (type2
);
1748 if (is_int1
&& is_int2
)
1749 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1751 else if ((is_floating_value (arg1
) || is_int1
)
1752 && (is_floating_value (arg2
) || is_int2
))
1754 struct type
*eff_type_v1
, *eff_type_v2
;
1755 gdb::byte_vector v1
, v2
;
1756 v1
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1757 v2
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1759 value_args_as_target_float (arg1
, arg2
,
1760 v1
.data (), &eff_type_v1
,
1761 v2
.data (), &eff_type_v2
);
1763 return target_float_compare (v1
.data (), eff_type_v1
,
1764 v2
.data (), eff_type_v2
) == 0;
1767 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1769 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1770 return value_as_address (arg1
) == (CORE_ADDR
) value_as_long (arg2
);
1771 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1772 return (CORE_ADDR
) value_as_long (arg1
) == value_as_address (arg2
);
1774 else if (code1
== code2
1775 && ((len
= (int) TYPE_LENGTH (type1
))
1776 == (int) TYPE_LENGTH (type2
)))
1778 p1
= value_contents (arg1
).data ();
1779 p2
= value_contents (arg2
).data ();
1787 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1789 return value_strcmp (arg1
, arg2
) == 0;
1792 error (_("Invalid type combination in equality test."));
1795 /* Compare values based on their raw contents. Useful for arrays since
1796 value_equal coerces them to pointers, thus comparing just the address
1797 of the array instead of its contents. */
1800 value_equal_contents (struct value
*arg1
, struct value
*arg2
)
1802 struct type
*type1
, *type2
;
1804 type1
= check_typedef (value_type (arg1
));
1805 type2
= check_typedef (value_type (arg2
));
1807 return (type1
->code () == type2
->code ()
1808 && TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
1809 && memcmp (value_contents (arg1
).data (),
1810 value_contents (arg2
).data (),
1811 TYPE_LENGTH (type1
)) == 0);
1814 /* Simulate the C operator < by returning 1
1815 iff ARG1's contents are less than ARG2's. */
1818 value_less (struct value
*arg1
, struct value
*arg2
)
1820 enum type_code code1
;
1821 enum type_code code2
;
1822 struct type
*type1
, *type2
;
1823 int is_int1
, is_int2
;
1825 arg1
= coerce_array (arg1
);
1826 arg2
= coerce_array (arg2
);
1828 type1
= check_typedef (value_type (arg1
));
1829 type2
= check_typedef (value_type (arg2
));
1830 code1
= type1
->code ();
1831 code2
= type2
->code ();
1832 is_int1
= is_integral_type (type1
);
1833 is_int2
= is_integral_type (type2
);
1835 if ((is_int1
&& is_int2
)
1836 || (is_fixed_point_type (type1
) && is_fixed_point_type (type2
)))
1837 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1839 else if ((is_floating_value (arg1
) || is_int1
)
1840 && (is_floating_value (arg2
) || is_int2
))
1842 struct type
*eff_type_v1
, *eff_type_v2
;
1843 gdb::byte_vector v1
, v2
;
1844 v1
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1845 v2
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1847 value_args_as_target_float (arg1
, arg2
,
1848 v1
.data (), &eff_type_v1
,
1849 v2
.data (), &eff_type_v2
);
1851 return target_float_compare (v1
.data (), eff_type_v1
,
1852 v2
.data (), eff_type_v2
) == -1;
1854 else if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
1855 return value_as_address (arg1
) < value_as_address (arg2
);
1857 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1859 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1860 return value_as_address (arg1
) < (CORE_ADDR
) value_as_long (arg2
);
1861 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1862 return (CORE_ADDR
) value_as_long (arg1
) < value_as_address (arg2
);
1863 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1864 return value_strcmp (arg1
, arg2
) < 0;
1867 error (_("Invalid type combination in ordering comparison."));
1872 /* The unary operators +, - and ~. They free the argument ARG1. */
1875 value_pos (struct value
*arg1
)
1879 arg1
= coerce_ref (arg1
);
1880 type
= check_typedef (value_type (arg1
));
1882 if (is_integral_type (type
) || is_floating_value (arg1
)
1883 || (type
->code () == TYPE_CODE_ARRAY
&& type
->is_vector ())
1884 || type
->code () == TYPE_CODE_COMPLEX
)
1885 return value_from_contents (type
, value_contents (arg1
).data ());
1887 error (_("Argument to positive operation not a number."));
1891 value_neg (struct value
*arg1
)
1895 arg1
= coerce_ref (arg1
);
1896 type
= check_typedef (value_type (arg1
));
1898 if (is_integral_type (type
) || is_floating_type (type
))
1899 return value_binop (value_from_longest (type
, 0), arg1
, BINOP_SUB
);
1900 else if (is_fixed_point_type (type
))
1901 return value_binop (value_zero (type
, not_lval
), arg1
, BINOP_SUB
);
1902 else if (type
->code () == TYPE_CODE_ARRAY
&& type
->is_vector ())
1904 struct value
*val
= allocate_value (type
);
1905 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1907 LONGEST low_bound
, high_bound
;
1909 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1910 error (_("Could not determine the vector bounds"));
1912 gdb::array_view
<gdb_byte
> val_contents
= value_contents_writeable (val
);
1913 int elt_len
= TYPE_LENGTH (eltype
);
1915 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1917 value
*tmp
= value_neg (value_subscript (arg1
, i
));
1918 copy (value_contents_all (tmp
),
1919 val_contents
.slice (i
* elt_len
, elt_len
));
1923 else if (type
->code () == TYPE_CODE_COMPLEX
)
1925 struct value
*real
= value_real_part (arg1
);
1926 struct value
*imag
= value_imaginary_part (arg1
);
1928 real
= value_neg (real
);
1929 imag
= value_neg (imag
);
1930 return value_literal_complex (real
, imag
, type
);
1933 error (_("Argument to negate operation not a number."));
1937 value_complement (struct value
*arg1
)
1942 arg1
= coerce_ref (arg1
);
1943 type
= check_typedef (value_type (arg1
));
1945 if (is_integral_type (type
))
1946 val
= value_from_longest (type
, ~value_as_long (arg1
));
1947 else if (type
->code () == TYPE_CODE_ARRAY
&& type
->is_vector ())
1949 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1951 LONGEST low_bound
, high_bound
;
1953 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1954 error (_("Could not determine the vector bounds"));
1956 val
= allocate_value (type
);
1957 gdb::array_view
<gdb_byte
> val_contents
= value_contents_writeable (val
);
1958 int elt_len
= TYPE_LENGTH (eltype
);
1960 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1962 value
*tmp
= value_complement (value_subscript (arg1
, i
));
1963 copy (value_contents_all (tmp
),
1964 val_contents
.slice (i
* elt_len
, elt_len
));
1967 else if (type
->code () == TYPE_CODE_COMPLEX
)
1969 /* GCC has an extension that treats ~complex as the complex
1971 struct value
*real
= value_real_part (arg1
);
1972 struct value
*imag
= value_imaginary_part (arg1
);
1974 imag
= value_neg (imag
);
1975 return value_literal_complex (real
, imag
, type
);
1978 error (_("Argument to complement operation not an integer, boolean."));
1983 /* The INDEX'th bit of SET value whose value_type is TYPE,
1984 and whose value_contents is valaddr.
1985 Return -1 if out of range, -2 other error. */
1988 value_bit_index (struct type
*type
, const gdb_byte
*valaddr
, int index
)
1990 struct gdbarch
*gdbarch
= type
->arch ();
1991 LONGEST low_bound
, high_bound
;
1994 struct type
*range
= type
->index_type ();
1996 if (!get_discrete_bounds (range
, &low_bound
, &high_bound
))
1998 if (index
< low_bound
|| index
> high_bound
)
2000 rel_index
= index
- low_bound
;
2001 word
= extract_unsigned_integer (valaddr
+ (rel_index
/ TARGET_CHAR_BIT
), 1,
2002 type_byte_order (type
));
2003 rel_index
%= TARGET_CHAR_BIT
;
2004 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
2005 rel_index
= TARGET_CHAR_BIT
- 1 - rel_index
;
2006 return (word
>> rel_index
) & 1;
2010 value_in (struct value
*element
, struct value
*set
)
2013 struct type
*settype
= check_typedef (value_type (set
));
2014 struct type
*eltype
= check_typedef (value_type (element
));
2016 if (eltype
->code () == TYPE_CODE_RANGE
)
2017 eltype
= TYPE_TARGET_TYPE (eltype
);
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"));
2025 member
= value_bit_index (settype
, value_contents (set
).data (),
2026 value_as_long (element
));
2028 error (_("First argument of 'IN' not in range"));