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 name
= TYPE_TAG_NAME (ptr_target
);
66 error (_("Cannot perform pointer math on incomplete types, "
67 "try casting to a known type, or void *."));
69 error (_("Cannot perform pointer math on incomplete type \"%s\", "
70 "try casting to a known type, or void *."), name
);
76 /* Given a pointer ARG1 and an integral value ARG2, return the
77 result of C-style pointer arithmetic ARG1 + ARG2. */
80 value_ptradd (struct value
*arg1
, LONGEST arg2
)
82 struct type
*valptrtype
;
86 arg1
= coerce_array (arg1
);
87 valptrtype
= check_typedef (value_type (arg1
));
88 sz
= find_size_for_pointer_math (valptrtype
);
90 result
= value_from_pointer (valptrtype
,
91 value_as_address (arg1
) + sz
* arg2
);
92 if (VALUE_LVAL (result
) != lval_internalvar
)
93 set_value_component_location (result
, arg1
);
97 /* Given two compatible pointer values ARG1 and ARG2, return the
98 result of C-style pointer arithmetic ARG1 - ARG2. */
101 value_ptrdiff (struct value
*arg1
, struct value
*arg2
)
103 struct type
*type1
, *type2
;
106 arg1
= coerce_array (arg1
);
107 arg2
= coerce_array (arg2
);
108 type1
= check_typedef (value_type (arg1
));
109 type2
= check_typedef (value_type (arg2
));
111 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_PTR
);
112 gdb_assert (TYPE_CODE (type2
) == TYPE_CODE_PTR
);
114 if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)))
115 != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2
))))
116 error (_("First argument of `-' is a pointer and "
117 "second argument is neither\n"
118 "an integer nor a pointer of the same type."));
120 sz
= type_length_units (check_typedef (TYPE_TARGET_TYPE (type1
)));
123 warning (_("Type size unknown, assuming 1. "
124 "Try casting to a known type, or void *."));
128 return (value_as_long (arg1
) - value_as_long (arg2
)) / sz
;
131 /* Return the value of ARRAY[IDX].
133 ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING. If the
134 current language supports C-style arrays, it may also be TYPE_CODE_PTR.
136 See comments in value_coerce_array() for rationale for reason for
137 doing lower bounds adjustment here rather than there.
138 FIXME: Perhaps we should validate that the index is valid and if
139 verbosity is set, warn about invalid indices (but still use them). */
142 value_subscript (struct value
*array
, LONGEST index
)
144 int c_style
= current_language
->c_style_arrays
;
147 array
= coerce_ref (array
);
148 tarray
= check_typedef (value_type (array
));
150 if (TYPE_CODE (tarray
) == TYPE_CODE_ARRAY
151 || TYPE_CODE (tarray
) == TYPE_CODE_STRING
)
153 struct type
*range_type
= TYPE_INDEX_TYPE (tarray
);
154 LONGEST lowerbound
, upperbound
;
156 get_discrete_bounds (range_type
, &lowerbound
, &upperbound
);
157 if (VALUE_LVAL (array
) != lval_memory
)
158 return value_subscripted_rvalue (array
, index
, lowerbound
);
162 if (index
>= lowerbound
&& index
<= upperbound
)
163 return value_subscripted_rvalue (array
, index
, lowerbound
);
164 /* Emit warning unless we have an array of unknown size.
165 An array of unknown size has lowerbound 0 and upperbound -1. */
167 warning (_("array or string index out of range"));
168 /* fall doing C stuff */
173 array
= value_coerce_array (array
);
177 return value_ind (value_ptradd (array
, index
));
179 error (_("not an array or string"));
182 /* Return the value of EXPR[IDX], expr an aggregate rvalue
183 (eg, a vector register). This routine used to promote floats
184 to doubles, but no longer does. */
187 value_subscripted_rvalue (struct value
*array
, LONGEST index
, int lowerbound
)
189 struct type
*array_type
= check_typedef (value_type (array
));
190 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (array_type
));
191 ULONGEST elt_size
= type_length_units (elt_type
);
192 ULONGEST elt_offs
= elt_size
* (index
- lowerbound
);
194 if (index
< lowerbound
|| (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type
)
195 && elt_offs
>= type_length_units (array_type
)))
197 if (type_not_associated (array_type
))
198 error (_("no such vector element (vector not associated)"));
199 else if (type_not_allocated (array_type
))
200 error (_("no such vector element (vector not allocated)"));
202 error (_("no such vector element"));
205 if (is_dynamic_type (elt_type
))
209 address
= value_address (array
) + elt_offs
;
210 elt_type
= resolve_dynamic_type (elt_type
, NULL
, address
);
213 return value_from_component (array
, elt_type
, elt_offs
);
217 /* Check to see if either argument is a structure, or a reference to
218 one. This is called so we know whether to go ahead with the normal
219 binop or look for a user defined function instead.
221 For now, we do not overload the `=' operator. */
224 binop_types_user_defined_p (enum exp_opcode op
,
225 struct type
*type1
, struct type
*type2
)
227 if (op
== BINOP_ASSIGN
|| op
== BINOP_CONCAT
)
230 type1
= check_typedef (type1
);
231 if (TYPE_IS_REFERENCE (type1
))
232 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
234 type2
= check_typedef (type2
);
235 if (TYPE_IS_REFERENCE (type2
))
236 type2
= check_typedef (TYPE_TARGET_TYPE (type2
));
238 return (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
239 || TYPE_CODE (type2
) == TYPE_CODE_STRUCT
);
242 /* Check to see if either argument is a structure, or a reference to
243 one. This is called so we know whether to go ahead with the normal
244 binop or look for a user defined function instead.
246 For now, we do not overload the `=' operator. */
249 binop_user_defined_p (enum exp_opcode op
,
250 struct value
*arg1
, struct value
*arg2
)
252 return binop_types_user_defined_p (op
, value_type (arg1
), value_type (arg2
));
255 /* Check to see if argument is a structure. This is called so
256 we know whether to go ahead with the normal unop or look for a
257 user defined function instead.
259 For now, we do not overload the `&' operator. */
262 unop_user_defined_p (enum exp_opcode op
, struct value
*arg1
)
268 type1
= check_typedef (value_type (arg1
));
269 if (TYPE_IS_REFERENCE (type1
))
270 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
271 return TYPE_CODE (type1
) == TYPE_CODE_STRUCT
;
274 /* Try to find an operator named OPERATOR which takes NARGS arguments
275 specified in ARGS. If the operator found is a static member operator
276 *STATIC_MEMFUNP will be set to 1, and otherwise 0.
277 The search if performed through find_overload_match which will handle
278 member operators, non member operators, operators imported implicitly or
279 explicitly, and perform correct overload resolution in all of the above
280 situations or combinations thereof. */
282 static struct value
*
283 value_user_defined_cpp_op (struct value
**args
, int nargs
, char *oper
,
284 int *static_memfuncp
, enum noside noside
)
287 struct symbol
*symp
= NULL
;
288 struct value
*valp
= NULL
;
290 find_overload_match (args
, nargs
, oper
, BOTH
/* could be method */,
292 NULL
/* pass NULL symbol since symbol is unknown */,
293 &valp
, &symp
, static_memfuncp
, 0, noside
);
300 /* This is a non member function and does not
301 expect a reference as its first argument
302 rather the explicit structure. */
303 args
[0] = value_ind (args
[0]);
304 return value_of_variable (symp
, 0);
307 error (_("Could not find %s."), oper
);
310 /* Lookup user defined operator NAME. Return a value representing the
311 function, otherwise return NULL. */
313 static struct value
*
314 value_user_defined_op (struct value
**argp
, struct value
**args
, char *name
,
315 int *static_memfuncp
, int nargs
, enum noside noside
)
317 struct value
*result
= NULL
;
319 if (current_language
->la_language
== language_cplus
)
321 result
= value_user_defined_cpp_op (args
, nargs
, name
, static_memfuncp
,
325 result
= value_struct_elt (argp
, args
, name
, static_memfuncp
,
331 /* We know either arg1 or arg2 is a structure, so try to find the right
332 user defined function. Create an argument vector that calls
333 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
334 binary operator which is legal for GNU C++).
336 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
337 is the opcode saying how to modify it. Otherwise, OTHEROP is
341 value_x_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
,
342 enum exp_opcode otherop
, enum noside noside
)
344 struct value
**argvec
;
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 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
359 argvec
[1] = value_addr (arg1
);
363 /* Make the right function name up. */
364 strcpy (tstr
, "operator__");
389 case BINOP_BITWISE_AND
:
392 case BINOP_BITWISE_IOR
:
395 case BINOP_BITWISE_XOR
:
398 case BINOP_LOGICAL_AND
:
401 case BINOP_LOGICAL_OR
:
413 case BINOP_ASSIGN_MODIFY
:
431 case BINOP_BITWISE_AND
:
434 case BINOP_BITWISE_IOR
:
437 case BINOP_BITWISE_XOR
:
440 case BINOP_MOD
: /* invalid */
442 error (_("Invalid binary operation specified."));
445 case BINOP_SUBSCRIPT
:
466 case BINOP_MOD
: /* invalid */
468 error (_("Invalid binary operation specified."));
471 argvec
[0] = value_user_defined_op (&arg1
, argvec
+ 1, tstr
,
472 &static_memfuncp
, 2, noside
);
478 argvec
[1] = argvec
[0];
481 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_XMETHOD
)
483 /* Static xmethods are not supported yet. */
484 gdb_assert (static_memfuncp
== 0);
485 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
487 struct type
*return_type
488 = result_type_of_xmethod (argvec
[0], 2, argvec
+ 1);
490 if (return_type
== NULL
)
491 error (_("Xmethod is missing return type."));
492 return value_zero (return_type
, VALUE_LVAL (arg1
));
494 return call_xmethod (argvec
[0], 2, argvec
+ 1);
496 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
498 struct type
*return_type
;
501 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
502 return value_zero (return_type
, VALUE_LVAL (arg1
));
504 return call_function_by_hand (argvec
[0], NULL
, 2 - static_memfuncp
,
507 throw_error (NOT_FOUND_ERROR
,
508 _("member function %s not found"), tstr
);
510 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
514 /* We know that arg1 is a structure, so try to find a unary user
515 defined operator that matches the operator in question.
516 Create an argument vector that calls arg1.operator @ (arg1)
517 and return that value (where '@' is (almost) any unary operator which
518 is legal for GNU C++). */
521 value_x_unop (struct value
*arg1
, enum exp_opcode op
, enum noside noside
)
523 struct gdbarch
*gdbarch
= get_type_arch (value_type (arg1
));
524 struct value
**argvec
;
526 char tstr
[13], mangle_tstr
[13];
527 int static_memfuncp
, nargs
;
529 arg1
= coerce_ref (arg1
);
531 /* now we know that what we have to do is construct our
532 arg vector and find the right function to call it with. */
534 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
535 error (_("Can't do that unary op on that type")); /* FIXME be explicit */
537 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
538 argvec
[1] = value_addr (arg1
);
543 /* Make the right function name up. */
544 strcpy (tstr
, "operator__");
546 strcpy (mangle_tstr
, "__");
549 case UNOP_PREINCREMENT
:
552 case UNOP_PREDECREMENT
:
555 case UNOP_POSTINCREMENT
:
557 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
561 case UNOP_POSTDECREMENT
:
563 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
567 case UNOP_LOGICAL_NOT
:
570 case UNOP_COMPLEMENT
:
586 error (_("Invalid unary operation specified."));
589 argvec
[0] = value_user_defined_op (&arg1
, argvec
+ 1, tstr
,
590 &static_memfuncp
, nargs
, noside
);
596 argvec
[1] = argvec
[0];
600 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_XMETHOD
)
602 /* Static xmethods are not supported yet. */
603 gdb_assert (static_memfuncp
== 0);
604 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
606 struct type
*return_type
607 = result_type_of_xmethod (argvec
[0], 1, argvec
+ 1);
609 if (return_type
== NULL
)
610 error (_("Xmethod is missing return type."));
611 return value_zero (return_type
, VALUE_LVAL (arg1
));
613 return call_xmethod (argvec
[0], 1, argvec
+ 1);
615 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
617 struct type
*return_type
;
620 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
621 return value_zero (return_type
, VALUE_LVAL (arg1
));
623 return call_function_by_hand (argvec
[0], NULL
, nargs
, argvec
+ 1);
625 throw_error (NOT_FOUND_ERROR
,
626 _("member function %s not found"), tstr
);
628 return 0; /* For lint -- never reached */
632 /* Concatenate two values with the following conditions:
634 (1) Both values must be either bitstring values or character string
635 values and the resulting value consists of the concatenation of
636 ARG1 followed by ARG2.
640 One value must be an integer value and the other value must be
641 either a bitstring value or character string value, which is
642 to be repeated by the number of times specified by the integer
646 (2) Boolean values are also allowed and are treated as bit string
649 (3) Character values are also allowed and are treated as character
650 string values of length 1. */
653 value_concat (struct value
*arg1
, struct value
*arg2
)
655 struct value
*inval1
;
656 struct value
*inval2
;
657 struct value
*outval
= NULL
;
658 int inval1len
, inval2len
;
661 struct type
*type1
= check_typedef (value_type (arg1
));
662 struct type
*type2
= check_typedef (value_type (arg2
));
663 struct type
*char_type
;
665 /* First figure out if we are dealing with two values to be concatenated
666 or a repeat count and a value to be repeated. INVAL1 is set to the
667 first of two concatenated values, or the repeat count. INVAL2 is set
668 to the second of the two concatenated values or the value to be
671 if (TYPE_CODE (type2
) == TYPE_CODE_INT
)
673 struct type
*tmp
= type1
;
686 /* Now process the input values. */
688 if (TYPE_CODE (type1
) == TYPE_CODE_INT
)
690 /* We have a repeat count. Validate the second value and then
691 construct a value repeated that many times. */
692 if (TYPE_CODE (type2
) == TYPE_CODE_STRING
693 || TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
695 count
= longest_to_int (value_as_long (inval1
));
696 inval2len
= TYPE_LENGTH (type2
);
697 std::vector
<char> ptr (count
* inval2len
);
698 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
702 inchar
= (char) unpack_long (type2
,
703 value_contents (inval2
));
704 for (idx
= 0; idx
< count
; idx
++)
711 char_type
= TYPE_TARGET_TYPE (type2
);
713 for (idx
= 0; idx
< count
; idx
++)
715 memcpy (&ptr
[idx
* inval2len
], value_contents (inval2
),
719 outval
= value_string (ptr
.data (), count
* inval2len
, char_type
);
721 else if (TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
723 error (_("unimplemented support for boolean repeats"));
727 error (_("can't repeat values of that type"));
730 else if (TYPE_CODE (type1
) == TYPE_CODE_STRING
731 || TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
733 /* We have two character strings to concatenate. */
734 if (TYPE_CODE (type2
) != TYPE_CODE_STRING
735 && TYPE_CODE (type2
) != TYPE_CODE_CHAR
)
737 error (_("Strings can only be concatenated with other strings."));
739 inval1len
= TYPE_LENGTH (type1
);
740 inval2len
= TYPE_LENGTH (type2
);
741 std::vector
<char> ptr (inval1len
+ inval2len
);
742 if (TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
746 ptr
[0] = (char) unpack_long (type1
, value_contents (inval1
));
750 char_type
= TYPE_TARGET_TYPE (type1
);
752 memcpy (ptr
.data (), value_contents (inval1
), inval1len
);
754 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
757 (char) unpack_long (type2
, value_contents (inval2
));
761 memcpy (&ptr
[inval1len
], value_contents (inval2
), inval2len
);
763 outval
= value_string (ptr
.data (), inval1len
+ inval2len
, char_type
);
765 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
)
767 /* We have two bitstrings to concatenate. */
768 if (TYPE_CODE (type2
) != TYPE_CODE_BOOL
)
770 error (_("Booleans can only be concatenated "
771 "with other bitstrings or booleans."));
773 error (_("unimplemented support for boolean concatenation."));
777 /* We don't know how to concatenate these operands. */
778 error (_("illegal operands for concatenation."));
783 /* Integer exponentiation: V1**V2, where both arguments are
784 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
787 integer_pow (LONGEST v1
, LONGEST v2
)
792 error (_("Attempt to raise 0 to negative power."));
798 /* The Russian Peasant's Algorithm. */
814 /* Integer exponentiation: V1**V2, where both arguments are
815 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
818 uinteger_pow (ULONGEST v1
, LONGEST v2
)
823 error (_("Attempt to raise 0 to negative power."));
829 /* The Russian Peasant's Algorithm. */
845 /* Obtain argument values for binary operation, converting from
846 other types if one of them is not floating point. */
848 value_args_as_target_float (struct value
*arg1
, struct value
*arg2
,
849 gdb_byte
*x
, struct type
**eff_type_x
,
850 gdb_byte
*y
, struct type
**eff_type_y
)
852 struct type
*type1
, *type2
;
854 type1
= check_typedef (value_type (arg1
));
855 type2
= check_typedef (value_type (arg2
));
857 /* At least one of the arguments must be of floating-point type. */
858 gdb_assert (is_floating_type (type1
) || is_floating_type (type2
));
860 if (is_floating_type (type1
) && is_floating_type (type2
)
861 && TYPE_CODE (type1
) != TYPE_CODE (type2
))
862 /* The DFP extension to the C language does not allow mixing of
863 * decimal float types with other float types in expressions
864 * (see WDTR 24732, page 12). */
865 error (_("Mixing decimal floating types with "
866 "other floating types is not allowed."));
868 /* Obtain value of arg1, converting from other types if necessary. */
870 if (is_floating_type (type1
))
873 memcpy (x
, value_contents (arg1
), TYPE_LENGTH (type1
));
875 else if (is_integral_type (type1
))
878 if (TYPE_UNSIGNED (type1
))
879 target_float_from_ulongest (x
, *eff_type_x
, value_as_long (arg1
));
881 target_float_from_longest (x
, *eff_type_x
, value_as_long (arg1
));
884 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
887 /* Obtain value of arg2, converting from other types if necessary. */
889 if (is_floating_type (type2
))
892 memcpy (y
, value_contents (arg2
), TYPE_LENGTH (type2
));
894 else if (is_integral_type (type2
))
897 if (TYPE_UNSIGNED (type2
))
898 target_float_from_ulongest (y
, *eff_type_y
, value_as_long (arg2
));
900 target_float_from_longest (y
, *eff_type_y
, value_as_long (arg2
));
903 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
907 /* Perform a binary operation on two operands which have reasonable
908 representations as integers or floats. This includes booleans,
909 characters, integers, or floats.
910 Does not support addition and subtraction on pointers;
911 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
913 static struct value
*
914 scalar_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
917 struct type
*type1
, *type2
, *result_type
;
919 arg1
= coerce_ref (arg1
);
920 arg2
= coerce_ref (arg2
);
922 type1
= check_typedef (value_type (arg1
));
923 type2
= check_typedef (value_type (arg2
));
925 if ((!is_floating_value (arg1
) && !is_integral_type (type1
))
926 || (!is_floating_value (arg2
) && !is_integral_type (type2
)))
927 error (_("Argument to arithmetic operation not a number or boolean."));
929 if (is_floating_type (type1
) || is_floating_type (type2
))
931 /* If only one type is floating-point, use its type.
932 Otherwise use the bigger type. */
933 if (!is_floating_type (type1
))
935 else if (!is_floating_type (type2
))
937 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
942 val
= allocate_value (result_type
);
944 struct type
*eff_type_v1
, *eff_type_v2
;
945 gdb::byte_vector v1
, v2
;
946 v1
.resize (TYPE_LENGTH (result_type
));
947 v2
.resize (TYPE_LENGTH (result_type
));
949 value_args_as_target_float (arg1
, arg2
,
950 v1
.data (), &eff_type_v1
,
951 v2
.data (), &eff_type_v2
);
952 target_float_binop (op
, v1
.data (), eff_type_v1
,
953 v2
.data (), eff_type_v2
,
954 value_contents_raw (val
), result_type
);
956 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
957 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
959 LONGEST v1
, v2
, v
= 0;
961 v1
= value_as_long (arg1
);
962 v2
= value_as_long (arg2
);
966 case BINOP_BITWISE_AND
:
970 case BINOP_BITWISE_IOR
:
974 case BINOP_BITWISE_XOR
:
987 error (_("Invalid operation on booleans."));
992 val
= allocate_value (result_type
);
993 store_signed_integer (value_contents_raw (val
),
994 TYPE_LENGTH (result_type
),
995 gdbarch_byte_order (get_type_arch (result_type
)),
999 /* Integral operations here. */
1001 /* Determine type length of the result, and if the operation should
1002 be done unsigned. For exponentiation and shift operators,
1003 use the length and type of the left operand. Otherwise,
1004 use the signedness of the operand with the greater length.
1005 If both operands are of equal length, use unsigned operation
1006 if one of the operands is unsigned. */
1007 if (op
== BINOP_RSH
|| op
== BINOP_LSH
|| op
== BINOP_EXP
)
1008 result_type
= type1
;
1009 else if (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
))
1010 result_type
= type1
;
1011 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1012 result_type
= type2
;
1013 else if (TYPE_UNSIGNED (type1
))
1014 result_type
= type1
;
1015 else if (TYPE_UNSIGNED (type2
))
1016 result_type
= type2
;
1018 result_type
= type1
;
1020 if (TYPE_UNSIGNED (result_type
))
1022 LONGEST v2_signed
= value_as_long (arg2
);
1023 ULONGEST v1
, v2
, v
= 0;
1025 v1
= (ULONGEST
) value_as_long (arg1
);
1026 v2
= (ULONGEST
) v2_signed
;
1047 error (_("Division by zero"));
1051 v
= uinteger_pow (v1
, v2_signed
);
1058 error (_("Division by zero"));
1062 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1063 v1 mod 0 has a defined value, v1. */
1071 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1084 case BINOP_BITWISE_AND
:
1088 case BINOP_BITWISE_IOR
:
1092 case BINOP_BITWISE_XOR
:
1096 case BINOP_LOGICAL_AND
:
1100 case BINOP_LOGICAL_OR
:
1105 v
= v1
< v2
? v1
: v2
;
1109 v
= v1
> v2
? v1
: v2
;
1116 case BINOP_NOTEQUAL
:
1137 error (_("Invalid binary operation on numbers."));
1140 val
= allocate_value (result_type
);
1141 store_unsigned_integer (value_contents_raw (val
),
1142 TYPE_LENGTH (value_type (val
)),
1144 (get_type_arch (result_type
)),
1149 LONGEST v1
, v2
, v
= 0;
1151 v1
= value_as_long (arg1
);
1152 v2
= value_as_long (arg2
);
1173 error (_("Division by zero"));
1177 v
= integer_pow (v1
, v2
);
1184 error (_("Division by zero"));
1188 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1189 X mod 0 has a defined value, X. */
1197 /* Compute floor. */
1198 if (TRUNCATION_TOWARDS_ZERO
&& (v
< 0) && ((v1
% v2
) != 0))
1214 case BINOP_BITWISE_AND
:
1218 case BINOP_BITWISE_IOR
:
1222 case BINOP_BITWISE_XOR
:
1226 case BINOP_LOGICAL_AND
:
1230 case BINOP_LOGICAL_OR
:
1235 v
= v1
< v2
? v1
: v2
;
1239 v
= v1
> v2
? v1
: v2
;
1246 case BINOP_NOTEQUAL
:
1267 error (_("Invalid binary operation on numbers."));
1270 val
= allocate_value (result_type
);
1271 store_signed_integer (value_contents_raw (val
),
1272 TYPE_LENGTH (value_type (val
)),
1274 (get_type_arch (result_type
)),
1282 /* Widen a scalar value SCALAR_VALUE to vector type VECTOR_TYPE by
1283 replicating SCALAR_VALUE for each element of the vector. Only scalar
1284 types that can be cast to the type of one element of the vector are
1285 acceptable. The newly created vector value is returned upon success,
1286 otherwise an error is thrown. */
1289 value_vector_widen (struct value
*scalar_value
, struct type
*vector_type
)
1291 /* Widen the scalar to a vector. */
1292 struct type
*eltype
, *scalar_type
;
1293 struct value
*val
, *elval
;
1294 LONGEST low_bound
, high_bound
;
1297 vector_type
= check_typedef (vector_type
);
1299 gdb_assert (TYPE_CODE (vector_type
) == TYPE_CODE_ARRAY
1300 && TYPE_VECTOR (vector_type
));
1302 if (!get_array_bounds (vector_type
, &low_bound
, &high_bound
))
1303 error (_("Could not determine the vector bounds"));
1305 eltype
= check_typedef (TYPE_TARGET_TYPE (vector_type
));
1306 elval
= value_cast (eltype
, scalar_value
);
1308 scalar_type
= check_typedef (value_type (scalar_value
));
1310 /* If we reduced the length of the scalar then check we didn't loose any
1312 if (TYPE_LENGTH (eltype
) < TYPE_LENGTH (scalar_type
)
1313 && !value_equal (elval
, scalar_value
))
1314 error (_("conversion of scalar to vector involves truncation"));
1316 val
= allocate_value (vector_type
);
1317 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1318 /* Duplicate the contents of elval into the destination vector. */
1319 memcpy (value_contents_writeable (val
) + (i
* TYPE_LENGTH (eltype
)),
1320 value_contents_all (elval
), TYPE_LENGTH (eltype
));
1325 /* Performs a binary operation on two vector operands by calling scalar_binop
1326 for each pair of vector components. */
1328 static struct value
*
1329 vector_binop (struct value
*val1
, struct value
*val2
, enum exp_opcode op
)
1331 struct value
*val
, *tmp
, *mark
;
1332 struct type
*type1
, *type2
, *eltype1
, *eltype2
;
1333 int t1_is_vec
, t2_is_vec
, elsize
, i
;
1334 LONGEST low_bound1
, high_bound1
, low_bound2
, high_bound2
;
1336 type1
= check_typedef (value_type (val1
));
1337 type2
= check_typedef (value_type (val2
));
1339 t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
1340 && TYPE_VECTOR (type1
)) ? 1 : 0;
1341 t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
1342 && TYPE_VECTOR (type2
)) ? 1 : 0;
1344 if (!t1_is_vec
|| !t2_is_vec
)
1345 error (_("Vector operations are only supported among vectors"));
1347 if (!get_array_bounds (type1
, &low_bound1
, &high_bound1
)
1348 || !get_array_bounds (type2
, &low_bound2
, &high_bound2
))
1349 error (_("Could not determine the vector bounds"));
1351 eltype1
= check_typedef (TYPE_TARGET_TYPE (type1
));
1352 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
));
1353 elsize
= TYPE_LENGTH (eltype1
);
1355 if (TYPE_CODE (eltype1
) != TYPE_CODE (eltype2
)
1356 || elsize
!= TYPE_LENGTH (eltype2
)
1357 || TYPE_UNSIGNED (eltype1
) != TYPE_UNSIGNED (eltype2
)
1358 || low_bound1
!= low_bound2
|| high_bound1
!= high_bound2
)
1359 error (_("Cannot perform operation on vectors with different types"));
1361 val
= allocate_value (type1
);
1362 mark
= value_mark ();
1363 for (i
= 0; i
< high_bound1
- low_bound1
+ 1; i
++)
1365 tmp
= value_binop (value_subscript (val1
, i
),
1366 value_subscript (val2
, i
), op
);
1367 memcpy (value_contents_writeable (val
) + i
* elsize
,
1368 value_contents_all (tmp
),
1371 value_free_to_mark (mark
);
1376 /* Perform a binary operation on two operands. */
1379 value_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
1382 struct type
*type1
= check_typedef (value_type (arg1
));
1383 struct type
*type2
= check_typedef (value_type (arg2
));
1384 int t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
1385 && TYPE_VECTOR (type1
));
1386 int t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
1387 && TYPE_VECTOR (type2
));
1389 if (!t1_is_vec
&& !t2_is_vec
)
1390 val
= scalar_binop (arg1
, arg2
, op
);
1391 else if (t1_is_vec
&& t2_is_vec
)
1392 val
= vector_binop (arg1
, arg2
, op
);
1395 /* Widen the scalar operand to a vector. */
1396 struct value
**v
= t1_is_vec
? &arg2
: &arg1
;
1397 struct type
*t
= t1_is_vec
? type2
: type1
;
1399 if (TYPE_CODE (t
) != TYPE_CODE_FLT
1400 && TYPE_CODE (t
) != TYPE_CODE_DECFLOAT
1401 && !is_integral_type (t
))
1402 error (_("Argument to operation not a number or boolean."));
1404 /* Replicate the scalar value to make a vector value. */
1405 *v
= value_vector_widen (*v
, t1_is_vec
? type1
: type2
);
1407 val
= vector_binop (arg1
, arg2
, op
);
1413 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1416 value_logical_not (struct value
*arg1
)
1422 arg1
= coerce_array (arg1
);
1423 type1
= check_typedef (value_type (arg1
));
1425 if (is_floating_value (arg1
))
1426 return target_float_is_zero (value_contents (arg1
), type1
);
1428 len
= TYPE_LENGTH (type1
);
1429 p
= value_contents (arg1
);
1440 /* Perform a comparison on two string values (whose content are not
1441 necessarily null terminated) based on their length. */
1444 value_strcmp (struct value
*arg1
, struct value
*arg2
)
1446 int len1
= TYPE_LENGTH (value_type (arg1
));
1447 int len2
= TYPE_LENGTH (value_type (arg2
));
1448 const gdb_byte
*s1
= value_contents (arg1
);
1449 const gdb_byte
*s2
= value_contents (arg2
);
1450 int i
, len
= len1
< len2
? len1
: len2
;
1452 for (i
= 0; i
< len
; i
++)
1456 else if (s1
[i
] > s2
[i
])
1464 else if (len1
> len2
)
1470 /* Simulate the C operator == by returning a 1
1471 iff ARG1 and ARG2 have equal contents. */
1474 value_equal (struct value
*arg1
, struct value
*arg2
)
1479 struct type
*type1
, *type2
;
1480 enum type_code code1
;
1481 enum type_code code2
;
1482 int is_int1
, is_int2
;
1484 arg1
= coerce_array (arg1
);
1485 arg2
= coerce_array (arg2
);
1487 type1
= check_typedef (value_type (arg1
));
1488 type2
= check_typedef (value_type (arg2
));
1489 code1
= TYPE_CODE (type1
);
1490 code2
= TYPE_CODE (type2
);
1491 is_int1
= is_integral_type (type1
);
1492 is_int2
= is_integral_type (type2
);
1494 if (is_int1
&& is_int2
)
1495 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1497 else if ((is_floating_value (arg1
) || is_int1
)
1498 && (is_floating_value (arg2
) || is_int2
))
1500 struct type
*eff_type_v1
, *eff_type_v2
;
1501 gdb::byte_vector v1
, v2
;
1502 v1
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1503 v2
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1505 value_args_as_target_float (arg1
, arg2
,
1506 v1
.data (), &eff_type_v1
,
1507 v2
.data (), &eff_type_v2
);
1509 return target_float_compare (v1
.data (), eff_type_v1
,
1510 v2
.data (), eff_type_v2
) == 0;
1513 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1515 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1516 return value_as_address (arg1
) == (CORE_ADDR
) value_as_long (arg2
);
1517 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1518 return (CORE_ADDR
) value_as_long (arg1
) == value_as_address (arg2
);
1520 else if (code1
== code2
1521 && ((len
= (int) TYPE_LENGTH (type1
))
1522 == (int) TYPE_LENGTH (type2
)))
1524 p1
= value_contents (arg1
);
1525 p2
= value_contents (arg2
);
1533 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1535 return value_strcmp (arg1
, arg2
) == 0;
1539 error (_("Invalid type combination in equality test."));
1540 return 0; /* For lint -- never reached. */
1544 /* Compare values based on their raw contents. Useful for arrays since
1545 value_equal coerces them to pointers, thus comparing just the address
1546 of the array instead of its contents. */
1549 value_equal_contents (struct value
*arg1
, struct value
*arg2
)
1551 struct type
*type1
, *type2
;
1553 type1
= check_typedef (value_type (arg1
));
1554 type2
= check_typedef (value_type (arg2
));
1556 return (TYPE_CODE (type1
) == TYPE_CODE (type2
)
1557 && TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
1558 && memcmp (value_contents (arg1
), value_contents (arg2
),
1559 TYPE_LENGTH (type1
)) == 0);
1562 /* Simulate the C operator < by returning 1
1563 iff ARG1's contents are less than ARG2's. */
1566 value_less (struct value
*arg1
, struct value
*arg2
)
1568 enum type_code code1
;
1569 enum type_code code2
;
1570 struct type
*type1
, *type2
;
1571 int is_int1
, is_int2
;
1573 arg1
= coerce_array (arg1
);
1574 arg2
= coerce_array (arg2
);
1576 type1
= check_typedef (value_type (arg1
));
1577 type2
= check_typedef (value_type (arg2
));
1578 code1
= TYPE_CODE (type1
);
1579 code2
= TYPE_CODE (type2
);
1580 is_int1
= is_integral_type (type1
);
1581 is_int2
= is_integral_type (type2
);
1583 if (is_int1
&& is_int2
)
1584 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1586 else if ((is_floating_value (arg1
) || is_int1
)
1587 && (is_floating_value (arg2
) || is_int2
))
1589 struct type
*eff_type_v1
, *eff_type_v2
;
1590 gdb::byte_vector v1
, v2
;
1591 v1
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1592 v2
.resize (std::max (TYPE_LENGTH (type1
), TYPE_LENGTH (type2
)));
1594 value_args_as_target_float (arg1
, arg2
,
1595 v1
.data (), &eff_type_v1
,
1596 v2
.data (), &eff_type_v2
);
1598 return target_float_compare (v1
.data (), eff_type_v1
,
1599 v2
.data (), eff_type_v2
) == -1;
1601 else if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
1602 return value_as_address (arg1
) < value_as_address (arg2
);
1604 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1606 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1607 return value_as_address (arg1
) < (CORE_ADDR
) value_as_long (arg2
);
1608 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1609 return (CORE_ADDR
) value_as_long (arg1
) < value_as_address (arg2
);
1610 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1611 return value_strcmp (arg1
, arg2
) < 0;
1614 error (_("Invalid type combination in ordering comparison."));
1619 /* The unary operators +, - and ~. They free the argument ARG1. */
1622 value_pos (struct value
*arg1
)
1626 arg1
= coerce_ref (arg1
);
1627 type
= check_typedef (value_type (arg1
));
1629 if (is_integral_type (type
) || is_floating_value (arg1
)
1630 || (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
)))
1631 return value_from_contents (type
, value_contents (arg1
));
1634 error (_("Argument to positive operation not a number."));
1635 return 0; /* For lint -- never reached. */
1640 value_neg (struct value
*arg1
)
1644 arg1
= coerce_ref (arg1
);
1645 type
= check_typedef (value_type (arg1
));
1647 if (is_integral_type (type
) || is_floating_type (type
))
1648 return value_binop (value_from_longest (type
, 0), arg1
, BINOP_SUB
);
1649 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1651 struct value
*tmp
, *val
= allocate_value (type
);
1652 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1654 LONGEST low_bound
, high_bound
;
1656 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1657 error (_("Could not determine the vector bounds"));
1659 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1661 tmp
= value_neg (value_subscript (arg1
, i
));
1662 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
1663 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
1669 error (_("Argument to negate operation not a number."));
1670 return 0; /* For lint -- never reached. */
1675 value_complement (struct value
*arg1
)
1680 arg1
= coerce_ref (arg1
);
1681 type
= check_typedef (value_type (arg1
));
1683 if (is_integral_type (type
))
1684 val
= value_from_longest (type
, ~value_as_long (arg1
));
1685 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1688 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1690 LONGEST low_bound
, high_bound
;
1692 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1693 error (_("Could not determine the vector bounds"));
1695 val
= allocate_value (type
);
1696 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1698 tmp
= value_complement (value_subscript (arg1
, i
));
1699 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
1700 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
1704 error (_("Argument to complement operation not an integer, boolean."));
1709 /* The INDEX'th bit of SET value whose value_type is TYPE,
1710 and whose value_contents is valaddr.
1711 Return -1 if out of range, -2 other error. */
1714 value_bit_index (struct type
*type
, const gdb_byte
*valaddr
, int index
)
1716 struct gdbarch
*gdbarch
= get_type_arch (type
);
1717 LONGEST low_bound
, high_bound
;
1720 struct type
*range
= TYPE_INDEX_TYPE (type
);
1722 if (get_discrete_bounds (range
, &low_bound
, &high_bound
) < 0)
1724 if (index
< low_bound
|| index
> high_bound
)
1726 rel_index
= index
- low_bound
;
1727 word
= extract_unsigned_integer (valaddr
+ (rel_index
/ TARGET_CHAR_BIT
), 1,
1728 gdbarch_byte_order (gdbarch
));
1729 rel_index
%= TARGET_CHAR_BIT
;
1730 if (gdbarch_bits_big_endian (gdbarch
))
1731 rel_index
= TARGET_CHAR_BIT
- 1 - rel_index
;
1732 return (word
>> rel_index
) & 1;
1736 value_in (struct value
*element
, struct value
*set
)
1739 struct type
*settype
= check_typedef (value_type (set
));
1740 struct type
*eltype
= check_typedef (value_type (element
));
1742 if (TYPE_CODE (eltype
) == TYPE_CODE_RANGE
)
1743 eltype
= TYPE_TARGET_TYPE (eltype
);
1744 if (TYPE_CODE (settype
) != TYPE_CODE_SET
)
1745 error (_("Second argument of 'IN' has wrong type"));
1746 if (TYPE_CODE (eltype
) != TYPE_CODE_INT
1747 && TYPE_CODE (eltype
) != TYPE_CODE_CHAR
1748 && TYPE_CODE (eltype
) != TYPE_CODE_ENUM
1749 && TYPE_CODE (eltype
) != TYPE_CODE_BOOL
)
1750 error (_("First argument of 'IN' has wrong type"));
1751 member
= value_bit_index (settype
, value_contents (set
),
1752 value_as_long (element
));
1754 error (_("First argument of 'IN' not in range"));
1759 _initialize_valarith (void)
This page took 0.088096 seconds and 4 git commands to generate.