1 /* Perform arithmetic and other operations on values, for GDB.
3 Copyright (C) 1986-2019 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 "common/byte-vector.h"
31 /* Define whether or not the C operator '/' truncates towards zero for
32 differently signed operands (truncation direction is undefined in C). */
34 #ifndef TRUNCATION_TOWARDS_ZERO
35 #define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
38 /* Given a pointer, return the size of its target.
39 If the pointer type is void *, then return 1.
40 If the target type is incomplete, then error out.
41 This isn't a general purpose function, but just a
42 helper for value_ptradd. */
45 find_size_for_pointer_math (struct type
*ptr_type
)
48 struct type
*ptr_target
;
50 gdb_assert (TYPE_CODE (ptr_type
) == TYPE_CODE_PTR
);
51 ptr_target
= check_typedef (TYPE_TARGET_TYPE (ptr_type
));
53 sz
= type_length_units (ptr_target
);
56 if (TYPE_CODE (ptr_type
) == TYPE_CODE_VOID
)
62 name
= TYPE_NAME (ptr_target
);
64 error (_("Cannot perform pointer math on incomplete types, "
65 "try casting to a known type, or void *."));
67 error (_("Cannot perform pointer math on incomplete type \"%s\", "
68 "try casting to a known type, or void *."), name
);
74 /* Given a pointer ARG1 and an integral value ARG2, return the
75 result of C-style pointer arithmetic ARG1 + ARG2. */
78 value_ptradd (struct value
*arg1
, LONGEST arg2
)
80 struct type
*valptrtype
;
84 arg1
= coerce_array (arg1
);
85 valptrtype
= check_typedef (value_type (arg1
));
86 sz
= find_size_for_pointer_math (valptrtype
);
88 result
= value_from_pointer (valptrtype
,
89 value_as_address (arg1
) + sz
* arg2
);
90 if (VALUE_LVAL (result
) != lval_internalvar
)
91 set_value_component_location (result
, arg1
);
95 /* Given two compatible pointer values ARG1 and ARG2, return the
96 result of C-style pointer arithmetic ARG1 - ARG2. */
99 value_ptrdiff (struct value
*arg1
, struct value
*arg2
)
101 struct type
*type1
, *type2
;
104 arg1
= coerce_array (arg1
);
105 arg2
= coerce_array (arg2
);
106 type1
= check_typedef (value_type (arg1
));
107 type2
= check_typedef (value_type (arg2
));
109 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_PTR
);
110 gdb_assert (TYPE_CODE (type2
) == TYPE_CODE_PTR
);
112 if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)))
113 != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2
))))
114 error (_("First argument of `-' is a pointer and "
115 "second argument is neither\n"
116 "an integer nor a pointer of the same type."));
118 sz
= type_length_units (check_typedef (TYPE_TARGET_TYPE (type1
)));
121 warning (_("Type size unknown, assuming 1. "
122 "Try casting to a known type, or void *."));
126 return (value_as_long (arg1
) - value_as_long (arg2
)) / sz
;
129 /* Return the value of ARRAY[IDX].
131 ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING. If the
132 current language supports C-style arrays, it may also be TYPE_CODE_PTR.
134 See comments in value_coerce_array() for rationale for reason for
135 doing lower bounds adjustment here rather than there.
136 FIXME: Perhaps we should validate that the index is valid and if
137 verbosity is set, warn about invalid indices (but still use them). */
140 value_subscript (struct value
*array
, LONGEST index
)
142 int c_style
= current_language
->c_style_arrays
;
145 array
= coerce_ref (array
);
146 tarray
= check_typedef (value_type (array
));
148 if (TYPE_CODE (tarray
) == TYPE_CODE_ARRAY
149 || TYPE_CODE (tarray
) == TYPE_CODE_STRING
)
151 struct type
*range_type
= TYPE_INDEX_TYPE (tarray
);
152 LONGEST lowerbound
, upperbound
;
154 get_discrete_bounds (range_type
, &lowerbound
, &upperbound
);
155 if (VALUE_LVAL (array
) != lval_memory
)
156 return value_subscripted_rvalue (array
, index
, lowerbound
);
160 if (index
>= lowerbound
&& index
<= upperbound
)
161 return value_subscripted_rvalue (array
, index
, lowerbound
);
162 /* Emit warning unless we have an array of unknown size.
163 An array of unknown size has lowerbound 0 and upperbound -1. */
165 warning (_("array or string index out of range"));
166 /* fall doing C stuff */
171 array
= value_coerce_array (array
);
175 return value_ind (value_ptradd (array
, index
));
177 error (_("not an array or string"));
180 /* Return the value of EXPR[IDX], expr an aggregate rvalue
181 (eg, a vector register). This routine used to promote floats
182 to doubles, but no longer does. */
185 value_subscripted_rvalue (struct value
*array
, LONGEST index
, int lowerbound
)
187 struct type
*array_type
= check_typedef (value_type (array
));
188 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (array_type
));
189 ULONGEST elt_size
= type_length_units (elt_type
);
190 ULONGEST elt_offs
= elt_size
* (index
- lowerbound
);
192 if (index
< lowerbound
193 || (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type
)
194 && elt_offs
>= type_length_units (array_type
))
195 || (VALUE_LVAL (array
) != lval_memory
196 && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type
)))
198 if (type_not_associated (array_type
))
199 error (_("no such vector element (vector not associated)"));
200 else if (type_not_allocated (array_type
))
201 error (_("no such vector element (vector not allocated)"));
203 error (_("no such vector element"));
206 if (is_dynamic_type (elt_type
))
210 address
= value_address (array
) + elt_offs
;
211 elt_type
= resolve_dynamic_type (elt_type
, NULL
, address
);
214 return value_from_component (array
, elt_type
, elt_offs
);
218 /* Check to see if either argument is a structure, or a reference to
219 one. This is called so we know whether to go ahead with the normal
220 binop or look for a user defined function instead.
222 For now, we do not overload the `=' operator. */
225 binop_types_user_defined_p (enum exp_opcode op
,
226 struct type
*type1
, struct type
*type2
)
228 if (op
== BINOP_ASSIGN
|| op
== BINOP_CONCAT
)
231 type1
= check_typedef (type1
);
232 if (TYPE_IS_REFERENCE (type1
))
233 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
235 type2
= check_typedef (type2
);
236 if (TYPE_IS_REFERENCE (type2
))
237 type2
= check_typedef (TYPE_TARGET_TYPE (type2
));
239 return (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
240 || TYPE_CODE (type2
) == TYPE_CODE_STRUCT
);
243 /* Check to see if either argument is a structure, or a reference to
244 one. This is called so we know whether to go ahead with the normal
245 binop or look for a user defined function instead.
247 For now, we do not overload the `=' operator. */
250 binop_user_defined_p (enum exp_opcode op
,
251 struct value
*arg1
, struct value
*arg2
)
253 return binop_types_user_defined_p (op
, value_type (arg1
), value_type (arg2
));
256 /* Check to see if argument is a structure. This is called so
257 we know whether to go ahead with the normal unop or look for a
258 user defined function instead.
260 For now, we do not overload the `&' operator. */
263 unop_user_defined_p (enum exp_opcode op
, struct value
*arg1
)
269 type1
= check_typedef (value_type (arg1
));
270 if (TYPE_IS_REFERENCE (type1
))
271 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
272 return TYPE_CODE (type1
) == TYPE_CODE_STRUCT
;
275 /* Try to find an operator named OPERATOR which takes NARGS arguments
276 specified in ARGS. If the operator found is a static member operator
277 *STATIC_MEMFUNP will be set to 1, and otherwise 0.
278 The search if performed through find_overload_match which will handle
279 member operators, non member operators, operators imported implicitly or
280 explicitly, and perform correct overload resolution in all of the above
281 situations or combinations thereof. */
283 static struct value
*
284 value_user_defined_cpp_op (gdb::array_view
<value
*> args
, char *oper
,
285 int *static_memfuncp
, enum noside noside
)
288 struct symbol
*symp
= NULL
;
289 struct value
*valp
= NULL
;
291 find_overload_match (args
, oper
, BOTH
/* could be method */,
293 NULL
/* pass NULL symbol since symbol is unknown */,
294 &valp
, &symp
, static_memfuncp
, 0, noside
);
301 /* This is a non member function and does not
302 expect a reference as its first argument
303 rather the explicit structure. */
304 args
[0] = value_ind (args
[0]);
305 return value_of_variable (symp
, 0);
308 error (_("Could not find %s."), oper
);
311 /* Lookup user defined operator NAME. Return a value representing the
312 function, otherwise return NULL. */
314 static struct value
*
315 value_user_defined_op (struct value
**argp
, gdb::array_view
<value
*> args
,
316 char *name
, int *static_memfuncp
, enum noside noside
)
318 struct value
*result
= NULL
;
320 if (current_language
->la_language
== language_cplus
)
322 result
= value_user_defined_cpp_op (args
, name
, static_memfuncp
,
326 result
= value_struct_elt (argp
, args
.data (), name
, static_memfuncp
,
332 /* We know either arg1 or arg2 is a structure, so try to find the right
333 user defined function. Create an argument vector that calls
334 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
335 binary operator which is legal for GNU C++).
337 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
338 is the opcode saying how to modify it. Otherwise, OTHEROP is
342 value_x_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
,
343 enum exp_opcode otherop
, enum noside noside
)
349 arg1
= coerce_ref (arg1
);
350 arg2
= coerce_ref (arg2
);
352 /* now we know that what we have to do is construct our
353 arg vector and find the right function to call it with. */
355 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
356 error (_("Can't do that binary op on that type")); /* FIXME be explicit */
358 value
*argvec_storage
[3];
359 gdb::array_view
<value
*> argvec
= argvec_storage
;
361 argvec
[1] = value_addr (arg1
);
364 /* Make the right function name up. */
365 strcpy (tstr
, "operator__");
390 case BINOP_BITWISE_AND
:
393 case BINOP_BITWISE_IOR
:
396 case BINOP_BITWISE_XOR
:
399 case BINOP_LOGICAL_AND
:
402 case BINOP_LOGICAL_OR
:
414 case BINOP_ASSIGN_MODIFY
:
432 case BINOP_BITWISE_AND
:
435 case BINOP_BITWISE_IOR
:
438 case BINOP_BITWISE_XOR
:
441 case BINOP_MOD
: /* invalid */
443 error (_("Invalid binary operation specified."));
446 case BINOP_SUBSCRIPT
:
467 case BINOP_MOD
: /* invalid */
469 error (_("Invalid binary operation specified."));
472 argvec
[0] = value_user_defined_op (&arg1
, argvec
.slice (1), tstr
,
473 &static_memfuncp
, noside
);
479 argvec
[1] = argvec
[0];
480 argvec
= argvec
.slice (1);
482 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_XMETHOD
)
484 /* Static xmethods are not supported yet. */
485 gdb_assert (static_memfuncp
== 0);
486 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
488 struct type
*return_type
489 = result_type_of_xmethod (argvec
[0], argvec
.slice (1));
491 if (return_type
== NULL
)
492 error (_("Xmethod is missing return type."));
493 return value_zero (return_type
, VALUE_LVAL (arg1
));
495 return call_xmethod (argvec
[0], argvec
.slice (1));
497 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
499 struct type
*return_type
;
502 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
503 return value_zero (return_type
, VALUE_LVAL (arg1
));
505 return call_function_by_hand (argvec
[0], NULL
,
506 argvec
.slice (1, 2 - static_memfuncp
));
508 throw_error (NOT_FOUND_ERROR
,
509 _("member function %s not found"), tstr
);
512 /* We know that arg1 is a structure, so try to find a unary user
513 defined operator that matches the operator in question.
514 Create an argument vector that calls arg1.operator @ (arg1)
515 and return that value (where '@' is (almost) any unary operator which
516 is legal for GNU C++). */
519 value_x_unop (struct value
*arg1
, enum exp_opcode op
, enum noside noside
)
521 struct gdbarch
*gdbarch
= get_type_arch (value_type (arg1
));
523 char tstr
[13], mangle_tstr
[13];
524 int static_memfuncp
, nargs
;
526 arg1
= coerce_ref (arg1
);
528 /* now we know that what we have to do is construct our
529 arg vector and find the right function to call it with. */
531 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
532 error (_("Can't do that unary op on that type")); /* FIXME be explicit */
534 value
*argvec_storage
[3];
535 gdb::array_view
<value
*> argvec
= argvec_storage
;
537 argvec
[1] = value_addr (arg1
);
542 /* Make the right function name up. */
543 strcpy (tstr
, "operator__");
545 strcpy (mangle_tstr
, "__");
548 case UNOP_PREINCREMENT
:
551 case UNOP_PREDECREMENT
:
554 case UNOP_POSTINCREMENT
:
556 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
559 case UNOP_POSTDECREMENT
:
561 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
564 case UNOP_LOGICAL_NOT
:
567 case UNOP_COMPLEMENT
:
583 error (_("Invalid unary operation specified."));
586 argvec
[0] = value_user_defined_op (&arg1
, argvec
.slice (1, nargs
), tstr
,
587 &static_memfuncp
, noside
);
593 argvec
[1] = argvec
[0];
594 argvec
= argvec
.slice (1);
596 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_XMETHOD
)
598 /* Static xmethods are not supported yet. */
599 gdb_assert (static_memfuncp
== 0);
600 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
602 struct type
*return_type
603 = result_type_of_xmethod (argvec
[0], argvec
[1]);
605 if (return_type
== NULL
)
606 error (_("Xmethod is missing return type."));
607 return value_zero (return_type
, VALUE_LVAL (arg1
));
609 return call_xmethod (argvec
[0], argvec
[1]);
611 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
613 struct type
*return_type
;
616 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
617 return value_zero (return_type
, VALUE_LVAL (arg1
));
619 return call_function_by_hand (argvec
[0], NULL
,
620 argvec
.slice (1, nargs
));
622 throw_error (NOT_FOUND_ERROR
,
623 _("member function %s not found"), tstr
);
627 /* Concatenate two values with the following conditions:
629 (1) Both values must be either bitstring values or character string
630 values and the resulting value consists of the concatenation of
631 ARG1 followed by ARG2.
635 One value must be an integer value and the other value must be
636 either a bitstring value or character string value, which is
637 to be repeated by the number of times specified by the integer
641 (2) Boolean values are also allowed and are treated as bit string
644 (3) Character values are also allowed and are treated as character
645 string values of length 1. */
648 value_concat (struct value
*arg1
, struct value
*arg2
)
650 struct value
*inval1
;
651 struct value
*inval2
;
652 struct value
*outval
= NULL
;
653 int inval1len
, inval2len
;
656 struct type
*type1
= check_typedef (value_type (arg1
));
657 struct type
*type2
= check_typedef (value_type (arg2
));
658 struct type
*char_type
;
660 /* First figure out if we are dealing with two values to be concatenated
661 or a repeat count and a value to be repeated. INVAL1 is set to the
662 first of two concatenated values, or the repeat count. INVAL2 is set
663 to the second of the two concatenated values or the value to be
666 if (TYPE_CODE (type2
) == TYPE_CODE_INT
)
668 struct type
*tmp
= type1
;
681 /* Now process the input values. */
683 if (TYPE_CODE (type1
) == TYPE_CODE_INT
)
685 /* We have a repeat count. Validate the second value and then
686 construct a value repeated that many times. */
687 if (TYPE_CODE (type2
) == TYPE_CODE_STRING
688 || TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
690 count
= longest_to_int (value_as_long (inval1
));
691 inval2len
= TYPE_LENGTH (type2
);
692 std::vector
<char> ptr (count
* inval2len
);
693 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
697 inchar
= (char) unpack_long (type2
,
698 value_contents (inval2
));
699 for (idx
= 0; idx
< count
; idx
++)
706 char_type
= TYPE_TARGET_TYPE (type2
);
708 for (idx
= 0; idx
< count
; idx
++)
710 memcpy (&ptr
[idx
* inval2len
], value_contents (inval2
),
714 outval
= value_string (ptr
.data (), count
* inval2len
, char_type
);
716 else if (TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
718 error (_("unimplemented support for boolean repeats"));
722 error (_("can't repeat values of that type"));
725 else if (TYPE_CODE (type1
) == TYPE_CODE_STRING
726 || TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
728 /* We have two character strings to concatenate. */
729 if (TYPE_CODE (type2
) != TYPE_CODE_STRING
730 && TYPE_CODE (type2
) != TYPE_CODE_CHAR
)
732 error (_("Strings can only be concatenated with other strings."));
734 inval1len
= TYPE_LENGTH (type1
);
735 inval2len
= TYPE_LENGTH (type2
);
736 std::vector
<char> ptr (inval1len
+ inval2len
);
737 if (TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
741 ptr
[0] = (char) unpack_long (type1
, value_contents (inval1
));
745 char_type
= TYPE_TARGET_TYPE (type1
);
747 memcpy (ptr
.data (), value_contents (inval1
), inval1len
);
749 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
752 (char) unpack_long (type2
, value_contents (inval2
));
756 memcpy (&ptr
[inval1len
], value_contents (inval2
), inval2len
);
758 outval
= value_string (ptr
.data (), inval1len
+ inval2len
, char_type
);
760 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
)
762 /* We have two bitstrings to concatenate. */
763 if (TYPE_CODE (type2
) != TYPE_CODE_BOOL
)
765 error (_("Booleans can only be concatenated "
766 "with other bitstrings or booleans."));
768 error (_("unimplemented support for boolean concatenation."));
772 /* We don't know how to concatenate these operands. */
773 error (_("illegal operands for concatenation."));
778 /* Integer exponentiation: V1**V2, where both arguments are
779 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
782 integer_pow (LONGEST v1
, LONGEST v2
)
787 error (_("Attempt to raise 0 to negative power."));
793 /* The Russian Peasant's Algorithm. */
809 /* Integer exponentiation: V1**V2, where both arguments are
810 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
813 uinteger_pow (ULONGEST v1
, LONGEST v2
)
818 error (_("Attempt to raise 0 to negative power."));
824 /* The Russian Peasant's Algorithm. */
840 /* Obtain argument values for binary operation, converting from
841 other types if one of them is not floating point. */
843 value_args_as_target_float (struct value
*arg1
, struct value
*arg2
,
844 gdb_byte
*x
, struct type
**eff_type_x
,
845 gdb_byte
*y
, struct type
**eff_type_y
)
847 struct type
*type1
, *type2
;
849 type1
= check_typedef (value_type (arg1
));
850 type2
= check_typedef (value_type (arg2
));
852 /* At least one of the arguments must be of floating-point type. */
853 gdb_assert (is_floating_type (type1
) || is_floating_type (type2
));
855 if (is_floating_type (type1
) && is_floating_type (type2
)
856 && TYPE_CODE (type1
) != TYPE_CODE (type2
))
857 /* The DFP extension to the C language does not allow mixing of
858 * decimal float types with other float types in expressions
859 * (see WDTR 24732, page 12). */
860 error (_("Mixing decimal floating types with "
861 "other floating types is not allowed."));
863 /* Obtain value of arg1, converting from other types if necessary. */
865 if (is_floating_type (type1
))
868 memcpy (x
, value_contents (arg1
), TYPE_LENGTH (type1
));
870 else if (is_integral_type (type1
))
873 if (TYPE_UNSIGNED (type1
))
874 target_float_from_ulongest (x
, *eff_type_x
, value_as_long (arg1
));
876 target_float_from_longest (x
, *eff_type_x
, value_as_long (arg1
));
879 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
882 /* Obtain value of arg2, converting from other types if necessary. */
884 if (is_floating_type (type2
))
887 memcpy (y
, value_contents (arg2
), TYPE_LENGTH (type2
));
889 else if (is_integral_type (type2
))
892 if (TYPE_UNSIGNED (type2
))
893 target_float_from_ulongest (y
, *eff_type_y
, value_as_long (arg2
));
895 target_float_from_longest (y
, *eff_type_y
, value_as_long (arg2
));
898 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
902 /* Perform a binary operation on two operands which have reasonable
903 representations as integers or floats. This includes booleans,
904 characters, integers, or floats.
905 Does not support addition and subtraction on pointers;
906 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
908 static struct value
*
909 scalar_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
912 struct type
*type1
, *type2
, *result_type
;
914 arg1
= coerce_ref (arg1
);
915 arg2
= coerce_ref (arg2
);
917 type1
= check_typedef (value_type (arg1
));
918 type2
= check_typedef (value_type (arg2
));
920 if ((!is_floating_value (arg1
) && !is_integral_type (type1
))
921 || (!is_floating_value (arg2
) && !is_integral_type (type2
)))
922 error (_("Argument to arithmetic operation not a number or boolean."));
924 if (is_floating_type (type1
) || is_floating_type (type2
))
926 /* If only one type is floating-point, use its type.
927 Otherwise use the bigger type. */
928 if (!is_floating_type (type1
))
930 else if (!is_floating_type (type2
))
932 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
937 val
= allocate_value (result_type
);
939 struct type
*eff_type_v1
, *eff_type_v2
;
940 gdb::byte_vector v1
, v2
;
941 v1
.resize (TYPE_LENGTH (result_type
));
942 v2
.resize (TYPE_LENGTH (result_type
));
944 value_args_as_target_float (arg1
, arg2
,
945 v1
.data (), &eff_type_v1
,
946 v2
.data (), &eff_type_v2
);
947 target_float_binop (op
, v1
.data (), eff_type_v1
,
948 v2
.data (), eff_type_v2
,
949 value_contents_raw (val
), result_type
);
951 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
952 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
954 LONGEST v1
, v2
, v
= 0;
956 v1
= value_as_long (arg1
);
957 v2
= value_as_long (arg2
);
961 case BINOP_BITWISE_AND
:
965 case BINOP_BITWISE_IOR
:
969 case BINOP_BITWISE_XOR
:
982 error (_("Invalid operation on booleans."));
987 val
= allocate_value (result_type
);
988 store_signed_integer (value_contents_raw (val
),
989 TYPE_LENGTH (result_type
),
990 gdbarch_byte_order (get_type_arch (result_type
)),
994 /* Integral operations here. */
996 /* Determine type length of the result, and if the operation should
997 be done unsigned. For exponentiation and shift operators,
998 use the length and type of the left operand. Otherwise,
999 use the signedness of the operand with the greater length.
1000 If both operands are of equal length, use unsigned operation
1001 if one of the operands is unsigned. */
1002 if (op
== BINOP_RSH
|| op
== BINOP_LSH
|| op
== BINOP_EXP
)
1003 result_type
= type1
;
1004 else if (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
))
1005 result_type
= type1
;
1006 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1007 result_type
= type2
;
1008 else if (TYPE_UNSIGNED (type1
))
1009 result_type
= type1
;
1010 else if (TYPE_UNSIGNED (type2
))
1011 result_type
= type2
;
1013 result_type
= type1
;
1015 if (TYPE_UNSIGNED (result_type
))
1017 LONGEST v2_signed
= value_as_long (arg2
);
1018 ULONGEST v1
, v2
, v
= 0;
1020 v1
= (ULONGEST
) value_as_long (arg1
);
1021 v2
= (ULONGEST
) v2_signed
;
1042 error (_("Division by zero"));
1046 v
= uinteger_pow (v1
, v2_signed
);
1053 error (_("Division by zero"));
1057 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1058 v1 mod 0 has a defined value, v1. */
1066 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1079 case BINOP_BITWISE_AND
:
1083 case BINOP_BITWISE_IOR
:
1087 case BINOP_BITWISE_XOR
:
1091 case BINOP_LOGICAL_AND
:
1095 case BINOP_LOGICAL_OR
:
1100 v
= v1
< v2
? v1
: v2
;
1104 v
= v1
> v2
? v1
: v2
;
1111 case BINOP_NOTEQUAL
:
1132 error (_("Invalid binary operation on numbers."));
1135 val
= allocate_value (result_type
);
1136 store_unsigned_integer (value_contents_raw (val
),
1137 TYPE_LENGTH (value_type (val
)),
1139 (get_type_arch (result_type
)),
1144 LONGEST v1
, v2
, v
= 0;
1146 v1
= value_as_long (arg1
);
1147 v2
= value_as_long (arg2
);
1168 error (_("Division by zero"));
1172 v
= integer_pow (v1
, v2
);
1179 error (_("Division by zero"));
1183 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1184 X mod 0 has a defined value, X. */
1192 /* Compute floor. */
1193 if (TRUNCATION_TOWARDS_ZERO
&& (v
< 0) && ((v1
% v2
) != 0))
1209 case BINOP_BITWISE_AND
:
1213 case BINOP_BITWISE_IOR
:
1217 case BINOP_BITWISE_XOR
:
1221 case BINOP_LOGICAL_AND
:
1225 case BINOP_LOGICAL_OR
:
1230 v
= v1
< v2
? v1
: v2
;
1234 v
= v1
> v2
? v1
: v2
;
1241 case BINOP_NOTEQUAL
:
1262 error (_("Invalid binary operation on numbers."));
1265 val
= allocate_value (result_type
);
1266 store_signed_integer (value_contents_raw (val
),
1267 TYPE_LENGTH (value_type (val
)),
1269 (get_type_arch (result_type
)),
1277 /* Widen a scalar value SCALAR_VALUE to vector type VECTOR_TYPE by
1278 replicating SCALAR_VALUE for each element of the vector. Only scalar
1279 types that can be cast to the type of one element of the vector are
1280 acceptable. The newly created vector value is returned upon success,
1281 otherwise an error is thrown. */
1284 value_vector_widen (struct value
*scalar_value
, struct type
*vector_type
)
1286 /* Widen the scalar to a vector. */
1287 struct type
*eltype
, *scalar_type
;
1288 struct value
*val
, *elval
;
1289 LONGEST low_bound
, high_bound
;
1292 vector_type
= check_typedef (vector_type
);
1294 gdb_assert (TYPE_CODE (vector_type
) == TYPE_CODE_ARRAY
1295 && TYPE_VECTOR (vector_type
));
1297 if (!get_array_bounds (vector_type
, &low_bound
, &high_bound
))
1298 error (_("Could not determine the vector bounds"));
1300 eltype
= check_typedef (TYPE_TARGET_TYPE (vector_type
));
1301 elval
= value_cast (eltype
, scalar_value
);
1303 scalar_type
= check_typedef (value_type (scalar_value
));
1305 /* If we reduced the length of the scalar then check we didn't loose any
1307 if (TYPE_LENGTH (eltype
) < TYPE_LENGTH (scalar_type
)
1308 && !value_equal (elval
, scalar_value
))
1309 error (_("conversion of scalar to vector involves truncation"));
1311 val
= allocate_value (vector_type
);
1312 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1313 /* Duplicate the contents of elval into the destination vector. */
1314 memcpy (value_contents_writeable (val
) + (i
* TYPE_LENGTH (eltype
)),
1315 value_contents_all (elval
), TYPE_LENGTH (eltype
));
1320 /* Performs a binary operation on two vector operands by calling scalar_binop
1321 for each pair of vector components. */
1323 static struct value
*
1324 vector_binop (struct value
*val1
, struct value
*val2
, enum exp_opcode op
)
1326 struct value
*val
, *tmp
, *mark
;
1327 struct type
*type1
, *type2
, *eltype1
, *eltype2
;
1328 int t1_is_vec
, t2_is_vec
, elsize
, i
;
1329 LONGEST low_bound1
, high_bound1
, low_bound2
, high_bound2
;
1331 type1
= check_typedef (value_type (val1
));
1332 type2
= check_typedef (value_type (val2
));
1334 t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
1335 && TYPE_VECTOR (type1
)) ? 1 : 0;
1336 t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
1337 && TYPE_VECTOR (type2
)) ? 1 : 0;
1339 if (!t1_is_vec
|| !t2_is_vec
)
1340 error (_("Vector operations are only supported among vectors"));
1342 if (!get_array_bounds (type1
, &low_bound1
, &high_bound1
)
1343 || !get_array_bounds (type2
, &low_bound2
, &high_bound2
))
1344 error (_("Could not determine the vector bounds"));
1346 eltype1
= check_typedef (TYPE_TARGET_TYPE (type1
));
1347 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
));
1348 elsize
= TYPE_LENGTH (eltype1
);
1350 if (TYPE_CODE (eltype1
) != TYPE_CODE (eltype2
)
1351 || elsize
!= TYPE_LENGTH (eltype2
)
1352 || TYPE_UNSIGNED (eltype1
) != TYPE_UNSIGNED (eltype2
)
1353 || low_bound1
!= low_bound2
|| high_bound1
!= high_bound2
)
1354 error (_("Cannot perform operation on vectors with different types"));
1356 val
= allocate_value (type1
);
1357 mark
= value_mark ();
1358 for (i
= 0; i
< high_bound1
- low_bound1
+ 1; i
++)
1360 tmp
= value_binop (value_subscript (val1
, i
),
1361 value_subscript (val2
, i
), op
);
1362 memcpy (value_contents_writeable (val
) + i
* elsize
,
1363 value_contents_all (tmp
),
1366 value_free_to_mark (mark
);
1371 /* Perform a binary operation on two operands. */
1374 value_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
1377 struct type
*type1
= check_typedef (value_type (arg1
));
1378 struct type
*type2
= check_typedef (value_type (arg2
));
1379 int t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
1380 && TYPE_VECTOR (type1
));
1381 int t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
1382 && TYPE_VECTOR (type2
));
1384 if (!t1_is_vec
&& !t2_is_vec
)
1385 val
= scalar_binop (arg1
, arg2
, op
);
1386 else if (t1_is_vec
&& t2_is_vec
)
1387 val
= vector_binop (arg1
, arg2
, op
);
1390 /* Widen the scalar operand to a vector. */
1391 struct value
**v
= t1_is_vec
? &arg2
: &arg1
;
1392 struct type
*t
= t1_is_vec
? type2
: type1
;
1394 if (TYPE_CODE (t
) != TYPE_CODE_FLT
1395 && TYPE_CODE (t
) != TYPE_CODE_DECFLOAT
1396 && !is_integral_type (t
))
1397 error (_("Argument to operation not a number or boolean."));
1399 /* Replicate the scalar value to make a vector value. */
1400 *v
= value_vector_widen (*v
, t1_is_vec
? type1
: type2
);
1402 val
= vector_binop (arg1
, arg2
, op
);
1408 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1411 value_logical_not (struct value
*arg1
)
1417 arg1
= coerce_array (arg1
);
1418 type1
= check_typedef (value_type (arg1
));
1420 if (is_floating_value (arg1
))
1421 return target_float_is_zero (value_contents (arg1
), type1
);
1423 len
= TYPE_LENGTH (type1
);
1424 p
= value_contents (arg1
);
1435 /* Perform a comparison on two string values (whose content are not
1436 necessarily null terminated) based on their length. */
1439 value_strcmp (struct value
*arg1
, struct value
*arg2
)
1441 int len1
= TYPE_LENGTH (value_type (arg1
));
1442 int len2
= TYPE_LENGTH (value_type (arg2
));
1443 const gdb_byte
*s1
= value_contents (arg1
);
1444 const gdb_byte
*s2
= value_contents (arg2
);
1445 int i
, len
= len1
< len2
? len1
: len2
;
1447 for (i
= 0; i
< len
; i
++)
1451 else if (s1
[i
] > s2
[i
])
1459 else if (len1
> len2
)
1465 /* Simulate the C operator == by returning a 1
1466 iff ARG1 and ARG2 have equal contents. */
1469 value_equal (struct value
*arg1
, struct value
*arg2
)
1474 struct type
*type1
, *type2
;
1475 enum type_code code1
;
1476 enum type_code code2
;
1477 int is_int1
, is_int2
;
1479 arg1
= coerce_array (arg1
);
1480 arg2
= coerce_array (arg2
);
1482 type1
= check_typedef (value_type (arg1
));
1483 type2
= check_typedef (value_type (arg2
));
1484 code1
= TYPE_CODE (type1
);
1485 code2
= TYPE_CODE (type2
);
1486 is_int1
= is_integral_type (type1
);
1487 is_int2
= is_integral_type (type2
);
1489 if (is_int1
&& is_int2
)
1490 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1492 else if ((is_floating_value (arg1
) || is_int1
)
1493 && (is_floating_value (arg2
) || is_int2
))
1495 struct type
*eff_type_v1
, *eff_type_v2
;
1496 gdb::byte_vector v1
, v2
;
1497 v1
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1498 v2
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1500 value_args_as_target_float (arg1
, arg2
,
1501 v1
.data (), &eff_type_v1
,
1502 v2
.data (), &eff_type_v2
);
1504 return target_float_compare (v1
.data (), eff_type_v1
,
1505 v2
.data (), eff_type_v2
) == 0;
1508 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1510 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1511 return value_as_address (arg1
) == (CORE_ADDR
) value_as_long (arg2
);
1512 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1513 return (CORE_ADDR
) value_as_long (arg1
) == value_as_address (arg2
);
1515 else if (code1
== code2
1516 && ((len
= (int) TYPE_LENGTH (type1
))
1517 == (int) TYPE_LENGTH (type2
)))
1519 p1
= value_contents (arg1
);
1520 p2
= value_contents (arg2
);
1528 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1530 return value_strcmp (arg1
, arg2
) == 0;
1533 error (_("Invalid type combination in equality test."));
1536 /* Compare values based on their raw contents. Useful for arrays since
1537 value_equal coerces them to pointers, thus comparing just the address
1538 of the array instead of its contents. */
1541 value_equal_contents (struct value
*arg1
, struct value
*arg2
)
1543 struct type
*type1
, *type2
;
1545 type1
= check_typedef (value_type (arg1
));
1546 type2
= check_typedef (value_type (arg2
));
1548 return (TYPE_CODE (type1
) == TYPE_CODE (type2
)
1549 && TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
1550 && memcmp (value_contents (arg1
), value_contents (arg2
),
1551 TYPE_LENGTH (type1
)) == 0);
1554 /* Simulate the C operator < by returning 1
1555 iff ARG1's contents are less than ARG2's. */
1558 value_less (struct value
*arg1
, struct value
*arg2
)
1560 enum type_code code1
;
1561 enum type_code code2
;
1562 struct type
*type1
, *type2
;
1563 int is_int1
, is_int2
;
1565 arg1
= coerce_array (arg1
);
1566 arg2
= coerce_array (arg2
);
1568 type1
= check_typedef (value_type (arg1
));
1569 type2
= check_typedef (value_type (arg2
));
1570 code1
= TYPE_CODE (type1
);
1571 code2
= TYPE_CODE (type2
);
1572 is_int1
= is_integral_type (type1
);
1573 is_int2
= is_integral_type (type2
);
1575 if (is_int1
&& is_int2
)
1576 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1578 else if ((is_floating_value (arg1
) || is_int1
)
1579 && (is_floating_value (arg2
) || is_int2
))
1581 struct type
*eff_type_v1
, *eff_type_v2
;
1582 gdb::byte_vector v1
, v2
;
1583 v1
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1584 v2
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1586 value_args_as_target_float (arg1
, arg2
,
1587 v1
.data (), &eff_type_v1
,
1588 v2
.data (), &eff_type_v2
);
1590 return target_float_compare (v1
.data (), eff_type_v1
,
1591 v2
.data (), eff_type_v2
) == -1;
1593 else if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
1594 return value_as_address (arg1
) < value_as_address (arg2
);
1596 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1598 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1599 return value_as_address (arg1
) < (CORE_ADDR
) value_as_long (arg2
);
1600 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1601 return (CORE_ADDR
) value_as_long (arg1
) < value_as_address (arg2
);
1602 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1603 return value_strcmp (arg1
, arg2
) < 0;
1606 error (_("Invalid type combination in ordering comparison."));
1611 /* The unary operators +, - and ~. They free the argument ARG1. */
1614 value_pos (struct value
*arg1
)
1618 arg1
= coerce_ref (arg1
);
1619 type
= check_typedef (value_type (arg1
));
1621 if (is_integral_type (type
) || is_floating_value (arg1
)
1622 || (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
)))
1623 return value_from_contents (type
, value_contents (arg1
));
1625 error (_("Argument to positive operation not a number."));
1629 value_neg (struct value
*arg1
)
1633 arg1
= coerce_ref (arg1
);
1634 type
= check_typedef (value_type (arg1
));
1636 if (is_integral_type (type
) || is_floating_type (type
))
1637 return value_binop (value_from_longest (type
, 0), arg1
, BINOP_SUB
);
1638 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1640 struct value
*tmp
, *val
= allocate_value (type
);
1641 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1643 LONGEST low_bound
, high_bound
;
1645 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1646 error (_("Could not determine the vector bounds"));
1648 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1650 tmp
= value_neg (value_subscript (arg1
, i
));
1651 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
1652 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
1657 error (_("Argument to negate operation not a number."));
1661 value_complement (struct value
*arg1
)
1666 arg1
= coerce_ref (arg1
);
1667 type
= check_typedef (value_type (arg1
));
1669 if (is_integral_type (type
))
1670 val
= value_from_longest (type
, ~value_as_long (arg1
));
1671 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1674 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1676 LONGEST low_bound
, high_bound
;
1678 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1679 error (_("Could not determine the vector bounds"));
1681 val
= allocate_value (type
);
1682 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1684 tmp
= value_complement (value_subscript (arg1
, i
));
1685 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
1686 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
1690 error (_("Argument to complement operation not an integer, boolean."));
1695 /* The INDEX'th bit of SET value whose value_type is TYPE,
1696 and whose value_contents is valaddr.
1697 Return -1 if out of range, -2 other error. */
1700 value_bit_index (struct type
*type
, const gdb_byte
*valaddr
, int index
)
1702 struct gdbarch
*gdbarch
= get_type_arch (type
);
1703 LONGEST low_bound
, high_bound
;
1706 struct type
*range
= TYPE_INDEX_TYPE (type
);
1708 if (get_discrete_bounds (range
, &low_bound
, &high_bound
) < 0)
1710 if (index
< low_bound
|| index
> high_bound
)
1712 rel_index
= index
- low_bound
;
1713 word
= extract_unsigned_integer (valaddr
+ (rel_index
/ TARGET_CHAR_BIT
), 1,
1714 gdbarch_byte_order (gdbarch
));
1715 rel_index
%= TARGET_CHAR_BIT
;
1716 if (gdbarch_bits_big_endian (gdbarch
))
1717 rel_index
= TARGET_CHAR_BIT
- 1 - rel_index
;
1718 return (word
>> rel_index
) & 1;
1722 value_in (struct value
*element
, struct value
*set
)
1725 struct type
*settype
= check_typedef (value_type (set
));
1726 struct type
*eltype
= check_typedef (value_type (element
));
1728 if (TYPE_CODE (eltype
) == TYPE_CODE_RANGE
)
1729 eltype
= TYPE_TARGET_TYPE (eltype
);
1730 if (TYPE_CODE (settype
) != TYPE_CODE_SET
)
1731 error (_("Second argument of 'IN' has wrong type"));
1732 if (TYPE_CODE (eltype
) != TYPE_CODE_INT
1733 && TYPE_CODE (eltype
) != TYPE_CODE_CHAR
1734 && TYPE_CODE (eltype
) != TYPE_CODE_ENUM
1735 && TYPE_CODE (eltype
) != TYPE_CODE_BOOL
)
1736 error (_("First argument of 'IN' has wrong type"));
1737 member
= value_bit_index (settype
, value_contents (set
),
1738 value_as_long (element
));
1740 error (_("First argument of 'IN' not in range"));
1745 _initialize_valarith (void)
This page took 0.065192 seconds and 4 git commands to generate.