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
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);
560 case UNOP_POSTDECREMENT:
562 argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
566 case UNOP_LOGICAL_NOT:
569 case UNOP_COMPLEMENT:
585 error (_("Invalid unary operation specified."));
588 argvec[0] = value_user_defined_op (&arg1, argvec.slice (1, nargs), tstr,
589 &static_memfuncp, noside);
595 argvec[1] = argvec[0];
596 argvec = argvec.slice (1);
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], 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], 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,
622 argvec.slice (1, nargs));
624 throw_error (NOT_FOUND_ERROR,
625 _("member function %s not found"), tstr);
629 /* Concatenate two values with the following conditions:
631 (1) Both values must be either bitstring values or character string
632 values and the resulting value consists of the concatenation of
633 ARG1 followed by ARG2.
637 One value must be an integer value and the other value must be
638 either a bitstring value or character string value, which is
639 to be repeated by the number of times specified by the integer
643 (2) Boolean values are also allowed and are treated as bit string
646 (3) Character values are also allowed and are treated as character
647 string values of length 1. */
650 value_concat (struct value *arg1, struct value *arg2)
652 struct value *inval1;
653 struct value *inval2;
654 struct value *outval = NULL;
655 int inval1len, inval2len;
658 struct type *type1 = check_typedef (value_type (arg1));
659 struct type *type2 = check_typedef (value_type (arg2));
660 struct type *char_type;
662 /* First figure out if we are dealing with two values to be concatenated
663 or a repeat count and a value to be repeated. INVAL1 is set to the
664 first of two concatenated values, or the repeat count. INVAL2 is set
665 to the second of the two concatenated values or the value to be
668 if (TYPE_CODE (type2) == TYPE_CODE_INT)
670 struct type *tmp = type1;
683 /* Now process the input values. */
685 if (TYPE_CODE (type1) == TYPE_CODE_INT)
687 /* We have a repeat count. Validate the second value and then
688 construct a value repeated that many times. */
689 if (TYPE_CODE (type2) == TYPE_CODE_STRING
690 || TYPE_CODE (type2) == TYPE_CODE_CHAR)
692 count = longest_to_int (value_as_long (inval1));
693 inval2len = TYPE_LENGTH (type2);
694 std::vector<char> ptr (count * inval2len);
695 if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
699 inchar = (char) unpack_long (type2,
700 value_contents (inval2));
701 for (idx = 0; idx < count; idx++)
708 char_type = TYPE_TARGET_TYPE (type2);
710 for (idx = 0; idx < count; idx++)
712 memcpy (&ptr[idx * inval2len], value_contents (inval2),
716 outval = value_string (ptr.data (), count * inval2len, char_type);
718 else if (TYPE_CODE (type2) == TYPE_CODE_BOOL)
720 error (_("unimplemented support for boolean repeats"));
724 error (_("can't repeat values of that type"));
727 else if (TYPE_CODE (type1) == TYPE_CODE_STRING
728 || TYPE_CODE (type1) == TYPE_CODE_CHAR)
730 /* We have two character strings to concatenate. */
731 if (TYPE_CODE (type2) != TYPE_CODE_STRING
732 && TYPE_CODE (type2) != TYPE_CODE_CHAR)
734 error (_("Strings can only be concatenated with other strings."));
736 inval1len = TYPE_LENGTH (type1);
737 inval2len = TYPE_LENGTH (type2);
738 std::vector<char> ptr (inval1len + inval2len);
739 if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
743 ptr[0] = (char) unpack_long (type1, value_contents (inval1));
747 char_type = TYPE_TARGET_TYPE (type1);
749 memcpy (ptr.data (), value_contents (inval1), inval1len);
751 if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
754 (char) unpack_long (type2, value_contents (inval2));
758 memcpy (&ptr[inval1len], value_contents (inval2), inval2len);
760 outval = value_string (ptr.data (), inval1len + inval2len, char_type);
762 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL)
764 /* We have two bitstrings to concatenate. */
765 if (TYPE_CODE (type2) != TYPE_CODE_BOOL)
767 error (_("Booleans can only be concatenated "
768 "with other bitstrings or booleans."));
770 error (_("unimplemented support for boolean concatenation."));
774 /* We don't know how to concatenate these operands. */
775 error (_("illegal operands for concatenation."));
780 /* Integer exponentiation: V1**V2, where both arguments are
781 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
784 integer_pow (LONGEST v1, LONGEST v2)
789 error (_("Attempt to raise 0 to negative power."));
795 /* The Russian Peasant's Algorithm. */
811 /* Integer exponentiation: V1**V2, where both arguments are
812 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
815 uinteger_pow (ULONGEST v1, LONGEST v2)
820 error (_("Attempt to raise 0 to negative power."));
826 /* The Russian Peasant's Algorithm. */
842 /* Obtain argument values for binary operation, converting from
843 other types if one of them is not floating point. */
845 value_args_as_target_float (struct value *arg1, struct value *arg2,
846 gdb_byte *x, struct type **eff_type_x,
847 gdb_byte *y, struct type **eff_type_y)
849 struct type *type1, *type2;
851 type1 = check_typedef (value_type (arg1));
852 type2 = check_typedef (value_type (arg2));
854 /* At least one of the arguments must be of floating-point type. */
855 gdb_assert (is_floating_type (type1) || is_floating_type (type2));
857 if (is_floating_type (type1) && is_floating_type (type2)
858 && TYPE_CODE (type1) != TYPE_CODE (type2))
859 /* The DFP extension to the C language does not allow mixing of
860 * decimal float types with other float types in expressions
861 * (see WDTR 24732, page 12). */
862 error (_("Mixing decimal floating types with "
863 "other floating types is not allowed."));
865 /* Obtain value of arg1, converting from other types if necessary. */
867 if (is_floating_type (type1))
870 memcpy (x, value_contents (arg1), TYPE_LENGTH (type1));
872 else if (is_integral_type (type1))
875 if (TYPE_UNSIGNED (type1))
876 target_float_from_ulongest (x, *eff_type_x, value_as_long (arg1));
878 target_float_from_longest (x, *eff_type_x, value_as_long (arg1));
881 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1),
884 /* Obtain value of arg2, converting from other types if necessary. */
886 if (is_floating_type (type2))
889 memcpy (y, value_contents (arg2), TYPE_LENGTH (type2));
891 else if (is_integral_type (type2))
894 if (TYPE_UNSIGNED (type2))
895 target_float_from_ulongest (y, *eff_type_y, value_as_long (arg2));
897 target_float_from_longest (y, *eff_type_y, value_as_long (arg2));
900 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1),
904 /* Perform a binary operation on two operands which have reasonable
905 representations as integers or floats. This includes booleans,
906 characters, integers, or floats.
907 Does not support addition and subtraction on pointers;
908 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
910 static struct value *
911 scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
914 struct type *type1, *type2, *result_type;
916 arg1 = coerce_ref (arg1);
917 arg2 = coerce_ref (arg2);
919 type1 = check_typedef (value_type (arg1));
920 type2 = check_typedef (value_type (arg2));
922 if ((!is_floating_value (arg1) && !is_integral_type (type1))
923 || (!is_floating_value (arg2) && !is_integral_type (type2)))
924 error (_("Argument to arithmetic operation not a number or boolean."));
926 if (is_floating_type (type1) || is_floating_type (type2))
928 /* If only one type is floating-point, use its type.
929 Otherwise use the bigger type. */
930 if (!is_floating_type (type1))
932 else if (!is_floating_type (type2))
934 else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
939 val = allocate_value (result_type);
941 struct type *eff_type_v1, *eff_type_v2;
942 gdb::byte_vector v1, v2;
943 v1.resize (TYPE_LENGTH (result_type));
944 v2.resize (TYPE_LENGTH (result_type));
946 value_args_as_target_float (arg1, arg2,
947 v1.data (), &eff_type_v1,
948 v2.data (), &eff_type_v2);
949 target_float_binop (op, v1.data (), eff_type_v1,
950 v2.data (), eff_type_v2,
951 value_contents_raw (val), result_type);
953 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
954 || TYPE_CODE (type2) == TYPE_CODE_BOOL)
956 LONGEST v1, v2, v = 0;
958 v1 = value_as_long (arg1);
959 v2 = value_as_long (arg2);
963 case BINOP_BITWISE_AND:
967 case BINOP_BITWISE_IOR:
971 case BINOP_BITWISE_XOR:
984 error (_("Invalid operation on booleans."));
989 val = allocate_value (result_type);
990 store_signed_integer (value_contents_raw (val),
991 TYPE_LENGTH (result_type),
992 gdbarch_byte_order (get_type_arch (result_type)),
996 /* Integral operations here. */
998 /* Determine type length of the result, and if the operation should
999 be done unsigned. For exponentiation and shift operators,
1000 use the length and type of the left operand. Otherwise,
1001 use the signedness of the operand with the greater length.
1002 If both operands are of equal length, use unsigned operation
1003 if one of the operands is unsigned. */
1004 if (op == BINOP_RSH || op == BINOP_LSH || op == BINOP_EXP)
1005 result_type = type1;
1006 else if (TYPE_LENGTH (type1) > TYPE_LENGTH (type2))
1007 result_type = type1;
1008 else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
1009 result_type = type2;
1010 else if (TYPE_UNSIGNED (type1))
1011 result_type = type1;
1012 else if (TYPE_UNSIGNED (type2))
1013 result_type = type2;
1015 result_type = type1;
1017 if (TYPE_UNSIGNED (result_type))
1019 LONGEST v2_signed = value_as_long (arg2);
1020 ULONGEST v1, v2, v = 0;
1022 v1 = (ULONGEST) value_as_long (arg1);
1023 v2 = (ULONGEST) v2_signed;
1044 error (_("Division by zero"));
1048 v = uinteger_pow (v1, v2_signed);
1055 error (_("Division by zero"));
1059 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1060 v1 mod 0 has a defined value, v1. */
1068 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1081 case BINOP_BITWISE_AND:
1085 case BINOP_BITWISE_IOR:
1089 case BINOP_BITWISE_XOR:
1093 case BINOP_LOGICAL_AND:
1097 case BINOP_LOGICAL_OR:
1102 v = v1 < v2 ? v1 : v2;
1106 v = v1 > v2 ? v1 : v2;
1113 case BINOP_NOTEQUAL:
1134 error (_("Invalid binary operation on numbers."));
1137 val = allocate_value (result_type);
1138 store_unsigned_integer (value_contents_raw (val),
1139 TYPE_LENGTH (value_type (val)),
1141 (get_type_arch (result_type)),
1146 LONGEST v1, v2, v = 0;
1148 v1 = value_as_long (arg1);
1149 v2 = value_as_long (arg2);
1170 error (_("Division by zero"));
1174 v = integer_pow (v1, v2);
1181 error (_("Division by zero"));
1185 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1186 X mod 0 has a defined value, X. */
1194 /* Compute floor. */
1195 if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0))
1211 case BINOP_BITWISE_AND:
1215 case BINOP_BITWISE_IOR:
1219 case BINOP_BITWISE_XOR:
1223 case BINOP_LOGICAL_AND:
1227 case BINOP_LOGICAL_OR:
1232 v = v1 < v2 ? v1 : v2;
1236 v = v1 > v2 ? v1 : v2;
1243 case BINOP_NOTEQUAL:
1264 error (_("Invalid binary operation on numbers."));
1267 val = allocate_value (result_type);
1268 store_signed_integer (value_contents_raw (val),
1269 TYPE_LENGTH (value_type (val)),
1271 (get_type_arch (result_type)),
1279 /* Widen a scalar value SCALAR_VALUE to vector type VECTOR_TYPE by
1280 replicating SCALAR_VALUE for each element of the vector. Only scalar
1281 types that can be cast to the type of one element of the vector are
1282 acceptable. The newly created vector value is returned upon success,
1283 otherwise an error is thrown. */
1286 value_vector_widen (struct value *scalar_value, struct type *vector_type)
1288 /* Widen the scalar to a vector. */
1289 struct type *eltype, *scalar_type;
1290 struct value *val, *elval;
1291 LONGEST low_bound, high_bound;
1294 vector_type = check_typedef (vector_type);
1296 gdb_assert (TYPE_CODE (vector_type) == TYPE_CODE_ARRAY
1297 && TYPE_VECTOR (vector_type));
1299 if (!get_array_bounds (vector_type, &low_bound, &high_bound))
1300 error (_("Could not determine the vector bounds"));
1302 eltype = check_typedef (TYPE_TARGET_TYPE (vector_type));
1303 elval = value_cast (eltype, scalar_value);
1305 scalar_type = check_typedef (value_type (scalar_value));
1307 /* If we reduced the length of the scalar then check we didn't loose any
1309 if (TYPE_LENGTH (eltype) < TYPE_LENGTH (scalar_type)
1310 && !value_equal (elval, scalar_value))
1311 error (_("conversion of scalar to vector involves truncation"));
1313 val = allocate_value (vector_type);
1314 for (i = 0; i < high_bound - low_bound + 1; i++)
1315 /* Duplicate the contents of elval into the destination vector. */
1316 memcpy (value_contents_writeable (val) + (i * TYPE_LENGTH (eltype)),
1317 value_contents_all (elval), TYPE_LENGTH (eltype));
1322 /* Performs a binary operation on two vector operands by calling scalar_binop
1323 for each pair of vector components. */
1325 static struct value *
1326 vector_binop (struct value *val1, struct value *val2, enum exp_opcode op)
1328 struct value *val, *tmp, *mark;
1329 struct type *type1, *type2, *eltype1, *eltype2;
1330 int t1_is_vec, t2_is_vec, elsize, i;
1331 LONGEST low_bound1, high_bound1, low_bound2, high_bound2;
1333 type1 = check_typedef (value_type (val1));
1334 type2 = check_typedef (value_type (val2));
1336 t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
1337 && TYPE_VECTOR (type1)) ? 1 : 0;
1338 t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
1339 && TYPE_VECTOR (type2)) ? 1 : 0;
1341 if (!t1_is_vec || !t2_is_vec)
1342 error (_("Vector operations are only supported among vectors"));
1344 if (!get_array_bounds (type1, &low_bound1, &high_bound1)
1345 || !get_array_bounds (type2, &low_bound2, &high_bound2))
1346 error (_("Could not determine the vector bounds"));
1348 eltype1 = check_typedef (TYPE_TARGET_TYPE (type1));
1349 eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
1350 elsize = TYPE_LENGTH (eltype1);
1352 if (TYPE_CODE (eltype1) != TYPE_CODE (eltype2)
1353 || elsize != TYPE_LENGTH (eltype2)
1354 || TYPE_UNSIGNED (eltype1) != TYPE_UNSIGNED (eltype2)
1355 || low_bound1 != low_bound2 || high_bound1 != high_bound2)
1356 error (_("Cannot perform operation on vectors with different types"));
1358 val = allocate_value (type1);
1359 mark = value_mark ();
1360 for (i = 0; i < high_bound1 - low_bound1 + 1; i++)
1362 tmp = value_binop (value_subscript (val1, i),
1363 value_subscript (val2, i), op);
1364 memcpy (value_contents_writeable (val) + i * elsize,
1365 value_contents_all (tmp),
1368 value_free_to_mark (mark);
1373 /* Perform a binary operation on two operands. */
1376 value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
1379 struct type *type1 = check_typedef (value_type (arg1));
1380 struct type *type2 = check_typedef (value_type (arg2));
1381 int t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
1382 && TYPE_VECTOR (type1));
1383 int t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
1384 && TYPE_VECTOR (type2));
1386 if (!t1_is_vec && !t2_is_vec)
1387 val = scalar_binop (arg1, arg2, op);
1388 else if (t1_is_vec && t2_is_vec)
1389 val = vector_binop (arg1, arg2, op);
1392 /* Widen the scalar operand to a vector. */
1393 struct value **v = t1_is_vec ? &arg2 : &arg1;
1394 struct type *t = t1_is_vec ? type2 : type1;
1396 if (TYPE_CODE (t) != TYPE_CODE_FLT
1397 && TYPE_CODE (t) != TYPE_CODE_DECFLOAT
1398 && !is_integral_type (t))
1399 error (_("Argument to operation not a number or boolean."));
1401 /* Replicate the scalar value to make a vector value. */
1402 *v = value_vector_widen (*v, t1_is_vec ? type1 : type2);
1404 val = vector_binop (arg1, arg2, op);
1410 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1413 value_logical_not (struct value *arg1)
1419 arg1 = coerce_array (arg1);
1420 type1 = check_typedef (value_type (arg1));
1422 if (is_floating_value (arg1))
1423 return target_float_is_zero (value_contents (arg1), type1);
1425 len = TYPE_LENGTH (type1);
1426 p = value_contents (arg1);
1437 /* Perform a comparison on two string values (whose content are not
1438 necessarily null terminated) based on their length. */
1441 value_strcmp (struct value *arg1, struct value *arg2)
1443 int len1 = TYPE_LENGTH (value_type (arg1));
1444 int len2 = TYPE_LENGTH (value_type (arg2));
1445 const gdb_byte *s1 = value_contents (arg1);
1446 const gdb_byte *s2 = value_contents (arg2);
1447 int i, len = len1 < len2 ? len1 : len2;
1449 for (i = 0; i < len; i++)
1453 else if (s1[i] > s2[i])
1461 else if (len1 > len2)
1467 /* Simulate the C operator == by returning a 1
1468 iff ARG1 and ARG2 have equal contents. */
1471 value_equal (struct value *arg1, struct value *arg2)
1476 struct type *type1, *type2;
1477 enum type_code code1;
1478 enum type_code code2;
1479 int is_int1, is_int2;
1481 arg1 = coerce_array (arg1);
1482 arg2 = coerce_array (arg2);
1484 type1 = check_typedef (value_type (arg1));
1485 type2 = check_typedef (value_type (arg2));
1486 code1 = TYPE_CODE (type1);
1487 code2 = TYPE_CODE (type2);
1488 is_int1 = is_integral_type (type1);
1489 is_int2 = is_integral_type (type2);
1491 if (is_int1 && is_int2)
1492 return longest_to_int (value_as_long (value_binop (arg1, arg2,
1494 else if ((is_floating_value (arg1) || is_int1)
1495 && (is_floating_value (arg2) || is_int2))
1497 struct type *eff_type_v1, *eff_type_v2;
1498 gdb::byte_vector v1, v2;
1499 v1.resize (std::max (TYPE_LENGTH (type1), TYPE_LENGTH (type2)));
1500 v2.resize (std::max (TYPE_LENGTH (type1), TYPE_LENGTH (type2)));
1502 value_args_as_target_float (arg1, arg2,
1503 v1.data (), &eff_type_v1,
1504 v2.data (), &eff_type_v2);
1506 return target_float_compare (v1.data (), eff_type_v1,
1507 v2.data (), eff_type_v2) == 0;
1510 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1512 else if (code1 == TYPE_CODE_PTR && is_int2)
1513 return value_as_address (arg1) == (CORE_ADDR) value_as_long (arg2);
1514 else if (code2 == TYPE_CODE_PTR && is_int1)
1515 return (CORE_ADDR) value_as_long (arg1) == value_as_address (arg2);
1517 else if (code1 == code2
1518 && ((len = (int) TYPE_LENGTH (type1))
1519 == (int) TYPE_LENGTH (type2)))
1521 p1 = value_contents (arg1);
1522 p2 = value_contents (arg2);
1530 else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1532 return value_strcmp (arg1, arg2) == 0;
1535 error (_("Invalid type combination in equality test."));
1538 /* Compare values based on their raw contents. Useful for arrays since
1539 value_equal coerces them to pointers, thus comparing just the address
1540 of the array instead of its contents. */
1543 value_equal_contents (struct value *arg1, struct value *arg2)
1545 struct type *type1, *type2;
1547 type1 = check_typedef (value_type (arg1));
1548 type2 = check_typedef (value_type (arg2));
1550 return (TYPE_CODE (type1) == TYPE_CODE (type2)
1551 && TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
1552 && memcmp (value_contents (arg1), value_contents (arg2),
1553 TYPE_LENGTH (type1)) == 0);
1556 /* Simulate the C operator < by returning 1
1557 iff ARG1's contents are less than ARG2's. */
1560 value_less (struct value *arg1, struct value *arg2)
1562 enum type_code code1;
1563 enum type_code code2;
1564 struct type *type1, *type2;
1565 int is_int1, is_int2;
1567 arg1 = coerce_array (arg1);
1568 arg2 = coerce_array (arg2);
1570 type1 = check_typedef (value_type (arg1));
1571 type2 = check_typedef (value_type (arg2));
1572 code1 = TYPE_CODE (type1);
1573 code2 = TYPE_CODE (type2);
1574 is_int1 = is_integral_type (type1);
1575 is_int2 = is_integral_type (type2);
1577 if (is_int1 && is_int2)
1578 return longest_to_int (value_as_long (value_binop (arg1, arg2,
1580 else if ((is_floating_value (arg1) || is_int1)
1581 && (is_floating_value (arg2) || is_int2))
1583 struct type *eff_type_v1, *eff_type_v2;
1584 gdb::byte_vector v1, v2;
1585 v1.resize (std::max (TYPE_LENGTH (type1), TYPE_LENGTH (type2)));
1586 v2.resize (std::max (TYPE_LENGTH (type1), TYPE_LENGTH (type2)));
1588 value_args_as_target_float (arg1, arg2,
1589 v1.data (), &eff_type_v1,
1590 v2.data (), &eff_type_v2);
1592 return target_float_compare (v1.data (), eff_type_v1,
1593 v2.data (), eff_type_v2) == -1;
1595 else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
1596 return value_as_address (arg1) < value_as_address (arg2);
1598 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1600 else if (code1 == TYPE_CODE_PTR && is_int2)
1601 return value_as_address (arg1) < (CORE_ADDR) value_as_long (arg2);
1602 else if (code2 == TYPE_CODE_PTR && is_int1)
1603 return (CORE_ADDR) value_as_long (arg1) < value_as_address (arg2);
1604 else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1605 return value_strcmp (arg1, arg2) < 0;
1608 error (_("Invalid type combination in ordering comparison."));
1613 /* The unary operators +, - and ~. They free the argument ARG1. */
1616 value_pos (struct value *arg1)
1620 arg1 = coerce_ref (arg1);
1621 type = check_typedef (value_type (arg1));
1623 if (is_integral_type (type) || is_floating_value (arg1)
1624 || (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type)))
1625 return value_from_contents (type, value_contents (arg1));
1627 error (_("Argument to positive operation not a number."));
1631 value_neg (struct value *arg1)
1635 arg1 = coerce_ref (arg1);
1636 type = check_typedef (value_type (arg1));
1638 if (is_integral_type (type) || is_floating_type (type))
1639 return value_binop (value_from_longest (type, 0), arg1, BINOP_SUB);
1640 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
1642 struct value *tmp, *val = allocate_value (type);
1643 struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
1645 LONGEST low_bound, high_bound;
1647 if (!get_array_bounds (type, &low_bound, &high_bound))
1648 error (_("Could not determine the vector bounds"));
1650 for (i = 0; i < high_bound - low_bound + 1; i++)
1652 tmp = value_neg (value_subscript (arg1, i));
1653 memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
1654 value_contents_all (tmp), TYPE_LENGTH (eltype));
1659 error (_("Argument to negate operation not a number."));
1663 value_complement (struct value *arg1)
1668 arg1 = coerce_ref (arg1);
1669 type = check_typedef (value_type (arg1));
1671 if (is_integral_type (type))
1672 val = value_from_longest (type, ~value_as_long (arg1));
1673 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
1676 struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
1678 LONGEST low_bound, high_bound;
1680 if (!get_array_bounds (type, &low_bound, &high_bound))
1681 error (_("Could not determine the vector bounds"));
1683 val = allocate_value (type);
1684 for (i = 0; i < high_bound - low_bound + 1; i++)
1686 tmp = value_complement (value_subscript (arg1, i));
1687 memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
1688 value_contents_all (tmp), TYPE_LENGTH (eltype));
1692 error (_("Argument to complement operation not an integer, boolean."));
1697 /* The INDEX'th bit of SET value whose value_type is TYPE,
1698 and whose value_contents is valaddr.
1699 Return -1 if out of range, -2 other error. */
1702 value_bit_index (struct type *type, const gdb_byte *valaddr, int index)
1704 struct gdbarch *gdbarch = get_type_arch (type);
1705 LONGEST low_bound, high_bound;
1708 struct type *range = TYPE_INDEX_TYPE (type);
1710 if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
1712 if (index < low_bound || index > high_bound)
1714 rel_index = index - low_bound;
1715 word = extract_unsigned_integer (valaddr + (rel_index / TARGET_CHAR_BIT), 1,
1716 gdbarch_byte_order (gdbarch));
1717 rel_index %= TARGET_CHAR_BIT;
1718 if (gdbarch_bits_big_endian (gdbarch))
1719 rel_index = TARGET_CHAR_BIT - 1 - rel_index;
1720 return (word >> rel_index) & 1;
1724 value_in (struct value *element, struct value *set)
1727 struct type *settype = check_typedef (value_type (set));
1728 struct type *eltype = check_typedef (value_type (element));
1730 if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
1731 eltype = TYPE_TARGET_TYPE (eltype);
1732 if (TYPE_CODE (settype) != TYPE_CODE_SET)
1733 error (_("Second argument of 'IN' has wrong type"));
1734 if (TYPE_CODE (eltype) != TYPE_CODE_INT
1735 && TYPE_CODE (eltype) != TYPE_CODE_CHAR
1736 && TYPE_CODE (eltype) != TYPE_CODE_ENUM
1737 && TYPE_CODE (eltype) != TYPE_CODE_BOOL)
1738 error (_("First argument of 'IN' has wrong type"));
1739 member = value_bit_index (settype, value_contents (set),
1740 value_as_long (element));
1742 error (_("First argument of 'IN' not in range"));
1747 _initialize_valarith (void)