1 /* Perform arithmetic and other operations on values, for GDB.
3 Copyright (C) 1986-2018 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
|| (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type
)
193 && elt_offs
>= type_length_units (array_type
)))
195 if (type_not_associated (array_type
))
196 error (_("no such vector element (vector not associated)"));
197 else if (type_not_allocated (array_type
))
198 error (_("no such vector element (vector not allocated)"));
200 error (_("no such vector element"));
203 if (is_dynamic_type (elt_type
))
207 address
= value_address (array
) + elt_offs
;
208 elt_type
= resolve_dynamic_type (elt_type
, NULL
, address
);
211 return value_from_component (array
, elt_type
, elt_offs
);
215 /* Check to see if either argument is a structure, or a reference to
216 one. This is called so we know whether to go ahead with the normal
217 binop or look for a user defined function instead.
219 For now, we do not overload the `=' operator. */
222 binop_types_user_defined_p (enum exp_opcode op
,
223 struct type
*type1
, struct type
*type2
)
225 if (op
== BINOP_ASSIGN
|| op
== BINOP_CONCAT
)
228 type1
= check_typedef (type1
);
229 if (TYPE_IS_REFERENCE (type1
))
230 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
232 type2
= check_typedef (type2
);
233 if (TYPE_IS_REFERENCE (type2
))
234 type2
= check_typedef (TYPE_TARGET_TYPE (type2
));
236 return (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
237 || TYPE_CODE (type2
) == TYPE_CODE_STRUCT
);
240 /* Check to see if either argument is a structure, or a reference to
241 one. This is called so we know whether to go ahead with the normal
242 binop or look for a user defined function instead.
244 For now, we do not overload the `=' operator. */
247 binop_user_defined_p (enum exp_opcode op
,
248 struct value
*arg1
, struct value
*arg2
)
250 return binop_types_user_defined_p (op
, value_type (arg1
), value_type (arg2
));
253 /* Check to see if argument is a structure. This is called so
254 we know whether to go ahead with the normal unop or look for a
255 user defined function instead.
257 For now, we do not overload the `&' operator. */
260 unop_user_defined_p (enum exp_opcode op
, struct value
*arg1
)
266 type1
= check_typedef (value_type (arg1
));
267 if (TYPE_IS_REFERENCE (type1
))
268 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
269 return TYPE_CODE (type1
) == TYPE_CODE_STRUCT
;
272 /* Try to find an operator named OPERATOR which takes NARGS arguments
273 specified in ARGS. If the operator found is a static member operator
274 *STATIC_MEMFUNP will be set to 1, and otherwise 0.
275 The search if performed through find_overload_match which will handle
276 member operators, non member operators, operators imported implicitly or
277 explicitly, and perform correct overload resolution in all of the above
278 situations or combinations thereof. */
280 static struct value
*
281 value_user_defined_cpp_op (struct value
**args
, int nargs
, char *oper
,
282 int *static_memfuncp
, enum noside noside
)
285 struct symbol
*symp
= NULL
;
286 struct value
*valp
= NULL
;
288 find_overload_match (args
, nargs
, oper
, BOTH
/* could be method */,
290 NULL
/* pass NULL symbol since symbol is unknown */,
291 &valp
, &symp
, static_memfuncp
, 0, noside
);
298 /* This is a non member function and does not
299 expect a reference as its first argument
300 rather the explicit structure. */
301 args
[0] = value_ind (args
[0]);
302 return value_of_variable (symp
, 0);
305 error (_("Could not find %s."), oper
);
308 /* Lookup user defined operator NAME. Return a value representing the
309 function, otherwise return NULL. */
311 static struct value
*
312 value_user_defined_op (struct value
**argp
, struct value
**args
, char *name
,
313 int *static_memfuncp
, int nargs
, enum noside noside
)
315 struct value
*result
= NULL
;
317 if (current_language
->la_language
== language_cplus
)
319 result
= value_user_defined_cpp_op (args
, nargs
, name
, static_memfuncp
,
323 result
= value_struct_elt (argp
, args
, name
, static_memfuncp
,
329 /* We know either arg1 or arg2 is a structure, so try to find the right
330 user defined function. Create an argument vector that calls
331 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
332 binary operator which is legal for GNU C++).
334 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
335 is the opcode saying how to modify it. Otherwise, OTHEROP is
339 value_x_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
,
340 enum exp_opcode otherop
, enum noside noside
)
342 struct value
**argvec
;
347 arg1
= coerce_ref (arg1
);
348 arg2
= coerce_ref (arg2
);
350 /* now we know that what we have to do is construct our
351 arg vector and find the right function to call it with. */
353 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
354 error (_("Can't do that binary op on that type")); /* FIXME be explicit */
356 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
357 argvec
[1] = value_addr (arg1
);
361 /* Make the right function name up. */
362 strcpy (tstr
, "operator__");
387 case BINOP_BITWISE_AND
:
390 case BINOP_BITWISE_IOR
:
393 case BINOP_BITWISE_XOR
:
396 case BINOP_LOGICAL_AND
:
399 case BINOP_LOGICAL_OR
:
411 case BINOP_ASSIGN_MODIFY
:
429 case BINOP_BITWISE_AND
:
432 case BINOP_BITWISE_IOR
:
435 case BINOP_BITWISE_XOR
:
438 case BINOP_MOD
: /* invalid */
440 error (_("Invalid binary operation specified."));
443 case BINOP_SUBSCRIPT
:
464 case BINOP_MOD
: /* invalid */
466 error (_("Invalid binary operation specified."));
469 argvec
[0] = value_user_defined_op (&arg1
, argvec
+ 1, tstr
,
470 &static_memfuncp
, 2, noside
);
476 argvec
[1] = argvec
[0];
479 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_XMETHOD
)
481 /* Static xmethods are not supported yet. */
482 gdb_assert (static_memfuncp
== 0);
483 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
485 struct type
*return_type
486 = result_type_of_xmethod (argvec
[0], 2, argvec
+ 1);
488 if (return_type
== NULL
)
489 error (_("Xmethod is missing return type."));
490 return value_zero (return_type
, VALUE_LVAL (arg1
));
492 return call_xmethod (argvec
[0], 2, argvec
+ 1);
494 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
496 struct type
*return_type
;
499 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
500 return value_zero (return_type
, VALUE_LVAL (arg1
));
502 return call_function_by_hand (argvec
[0], NULL
, 2 - static_memfuncp
,
505 throw_error (NOT_FOUND_ERROR
,
506 _("member function %s not found"), tstr
);
508 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
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
));
522 struct value
**argvec
;
524 char tstr
[13], mangle_tstr
[13];
525 int static_memfuncp
, nargs
;
527 arg1
= coerce_ref (arg1
);
529 /* now we know that what we have to do is construct our
530 arg vector and find the right function to call it with. */
532 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
533 error (_("Can't do that unary op on that type")); /* FIXME be explicit */
535 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
536 argvec
[1] = value_addr (arg1
);
541 /* Make the right function name up. */
542 strcpy (tstr
, "operator__");
544 strcpy (mangle_tstr
, "__");
547 case UNOP_PREINCREMENT
:
550 case UNOP_PREDECREMENT
:
553 case UNOP_POSTINCREMENT
:
555 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);
565 case UNOP_LOGICAL_NOT
:
568 case UNOP_COMPLEMENT
:
584 error (_("Invalid unary operation specified."));
587 argvec
[0] = value_user_defined_op (&arg1
, argvec
+ 1, tstr
,
588 &static_memfuncp
, nargs
, noside
);
594 argvec
[1] = argvec
[0];
598 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_XMETHOD
)
600 /* Static xmethods are not supported yet. */
601 gdb_assert (static_memfuncp
== 0);
602 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
604 struct type
*return_type
605 = result_type_of_xmethod (argvec
[0], 1, argvec
+ 1);
607 if (return_type
== NULL
)
608 error (_("Xmethod is missing return type."));
609 return value_zero (return_type
, VALUE_LVAL (arg1
));
611 return call_xmethod (argvec
[0], 1, argvec
+ 1);
613 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
615 struct type
*return_type
;
618 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
619 return value_zero (return_type
, VALUE_LVAL (arg1
));
621 return call_function_by_hand (argvec
[0], NULL
, nargs
, argvec
+ 1);
623 throw_error (NOT_FOUND_ERROR
,
624 _("member function %s not found"), tstr
);
626 return 0; /* For lint -- never reached */
630 /* Concatenate two values with the following conditions:
632 (1) Both values must be either bitstring values or character string
633 values and the resulting value consists of the concatenation of
634 ARG1 followed by ARG2.
638 One value must be an integer value and the other value must be
639 either a bitstring value or character string value, which is
640 to be repeated by the number of times specified by the integer
644 (2) Boolean values are also allowed and are treated as bit string
647 (3) Character values are also allowed and are treated as character
648 string values of length 1. */
651 value_concat (struct value
*arg1
, struct value
*arg2
)
653 struct value
*inval1
;
654 struct value
*inval2
;
655 struct value
*outval
= NULL
;
656 int inval1len
, inval2len
;
659 struct type
*type1
= check_typedef (value_type (arg1
));
660 struct type
*type2
= check_typedef (value_type (arg2
));
661 struct type
*char_type
;
663 /* First figure out if we are dealing with two values to be concatenated
664 or a repeat count and a value to be repeated. INVAL1 is set to the
665 first of two concatenated values, or the repeat count. INVAL2 is set
666 to the second of the two concatenated values or the value to be
669 if (TYPE_CODE (type2
) == TYPE_CODE_INT
)
671 struct type
*tmp
= type1
;
684 /* Now process the input values. */
686 if (TYPE_CODE (type1
) == TYPE_CODE_INT
)
688 /* We have a repeat count. Validate the second value and then
689 construct a value repeated that many times. */
690 if (TYPE_CODE (type2
) == TYPE_CODE_STRING
691 || TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
693 count
= longest_to_int (value_as_long (inval1
));
694 inval2len
= TYPE_LENGTH (type2
);
695 std::vector
<char> ptr (count
* inval2len
);
696 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
700 inchar
= (char) unpack_long (type2
,
701 value_contents (inval2
));
702 for (idx
= 0; idx
< count
; idx
++)
709 char_type
= TYPE_TARGET_TYPE (type2
);
711 for (idx
= 0; idx
< count
; idx
++)
713 memcpy (&ptr
[idx
* inval2len
], value_contents (inval2
),
717 outval
= value_string (ptr
.data (), count
* inval2len
, char_type
);
719 else if (TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
721 error (_("unimplemented support for boolean repeats"));
725 error (_("can't repeat values of that type"));
728 else if (TYPE_CODE (type1
) == TYPE_CODE_STRING
729 || TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
731 /* We have two character strings to concatenate. */
732 if (TYPE_CODE (type2
) != TYPE_CODE_STRING
733 && TYPE_CODE (type2
) != TYPE_CODE_CHAR
)
735 error (_("Strings can only be concatenated with other strings."));
737 inval1len
= TYPE_LENGTH (type1
);
738 inval2len
= TYPE_LENGTH (type2
);
739 std::vector
<char> ptr (inval1len
+ inval2len
);
740 if (TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
744 ptr
[0] = (char) unpack_long (type1
, value_contents (inval1
));
748 char_type
= TYPE_TARGET_TYPE (type1
);
750 memcpy (ptr
.data (), value_contents (inval1
), inval1len
);
752 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
755 (char) unpack_long (type2
, value_contents (inval2
));
759 memcpy (&ptr
[inval1len
], value_contents (inval2
), inval2len
);
761 outval
= value_string (ptr
.data (), inval1len
+ inval2len
, char_type
);
763 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
)
765 /* We have two bitstrings to concatenate. */
766 if (TYPE_CODE (type2
) != TYPE_CODE_BOOL
)
768 error (_("Booleans can only be concatenated "
769 "with other bitstrings or booleans."));
771 error (_("unimplemented support for boolean concatenation."));
775 /* We don't know how to concatenate these operands. */
776 error (_("illegal operands for concatenation."));
781 /* Integer exponentiation: V1**V2, where both arguments are
782 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
785 integer_pow (LONGEST v1
, LONGEST v2
)
790 error (_("Attempt to raise 0 to negative power."));
796 /* The Russian Peasant's Algorithm. */
812 /* Integer exponentiation: V1**V2, where both arguments are
813 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
816 uinteger_pow (ULONGEST v1
, LONGEST v2
)
821 error (_("Attempt to raise 0 to negative power."));
827 /* The Russian Peasant's Algorithm. */
843 /* Obtain argument values for binary operation, converting from
844 other types if one of them is not floating point. */
846 value_args_as_target_float (struct value
*arg1
, struct value
*arg2
,
847 gdb_byte
*x
, struct type
**eff_type_x
,
848 gdb_byte
*y
, struct type
**eff_type_y
)
850 struct type
*type1
, *type2
;
852 type1
= check_typedef (value_type (arg1
));
853 type2
= check_typedef (value_type (arg2
));
855 /* At least one of the arguments must be of floating-point type. */
856 gdb_assert (is_floating_type (type1
) || is_floating_type (type2
));
858 if (is_floating_type (type1
) && is_floating_type (type2
)
859 && TYPE_CODE (type1
) != TYPE_CODE (type2
))
860 /* The DFP extension to the C language does not allow mixing of
861 * decimal float types with other float types in expressions
862 * (see WDTR 24732, page 12). */
863 error (_("Mixing decimal floating types with "
864 "other floating types is not allowed."));
866 /* Obtain value of arg1, converting from other types if necessary. */
868 if (is_floating_type (type1
))
871 memcpy (x
, value_contents (arg1
), TYPE_LENGTH (type1
));
873 else if (is_integral_type (type1
))
876 if (TYPE_UNSIGNED (type1
))
877 target_float_from_ulongest (x
, *eff_type_x
, value_as_long (arg1
));
879 target_float_from_longest (x
, *eff_type_x
, value_as_long (arg1
));
882 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
885 /* Obtain value of arg2, converting from other types if necessary. */
887 if (is_floating_type (type2
))
890 memcpy (y
, value_contents (arg2
), TYPE_LENGTH (type2
));
892 else if (is_integral_type (type2
))
895 if (TYPE_UNSIGNED (type2
))
896 target_float_from_ulongest (y
, *eff_type_y
, value_as_long (arg2
));
898 target_float_from_longest (y
, *eff_type_y
, value_as_long (arg2
));
901 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
905 /* Perform a binary operation on two operands which have reasonable
906 representations as integers or floats. This includes booleans,
907 characters, integers, or floats.
908 Does not support addition and subtraction on pointers;
909 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
911 static struct value
*
912 scalar_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
915 struct type
*type1
, *type2
, *result_type
;
917 arg1
= coerce_ref (arg1
);
918 arg2
= coerce_ref (arg2
);
920 type1
= check_typedef (value_type (arg1
));
921 type2
= check_typedef (value_type (arg2
));
923 if ((!is_floating_value (arg1
) && !is_integral_type (type1
))
924 || (!is_floating_value (arg2
) && !is_integral_type (type2
)))
925 error (_("Argument to arithmetic operation not a number or boolean."));
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
))
940 val
= allocate_value (result_type
);
942 struct type
*eff_type_v1
, *eff_type_v2
;
943 gdb::byte_vector v1
, v2
;
944 v1
.resize (TYPE_LENGTH (result_type
));
945 v2
.resize (TYPE_LENGTH (result_type
));
947 value_args_as_target_float (arg1
, arg2
,
948 v1
.data (), &eff_type_v1
,
949 v2
.data (), &eff_type_v2
);
950 target_float_binop (op
, v1
.data (), eff_type_v1
,
951 v2
.data (), eff_type_v2
,
952 value_contents_raw (val
), result_type
);
954 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
955 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
957 LONGEST v1
, v2
, v
= 0;
959 v1
= value_as_long (arg1
);
960 v2
= value_as_long (arg2
);
964 case BINOP_BITWISE_AND
:
968 case BINOP_BITWISE_IOR
:
972 case BINOP_BITWISE_XOR
:
985 error (_("Invalid operation on booleans."));
990 val
= allocate_value (result_type
);
991 store_signed_integer (value_contents_raw (val
),
992 TYPE_LENGTH (result_type
),
993 gdbarch_byte_order (get_type_arch (result_type
)),
997 /* Integral operations here. */
999 /* Determine type length of the result, and if the operation should
1000 be done unsigned. For exponentiation and shift operators,
1001 use the length and type of the left operand. Otherwise,
1002 use the signedness of the operand with the greater length.
1003 If both operands are of equal length, use unsigned operation
1004 if one of the operands is unsigned. */
1005 if (op
== BINOP_RSH
|| op
== BINOP_LSH
|| op
== BINOP_EXP
)
1006 result_type
= type1
;
1007 else if (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
))
1008 result_type
= type1
;
1009 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1010 result_type
= type2
;
1011 else if (TYPE_UNSIGNED (type1
))
1012 result_type
= type1
;
1013 else if (TYPE_UNSIGNED (type2
))
1014 result_type
= type2
;
1016 result_type
= type1
;
1018 if (TYPE_UNSIGNED (result_type
))
1020 LONGEST v2_signed
= value_as_long (arg2
);
1021 ULONGEST v1
, v2
, v
= 0;
1023 v1
= (ULONGEST
) value_as_long (arg1
);
1024 v2
= (ULONGEST
) v2_signed
;
1045 error (_("Division by zero"));
1049 v
= uinteger_pow (v1
, v2_signed
);
1056 error (_("Division by zero"));
1060 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1061 v1 mod 0 has a defined value, v1. */
1069 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1082 case BINOP_BITWISE_AND
:
1086 case BINOP_BITWISE_IOR
:
1090 case BINOP_BITWISE_XOR
:
1094 case BINOP_LOGICAL_AND
:
1098 case BINOP_LOGICAL_OR
:
1103 v
= v1
< v2
? v1
: v2
;
1107 v
= v1
> v2
? v1
: v2
;
1114 case BINOP_NOTEQUAL
:
1135 error (_("Invalid binary operation on numbers."));
1138 val
= allocate_value (result_type
);
1139 store_unsigned_integer (value_contents_raw (val
),
1140 TYPE_LENGTH (value_type (val
)),
1142 (get_type_arch (result_type
)),
1147 LONGEST v1
, v2
, v
= 0;
1149 v1
= value_as_long (arg1
);
1150 v2
= value_as_long (arg2
);
1171 error (_("Division by zero"));
1175 v
= integer_pow (v1
, v2
);
1182 error (_("Division by zero"));
1186 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1187 X mod 0 has a defined value, X. */
1195 /* Compute floor. */
1196 if (TRUNCATION_TOWARDS_ZERO
&& (v
< 0) && ((v1
% v2
) != 0))
1212 case BINOP_BITWISE_AND
:
1216 case BINOP_BITWISE_IOR
:
1220 case BINOP_BITWISE_XOR
:
1224 case BINOP_LOGICAL_AND
:
1228 case BINOP_LOGICAL_OR
:
1233 v
= v1
< v2
? v1
: v2
;
1237 v
= v1
> v2
? v1
: v2
;
1244 case BINOP_NOTEQUAL
:
1265 error (_("Invalid binary operation on numbers."));
1268 val
= allocate_value (result_type
);
1269 store_signed_integer (value_contents_raw (val
),
1270 TYPE_LENGTH (value_type (val
)),
1272 (get_type_arch (result_type
)),
1280 /* Widen a scalar value SCALAR_VALUE to vector type VECTOR_TYPE by
1281 replicating SCALAR_VALUE for each element of the vector. Only scalar
1282 types that can be cast to the type of one element of the vector are
1283 acceptable. The newly created vector value is returned upon success,
1284 otherwise an error is thrown. */
1287 value_vector_widen (struct value
*scalar_value
, struct type
*vector_type
)
1289 /* Widen the scalar to a vector. */
1290 struct type
*eltype
, *scalar_type
;
1291 struct value
*val
, *elval
;
1292 LONGEST low_bound
, high_bound
;
1295 vector_type
= check_typedef (vector_type
);
1297 gdb_assert (TYPE_CODE (vector_type
) == TYPE_CODE_ARRAY
1298 && TYPE_VECTOR (vector_type
));
1300 if (!get_array_bounds (vector_type
, &low_bound
, &high_bound
))
1301 error (_("Could not determine the vector bounds"));
1303 eltype
= check_typedef (TYPE_TARGET_TYPE (vector_type
));
1304 elval
= value_cast (eltype
, scalar_value
);
1306 scalar_type
= check_typedef (value_type (scalar_value
));
1308 /* If we reduced the length of the scalar then check we didn't loose any
1310 if (TYPE_LENGTH (eltype
) < TYPE_LENGTH (scalar_type
)
1311 && !value_equal (elval
, scalar_value
))
1312 error (_("conversion of scalar to vector involves truncation"));
1314 val
= allocate_value (vector_type
);
1315 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1316 /* Duplicate the contents of elval into the destination vector. */
1317 memcpy (value_contents_writeable (val
) + (i
* TYPE_LENGTH (eltype
)),
1318 value_contents_all (elval
), TYPE_LENGTH (eltype
));
1323 /* Performs a binary operation on two vector operands by calling scalar_binop
1324 for each pair of vector components. */
1326 static struct value
*
1327 vector_binop (struct value
*val1
, struct value
*val2
, enum exp_opcode op
)
1329 struct value
*val
, *tmp
, *mark
;
1330 struct type
*type1
, *type2
, *eltype1
, *eltype2
;
1331 int t1_is_vec
, t2_is_vec
, elsize
, i
;
1332 LONGEST low_bound1
, high_bound1
, low_bound2
, high_bound2
;
1334 type1
= check_typedef (value_type (val1
));
1335 type2
= check_typedef (value_type (val2
));
1337 t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
1338 && TYPE_VECTOR (type1
)) ? 1 : 0;
1339 t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
1340 && TYPE_VECTOR (type2
)) ? 1 : 0;
1342 if (!t1_is_vec
|| !t2_is_vec
)
1343 error (_("Vector operations are only supported among vectors"));
1345 if (!get_array_bounds (type1
, &low_bound1
, &high_bound1
)
1346 || !get_array_bounds (type2
, &low_bound2
, &high_bound2
))
1347 error (_("Could not determine the vector bounds"));
1349 eltype1
= check_typedef (TYPE_TARGET_TYPE (type1
));
1350 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
));
1351 elsize
= TYPE_LENGTH (eltype1
);
1353 if (TYPE_CODE (eltype1
) != TYPE_CODE (eltype2
)
1354 || elsize
!= TYPE_LENGTH (eltype2
)
1355 || TYPE_UNSIGNED (eltype1
) != TYPE_UNSIGNED (eltype2
)
1356 || low_bound1
!= low_bound2
|| high_bound1
!= high_bound2
)
1357 error (_("Cannot perform operation on vectors with different types"));
1359 val
= allocate_value (type1
);
1360 mark
= value_mark ();
1361 for (i
= 0; i
< high_bound1
- low_bound1
+ 1; i
++)
1363 tmp
= value_binop (value_subscript (val1
, i
),
1364 value_subscript (val2
, i
), op
);
1365 memcpy (value_contents_writeable (val
) + i
* elsize
,
1366 value_contents_all (tmp
),
1369 value_free_to_mark (mark
);
1374 /* Perform a binary operation on two operands. */
1377 value_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
1380 struct type
*type1
= check_typedef (value_type (arg1
));
1381 struct type
*type2
= check_typedef (value_type (arg2
));
1382 int t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
1383 && TYPE_VECTOR (type1
));
1384 int t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
1385 && TYPE_VECTOR (type2
));
1387 if (!t1_is_vec
&& !t2_is_vec
)
1388 val
= scalar_binop (arg1
, arg2
, op
);
1389 else if (t1_is_vec
&& t2_is_vec
)
1390 val
= vector_binop (arg1
, arg2
, op
);
1393 /* Widen the scalar operand to a vector. */
1394 struct value
**v
= t1_is_vec
? &arg2
: &arg1
;
1395 struct type
*t
= t1_is_vec
? type2
: type1
;
1397 if (TYPE_CODE (t
) != TYPE_CODE_FLT
1398 && TYPE_CODE (t
) != TYPE_CODE_DECFLOAT
1399 && !is_integral_type (t
))
1400 error (_("Argument to operation not a number or boolean."));
1402 /* Replicate the scalar value to make a vector value. */
1403 *v
= value_vector_widen (*v
, t1_is_vec
? type1
: type2
);
1405 val
= vector_binop (arg1
, arg2
, op
);
1411 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1414 value_logical_not (struct value
*arg1
)
1420 arg1
= coerce_array (arg1
);
1421 type1
= check_typedef (value_type (arg1
));
1423 if (is_floating_value (arg1
))
1424 return target_float_is_zero (value_contents (arg1
), type1
);
1426 len
= TYPE_LENGTH (type1
);
1427 p
= value_contents (arg1
);
1438 /* Perform a comparison on two string values (whose content are not
1439 necessarily null terminated) based on their length. */
1442 value_strcmp (struct value
*arg1
, struct value
*arg2
)
1444 int len1
= TYPE_LENGTH (value_type (arg1
));
1445 int len2
= TYPE_LENGTH (value_type (arg2
));
1446 const gdb_byte
*s1
= value_contents (arg1
);
1447 const gdb_byte
*s2
= value_contents (arg2
);
1448 int i
, len
= len1
< len2
? len1
: len2
;
1450 for (i
= 0; i
< len
; i
++)
1454 else if (s1
[i
] > s2
[i
])
1462 else if (len1
> len2
)
1468 /* Simulate the C operator == by returning a 1
1469 iff ARG1 and ARG2 have equal contents. */
1472 value_equal (struct value
*arg1
, struct value
*arg2
)
1477 struct type
*type1
, *type2
;
1478 enum type_code code1
;
1479 enum type_code code2
;
1480 int is_int1
, is_int2
;
1482 arg1
= coerce_array (arg1
);
1483 arg2
= coerce_array (arg2
);
1485 type1
= check_typedef (value_type (arg1
));
1486 type2
= check_typedef (value_type (arg2
));
1487 code1
= TYPE_CODE (type1
);
1488 code2
= TYPE_CODE (type2
);
1489 is_int1
= is_integral_type (type1
);
1490 is_int2
= is_integral_type (type2
);
1492 if (is_int1
&& is_int2
)
1493 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1495 else if ((is_floating_value (arg1
) || is_int1
)
1496 && (is_floating_value (arg2
) || is_int2
))
1498 struct type
*eff_type_v1
, *eff_type_v2
;
1499 gdb::byte_vector v1
, v2
;
1500 v1
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1501 v2
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1503 value_args_as_target_float (arg1
, arg2
,
1504 v1
.data (), &eff_type_v1
,
1505 v2
.data (), &eff_type_v2
);
1507 return target_float_compare (v1
.data (), eff_type_v1
,
1508 v2
.data (), eff_type_v2
) == 0;
1511 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1513 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1514 return value_as_address (arg1
) == (CORE_ADDR
) value_as_long (arg2
);
1515 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1516 return (CORE_ADDR
) value_as_long (arg1
) == value_as_address (arg2
);
1518 else if (code1
== code2
1519 && ((len
= (int) TYPE_LENGTH (type1
))
1520 == (int) TYPE_LENGTH (type2
)))
1522 p1
= value_contents (arg1
);
1523 p2
= value_contents (arg2
);
1531 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1533 return value_strcmp (arg1
, arg2
) == 0;
1537 error (_("Invalid type combination in equality test."));
1538 return 0; /* For lint -- never reached. */
1542 /* Compare values based on their raw contents. Useful for arrays since
1543 value_equal coerces them to pointers, thus comparing just the address
1544 of the array instead of its contents. */
1547 value_equal_contents (struct value
*arg1
, struct value
*arg2
)
1549 struct type
*type1
, *type2
;
1551 type1
= check_typedef (value_type (arg1
));
1552 type2
= check_typedef (value_type (arg2
));
1554 return (TYPE_CODE (type1
) == TYPE_CODE (type2
)
1555 && TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
1556 && memcmp (value_contents (arg1
), value_contents (arg2
),
1557 TYPE_LENGTH (type1
)) == 0);
1560 /* Simulate the C operator < by returning 1
1561 iff ARG1's contents are less than ARG2's. */
1564 value_less (struct value
*arg1
, struct value
*arg2
)
1566 enum type_code code1
;
1567 enum type_code code2
;
1568 struct type
*type1
, *type2
;
1569 int is_int1
, is_int2
;
1571 arg1
= coerce_array (arg1
);
1572 arg2
= coerce_array (arg2
);
1574 type1
= check_typedef (value_type (arg1
));
1575 type2
= check_typedef (value_type (arg2
));
1576 code1
= TYPE_CODE (type1
);
1577 code2
= TYPE_CODE (type2
);
1578 is_int1
= is_integral_type (type1
);
1579 is_int2
= is_integral_type (type2
);
1581 if (is_int1
&& is_int2
)
1582 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1584 else if ((is_floating_value (arg1
) || is_int1
)
1585 && (is_floating_value (arg2
) || is_int2
))
1587 struct type
*eff_type_v1
, *eff_type_v2
;
1588 gdb::byte_vector v1
, v2
;
1589 v1
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1590 v2
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1592 value_args_as_target_float (arg1
, arg2
,
1593 v1
.data (), &eff_type_v1
,
1594 v2
.data (), &eff_type_v2
);
1596 return target_float_compare (v1
.data (), eff_type_v1
,
1597 v2
.data (), eff_type_v2
) == -1;
1599 else if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
1600 return value_as_address (arg1
) < value_as_address (arg2
);
1602 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1604 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1605 return value_as_address (arg1
) < (CORE_ADDR
) value_as_long (arg2
);
1606 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1607 return (CORE_ADDR
) value_as_long (arg1
) < value_as_address (arg2
);
1608 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1609 return value_strcmp (arg1
, arg2
) < 0;
1612 error (_("Invalid type combination in ordering comparison."));
1617 /* The unary operators +, - and ~. They free the argument ARG1. */
1620 value_pos (struct value
*arg1
)
1624 arg1
= coerce_ref (arg1
);
1625 type
= check_typedef (value_type (arg1
));
1627 if (is_integral_type (type
) || is_floating_value (arg1
)
1628 || (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
)))
1629 return value_from_contents (type
, value_contents (arg1
));
1632 error (_("Argument to positive operation not a number."));
1633 return 0; /* For lint -- never reached. */
1638 value_neg (struct value
*arg1
)
1642 arg1
= coerce_ref (arg1
);
1643 type
= check_typedef (value_type (arg1
));
1645 if (is_integral_type (type
) || is_floating_type (type
))
1646 return value_binop (value_from_longest (type
, 0), arg1
, BINOP_SUB
);
1647 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1649 struct value
*tmp
, *val
= allocate_value (type
);
1650 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1652 LONGEST low_bound
, high_bound
;
1654 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1655 error (_("Could not determine the vector bounds"));
1657 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1659 tmp
= value_neg (value_subscript (arg1
, i
));
1660 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
1661 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
1667 error (_("Argument to negate operation not a number."));
1668 return 0; /* For lint -- never reached. */
1673 value_complement (struct value
*arg1
)
1678 arg1
= coerce_ref (arg1
);
1679 type
= check_typedef (value_type (arg1
));
1681 if (is_integral_type (type
))
1682 val
= value_from_longest (type
, ~value_as_long (arg1
));
1683 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1686 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1688 LONGEST low_bound
, high_bound
;
1690 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1691 error (_("Could not determine the vector bounds"));
1693 val
= allocate_value (type
);
1694 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1696 tmp
= value_complement (value_subscript (arg1
, i
));
1697 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
1698 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
1702 error (_("Argument to complement operation not an integer, boolean."));
1707 /* The INDEX'th bit of SET value whose value_type is TYPE,
1708 and whose value_contents is valaddr.
1709 Return -1 if out of range, -2 other error. */
1712 value_bit_index (struct type
*type
, const gdb_byte
*valaddr
, int index
)
1714 struct gdbarch
*gdbarch
= get_type_arch (type
);
1715 LONGEST low_bound
, high_bound
;
1718 struct type
*range
= TYPE_INDEX_TYPE (type
);
1720 if (get_discrete_bounds (range
, &low_bound
, &high_bound
) < 0)
1722 if (index
< low_bound
|| index
> high_bound
)
1724 rel_index
= index
- low_bound
;
1725 word
= extract_unsigned_integer (valaddr
+ (rel_index
/ TARGET_CHAR_BIT
), 1,
1726 gdbarch_byte_order (gdbarch
));
1727 rel_index
%= TARGET_CHAR_BIT
;
1728 if (gdbarch_bits_big_endian (gdbarch
))
1729 rel_index
= TARGET_CHAR_BIT
- 1 - rel_index
;
1730 return (word
>> rel_index
) & 1;
1734 value_in (struct value
*element
, struct value
*set
)
1737 struct type
*settype
= check_typedef (value_type (set
));
1738 struct type
*eltype
= check_typedef (value_type (element
));
1740 if (TYPE_CODE (eltype
) == TYPE_CODE_RANGE
)
1741 eltype
= TYPE_TARGET_TYPE (eltype
);
1742 if (TYPE_CODE (settype
) != TYPE_CODE_SET
)
1743 error (_("Second argument of 'IN' has wrong type"));
1744 if (TYPE_CODE (eltype
) != TYPE_CODE_INT
1745 && TYPE_CODE (eltype
) != TYPE_CODE_CHAR
1746 && TYPE_CODE (eltype
) != TYPE_CODE_ENUM
1747 && TYPE_CODE (eltype
) != TYPE_CODE_BOOL
)
1748 error (_("First argument of 'IN' has wrong type"));
1749 member
= value_bit_index (settype
, value_contents (set
),
1750 value_as_long (element
));
1752 error (_("First argument of 'IN' not in range"));
1757 _initialize_valarith (void)
This page took 0.066592 seconds and 4 git commands to generate.