1 /* Perform arithmetic and other operations on values, for GDB.
3 Copyright (C) 1986-2014 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"
31 #include "exceptions.h"
33 /* Define whether or not the C operator '/' truncates towards zero for
34 differently signed operands (truncation direction is undefined in C). */
36 #ifndef TRUNCATION_TOWARDS_ZERO
37 #define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
40 void _initialize_valarith (void);
43 /* Given a pointer, return the size of its target.
44 If the pointer type is void *, then return 1.
45 If the target type is incomplete, then error out.
46 This isn't a general purpose function, but just a
47 helper for value_ptradd. */
50 find_size_for_pointer_math (struct type *ptr_type)
53 struct type *ptr_target;
55 gdb_assert (TYPE_CODE (ptr_type) == TYPE_CODE_PTR);
56 ptr_target = check_typedef (TYPE_TARGET_TYPE (ptr_type));
58 sz = TYPE_LENGTH (ptr_target);
61 if (TYPE_CODE (ptr_type) == TYPE_CODE_VOID)
67 name = TYPE_NAME (ptr_target);
69 name = TYPE_TAG_NAME (ptr_target);
71 error (_("Cannot perform pointer math on incomplete types, "
72 "try casting to a known type, or void *."));
74 error (_("Cannot perform pointer math on incomplete type \"%s\", "
75 "try casting to a known type, or void *."), name);
81 /* Given a pointer ARG1 and an integral value ARG2, return the
82 result of C-style pointer arithmetic ARG1 + ARG2. */
85 value_ptradd (struct value *arg1, LONGEST arg2)
87 struct type *valptrtype;
91 arg1 = coerce_array (arg1);
92 valptrtype = check_typedef (value_type (arg1));
93 sz = find_size_for_pointer_math (valptrtype);
95 result = value_from_pointer (valptrtype,
96 value_as_address (arg1) + sz * arg2);
97 if (VALUE_LVAL (result) != lval_internalvar)
98 set_value_component_location (result, arg1);
102 /* Given two compatible pointer values ARG1 and ARG2, return the
103 result of C-style pointer arithmetic ARG1 - ARG2. */
106 value_ptrdiff (struct value *arg1, struct value *arg2)
108 struct type *type1, *type2;
111 arg1 = coerce_array (arg1);
112 arg2 = coerce_array (arg2);
113 type1 = check_typedef (value_type (arg1));
114 type2 = check_typedef (value_type (arg2));
116 gdb_assert (TYPE_CODE (type1) == TYPE_CODE_PTR);
117 gdb_assert (TYPE_CODE (type2) == TYPE_CODE_PTR);
119 if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)))
120 != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2))))
121 error (_("First argument of `-' is a pointer and "
122 "second argument is neither\n"
123 "an integer nor a pointer of the same type."));
125 sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
128 warning (_("Type size unknown, assuming 1. "
129 "Try casting to a known type, or void *."));
133 return (value_as_long (arg1) - value_as_long (arg2)) / sz;
136 /* Return the value of ARRAY[IDX].
138 ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING. If the
139 current language supports C-style arrays, it may also be TYPE_CODE_PTR.
141 See comments in value_coerce_array() for rationale for reason for
142 doing lower bounds adjustment here rather than there.
143 FIXME: Perhaps we should validate that the index is valid and if
144 verbosity is set, warn about invalid indices (but still use them). */
147 value_subscript (struct value *array, LONGEST index)
149 int c_style = current_language->c_style_arrays;
152 array = coerce_ref (array);
153 tarray = check_typedef (value_type (array));
155 if (TYPE_CODE (tarray) == TYPE_CODE_ARRAY
156 || TYPE_CODE (tarray) == TYPE_CODE_STRING)
158 struct type *range_type = TYPE_INDEX_TYPE (tarray);
159 LONGEST lowerbound, upperbound;
161 get_discrete_bounds (range_type, &lowerbound, &upperbound);
162 if (VALUE_LVAL (array) != lval_memory)
163 return value_subscripted_rvalue (array, index, lowerbound);
167 if (index >= lowerbound && index <= upperbound)
168 return value_subscripted_rvalue (array, index, lowerbound);
169 /* Emit warning unless we have an array of unknown size.
170 An array of unknown size has lowerbound 0 and upperbound -1. */
172 warning (_("array or string index out of range"));
173 /* fall doing C stuff */
178 array = value_coerce_array (array);
182 return value_ind (value_ptradd (array, index));
184 error (_("not an array or string"));
187 /* Return the value of EXPR[IDX], expr an aggregate rvalue
188 (eg, a vector register). This routine used to promote floats
189 to doubles, but no longer does. */
192 value_subscripted_rvalue (struct value *array, LONGEST index, int lowerbound)
194 struct type *array_type = check_typedef (value_type (array));
195 struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
196 unsigned int elt_size = TYPE_LENGTH (elt_type);
197 unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
200 if (index < lowerbound || (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type)
201 && elt_offs >= TYPE_LENGTH (array_type)))
202 error (_("no such vector element"));
204 if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
205 v = allocate_value_lazy (elt_type);
208 v = allocate_value (elt_type);
209 value_contents_copy (v, value_embedded_offset (v),
210 array, value_embedded_offset (array) + elt_offs,
214 set_value_component_location (v, array);
215 VALUE_REGNUM (v) = VALUE_REGNUM (array);
216 VALUE_FRAME_ID (v) = VALUE_FRAME_ID (array);
217 set_value_offset (v, value_offset (array) + elt_offs);
222 /* Check to see if either argument is a structure, or a reference to
223 one. This is called so we know whether to go ahead with the normal
224 binop or look for a user defined function instead.
226 For now, we do not overload the `=' operator. */
229 binop_types_user_defined_p (enum exp_opcode op,
230 struct type *type1, struct type *type2)
232 if (op == BINOP_ASSIGN || op == BINOP_CONCAT)
235 type1 = check_typedef (type1);
236 if (TYPE_CODE (type1) == TYPE_CODE_REF)
237 type1 = check_typedef (TYPE_TARGET_TYPE (type1));
239 type2 = check_typedef (type2);
240 if (TYPE_CODE (type2) == TYPE_CODE_REF)
241 type2 = check_typedef (TYPE_TARGET_TYPE (type2));
243 return (TYPE_CODE (type1) == TYPE_CODE_STRUCT
244 || TYPE_CODE (type2) == TYPE_CODE_STRUCT);
247 /* Check to see if either argument is a structure, or a reference to
248 one. This is called so we know whether to go ahead with the normal
249 binop or look for a user defined function instead.
251 For now, we do not overload the `=' operator. */
254 binop_user_defined_p (enum exp_opcode op,
255 struct value *arg1, struct value *arg2)
257 return binop_types_user_defined_p (op, value_type (arg1), value_type (arg2));
260 /* Check to see if argument is a structure. This is called so
261 we know whether to go ahead with the normal unop or look for a
262 user defined function instead.
264 For now, we do not overload the `&' operator. */
267 unop_user_defined_p (enum exp_opcode op, struct value *arg1)
273 type1 = check_typedef (value_type (arg1));
274 if (TYPE_CODE (type1) == TYPE_CODE_REF)
275 type1 = check_typedef (TYPE_TARGET_TYPE (type1));
276 return TYPE_CODE (type1) == TYPE_CODE_STRUCT;
279 /* Try to find an operator named OPERATOR which takes NARGS arguments
280 specified in ARGS. If the operator found is a static member operator
281 *STATIC_MEMFUNP will be set to 1, and otherwise 0.
282 The search if performed through find_overload_match which will handle
283 member operators, non member operators, operators imported implicitly or
284 explicitly, and perform correct overload resolution in all of the above
285 situations or combinations thereof. */
287 static struct value *
288 value_user_defined_cpp_op (struct value **args, int nargs, char *operator,
289 int *static_memfuncp)
292 struct symbol *symp = NULL;
293 struct value *valp = NULL;
295 find_overload_match (args, nargs, operator, BOTH /* could be method */,
297 NULL /* pass NULL symbol since symbol is unknown */,
298 &valp, &symp, static_memfuncp, 0);
305 /* This is a non member function and does not
306 expect a reference as its first argument
307 rather the explicit structure. */
308 args[0] = value_ind (args[0]);
309 return value_of_variable (symp, 0);
312 error (_("Could not find %s."), operator);
315 /* Lookup user defined operator NAME. Return a value representing the
316 function, otherwise return NULL. */
318 static struct value *
319 value_user_defined_op (struct value **argp, struct value **args, char *name,
320 int *static_memfuncp, int nargs)
322 struct value *result = NULL;
324 if (current_language->la_language == language_cplus)
325 result = value_user_defined_cpp_op (args, nargs, name, static_memfuncp);
327 result = value_struct_elt (argp, args, name, static_memfuncp,
333 /* We know either arg1 or arg2 is a structure, so try to find the right
334 user defined function. Create an argument vector that calls
335 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
336 binary operator which is legal for GNU C++).
338 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
339 is the opcode saying how to modify it. Otherwise, OTHEROP is
343 value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
344 enum exp_opcode otherop, enum noside noside)
346 struct value **argvec;
351 arg1 = coerce_ref (arg1);
352 arg2 = coerce_ref (arg2);
354 /* now we know that what we have to do is construct our
355 arg vector and find the right function to call it with. */
357 if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT)
358 error (_("Can't do that binary op on that type")); /* FIXME be explicit */
360 argvec = (struct value **) alloca (sizeof (struct value *) * 4);
361 argvec[1] = value_addr (arg1);
365 /* Make the right function name up. */
366 strcpy (tstr, "operator__");
391 case BINOP_BITWISE_AND:
394 case BINOP_BITWISE_IOR:
397 case BINOP_BITWISE_XOR:
400 case BINOP_LOGICAL_AND:
403 case BINOP_LOGICAL_OR:
415 case BINOP_ASSIGN_MODIFY:
433 case BINOP_BITWISE_AND:
436 case BINOP_BITWISE_IOR:
439 case BINOP_BITWISE_XOR:
442 case BINOP_MOD: /* invalid */
444 error (_("Invalid binary operation specified."));
447 case BINOP_SUBSCRIPT:
468 case BINOP_MOD: /* invalid */
470 error (_("Invalid binary operation specified."));
473 argvec[0] = value_user_defined_op (&arg1, argvec + 1, tstr,
474 &static_memfuncp, 2);
480 argvec[1] = argvec[0];
483 if (noside == EVAL_AVOID_SIDE_EFFECTS)
485 struct type *return_type;
488 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
489 return value_zero (return_type, VALUE_LVAL (arg1));
492 if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_XMETHOD)
494 /* Static xmethods are not supported yet. */
495 gdb_assert (static_memfuncp == 0);
496 return call_xmethod (argvec[0], 2, argvec + 1);
499 return call_function_by_hand (argvec[0], 2 - static_memfuncp,
502 throw_error (NOT_FOUND_ERROR,
503 _("member function %s not found"), tstr);
505 return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
509 /* We know that arg1 is a structure, so try to find a unary user
510 defined operator that matches the operator in question.
511 Create an argument vector that calls arg1.operator @ (arg1)
512 and return that value (where '@' is (almost) any unary operator which
513 is legal for GNU C++). */
516 value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
518 struct gdbarch *gdbarch = get_type_arch (value_type (arg1));
519 struct value **argvec;
521 char tstr[13], mangle_tstr[13];
522 int static_memfuncp, nargs;
524 arg1 = coerce_ref (arg1);
526 /* now we know that what we have to do is construct our
527 arg vector and find the right function to call it with. */
529 if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT)
530 error (_("Can't do that unary op on that type")); /* FIXME be explicit */
532 argvec = (struct value **) alloca (sizeof (struct value *) * 4);
533 argvec[1] = value_addr (arg1);
538 /* Make the right function name up. */
539 strcpy (tstr, "operator__");
541 strcpy (mangle_tstr, "__");
544 case UNOP_PREINCREMENT:
547 case UNOP_PREDECREMENT:
550 case UNOP_POSTINCREMENT:
552 argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
556 case UNOP_POSTDECREMENT:
558 argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
562 case UNOP_LOGICAL_NOT:
565 case UNOP_COMPLEMENT:
581 error (_("Invalid unary operation specified."));
584 argvec[0] = value_user_defined_op (&arg1, argvec + 1, tstr,
585 &static_memfuncp, nargs);
591 argvec[1] = argvec[0];
595 if (noside == EVAL_AVOID_SIDE_EFFECTS)
597 struct type *return_type;
600 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
601 return value_zero (return_type, VALUE_LVAL (arg1));
603 if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_XMETHOD)
605 /* Static xmethods are not supported yet. */
606 gdb_assert (static_memfuncp == 0);
607 return call_xmethod (argvec[0], 1, argvec + 1);
610 return call_function_by_hand (argvec[0], nargs, argvec + 1);
612 throw_error (NOT_FOUND_ERROR,
613 _("member function %s not found"), tstr);
615 return 0; /* For lint -- never reached */
619 /* Concatenate two values with the following conditions:
621 (1) Both values must be either bitstring values or character string
622 values and the resulting value consists of the concatenation of
623 ARG1 followed by ARG2.
627 One value must be an integer value and the other value must be
628 either a bitstring value or character string value, which is
629 to be repeated by the number of times specified by the integer
633 (2) Boolean values are also allowed and are treated as bit string
636 (3) Character values are also allowed and are treated as character
637 string values of length 1. */
640 value_concat (struct value *arg1, struct value *arg2)
642 struct value *inval1;
643 struct value *inval2;
644 struct value *outval = NULL;
645 int inval1len, inval2len;
649 struct type *type1 = check_typedef (value_type (arg1));
650 struct type *type2 = check_typedef (value_type (arg2));
651 struct type *char_type;
653 /* First figure out if we are dealing with two values to be concatenated
654 or a repeat count and a value to be repeated. INVAL1 is set to the
655 first of two concatenated values, or the repeat count. INVAL2 is set
656 to the second of the two concatenated values or the value to be
659 if (TYPE_CODE (type2) == TYPE_CODE_INT)
661 struct type *tmp = type1;
674 /* Now process the input values. */
676 if (TYPE_CODE (type1) == TYPE_CODE_INT)
678 /* We have a repeat count. Validate the second value and then
679 construct a value repeated that many times. */
680 if (TYPE_CODE (type2) == TYPE_CODE_STRING
681 || TYPE_CODE (type2) == TYPE_CODE_CHAR)
683 struct cleanup *back_to;
685 count = longest_to_int (value_as_long (inval1));
686 inval2len = TYPE_LENGTH (type2);
687 ptr = (char *) xmalloc (count * inval2len);
688 back_to = make_cleanup (xfree, ptr);
689 if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
693 inchar = (char) unpack_long (type2,
694 value_contents (inval2));
695 for (idx = 0; idx < count; idx++)
697 *(ptr + idx) = inchar;
702 char_type = TYPE_TARGET_TYPE (type2);
704 for (idx = 0; idx < count; idx++)
706 memcpy (ptr + (idx * inval2len), value_contents (inval2),
710 outval = value_string (ptr, count * inval2len, char_type);
711 do_cleanups (back_to);
713 else if (TYPE_CODE (type2) == TYPE_CODE_BOOL)
715 error (_("unimplemented support for boolean repeats"));
719 error (_("can't repeat values of that type"));
722 else if (TYPE_CODE (type1) == TYPE_CODE_STRING
723 || TYPE_CODE (type1) == TYPE_CODE_CHAR)
725 struct cleanup *back_to;
727 /* We have two character strings to concatenate. */
728 if (TYPE_CODE (type2) != TYPE_CODE_STRING
729 && TYPE_CODE (type2) != TYPE_CODE_CHAR)
731 error (_("Strings can only be concatenated with other strings."));
733 inval1len = TYPE_LENGTH (type1);
734 inval2len = TYPE_LENGTH (type2);
735 ptr = (char *) xmalloc (inval1len + inval2len);
736 back_to = make_cleanup (xfree, ptr);
737 if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
741 *ptr = (char) unpack_long (type1, value_contents (inval1));
745 char_type = TYPE_TARGET_TYPE (type1);
747 memcpy (ptr, value_contents (inval1), inval1len);
749 if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
752 (char) unpack_long (type2, value_contents (inval2));
756 memcpy (ptr + inval1len, value_contents (inval2), inval2len);
758 outval = value_string (ptr, inval1len + inval2len, char_type);
759 do_cleanups (back_to);
761 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL)
763 /* We have two bitstrings to concatenate. */
764 if (TYPE_CODE (type2) != TYPE_CODE_BOOL)
766 error (_("Booleans can only be concatenated "
767 "with other bitstrings or booleans."));
769 error (_("unimplemented support for boolean concatenation."));
773 /* We don't know how to concatenate these operands. */
774 error (_("illegal operands for concatenation."));
779 /* Integer exponentiation: V1**V2, where both arguments are
780 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
783 integer_pow (LONGEST v1, LONGEST v2)
788 error (_("Attempt to raise 0 to negative power."));
794 /* The Russian Peasant's Algorithm. */
810 /* Integer exponentiation: V1**V2, where both arguments are
811 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
814 uinteger_pow (ULONGEST v1, LONGEST v2)
819 error (_("Attempt to raise 0 to negative power."));
825 /* The Russian Peasant's Algorithm. */
841 /* Obtain decimal value of arguments for binary operation, converting from
842 other types if one of them is not decimal floating point. */
844 value_args_as_decimal (struct value *arg1, struct value *arg2,
845 gdb_byte *x, int *len_x, enum bfd_endian *byte_order_x,
846 gdb_byte *y, int *len_y, enum bfd_endian *byte_order_y)
848 struct type *type1, *type2;
850 type1 = check_typedef (value_type (arg1));
851 type2 = check_typedef (value_type (arg2));
853 /* At least one of the arguments must be of decimal float type. */
854 gdb_assert (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
855 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT);
857 if (TYPE_CODE (type1) == TYPE_CODE_FLT
858 || TYPE_CODE (type2) == TYPE_CODE_FLT)
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 decimal value of arg1, converting from other types
868 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
870 *byte_order_x = gdbarch_byte_order (get_type_arch (type1));
871 *len_x = TYPE_LENGTH (type1);
872 memcpy (x, value_contents (arg1), *len_x);
874 else if (is_integral_type (type1))
876 *byte_order_x = gdbarch_byte_order (get_type_arch (type2));
877 *len_x = TYPE_LENGTH (type2);
878 decimal_from_integral (arg1, x, *len_x, *byte_order_x);
881 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1),
884 /* Obtain decimal value of arg2, converting from other types
887 if (TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
889 *byte_order_y = gdbarch_byte_order (get_type_arch (type2));
890 *len_y = TYPE_LENGTH (type2);
891 memcpy (y, value_contents (arg2), *len_y);
893 else if (is_integral_type (type2))
895 *byte_order_y = gdbarch_byte_order (get_type_arch (type1));
896 *len_y = TYPE_LENGTH (type1);
897 decimal_from_integral (arg2, y, *len_y, *byte_order_y);
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 ((TYPE_CODE (type1) != TYPE_CODE_FLT
923 && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
924 && !is_integral_type (type1))
925 || (TYPE_CODE (type2) != TYPE_CODE_FLT
926 && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
927 && !is_integral_type (type2)))
928 error (_("Argument to arithmetic operation not a number or boolean."));
930 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
931 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
933 int len_v1, len_v2, len_v;
934 enum bfd_endian byte_order_v1, byte_order_v2, byte_order_v;
935 gdb_byte v1[16], v2[16];
938 /* If only one type is decimal float, use its type.
939 Otherwise use the bigger type. */
940 if (TYPE_CODE (type1) != TYPE_CODE_DECFLOAT)
942 else if (TYPE_CODE (type2) != TYPE_CODE_DECFLOAT)
944 else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
949 len_v = TYPE_LENGTH (result_type);
950 byte_order_v = gdbarch_byte_order (get_type_arch (result_type));
952 value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
953 v2, &len_v2, &byte_order_v2);
962 decimal_binop (op, v1, len_v1, byte_order_v1,
963 v2, len_v2, byte_order_v2,
964 v, len_v, byte_order_v);
968 error (_("Operation not valid for decimal floating point number."));
971 val = value_from_decfloat (result_type, v);
973 else if (TYPE_CODE (type1) == TYPE_CODE_FLT
974 || TYPE_CODE (type2) == TYPE_CODE_FLT)
976 /* FIXME-if-picky-about-floating-accuracy: Should be doing this
977 in target format. real.c in GCC probably has the necessary
979 DOUBLEST v1, v2, v = 0;
981 v1 = value_as_double (arg1);
982 v2 = value_as_double (arg2);
1006 error (_("Cannot perform exponentiation: %s"),
1007 safe_strerror (errno));
1011 v = v1 < v2 ? v1 : v2;
1015 v = v1 > v2 ? v1 : v2;
1019 error (_("Integer-only operation on floating point number."));
1022 /* If only one type is float, use its type.
1023 Otherwise use the bigger type. */
1024 if (TYPE_CODE (type1) != TYPE_CODE_FLT)
1025 result_type = type2;
1026 else if (TYPE_CODE (type2) != TYPE_CODE_FLT)
1027 result_type = type1;
1028 else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
1029 result_type = type2;
1031 result_type = type1;
1033 val = allocate_value (result_type);
1034 store_typed_floating (value_contents_raw (val), value_type (val), v);
1036 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
1037 || TYPE_CODE (type2) == TYPE_CODE_BOOL)
1039 LONGEST v1, v2, v = 0;
1041 v1 = value_as_long (arg1);
1042 v2 = value_as_long (arg2);
1046 case BINOP_BITWISE_AND:
1050 case BINOP_BITWISE_IOR:
1054 case BINOP_BITWISE_XOR:
1062 case BINOP_NOTEQUAL:
1067 error (_("Invalid operation on booleans."));
1070 result_type = type1;
1072 val = allocate_value (result_type);
1073 store_signed_integer (value_contents_raw (val),
1074 TYPE_LENGTH (result_type),
1075 gdbarch_byte_order (get_type_arch (result_type)),
1079 /* Integral operations here. */
1081 /* Determine type length of the result, and if the operation should
1082 be done unsigned. For exponentiation and shift operators,
1083 use the length and type of the left operand. Otherwise,
1084 use the signedness of the operand with the greater length.
1085 If both operands are of equal length, use unsigned operation
1086 if one of the operands is unsigned. */
1087 if (op == BINOP_RSH || op == BINOP_LSH || op == BINOP_EXP)
1088 result_type = type1;
1089 else if (TYPE_LENGTH (type1) > TYPE_LENGTH (type2))
1090 result_type = type1;
1091 else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
1092 result_type = type2;
1093 else if (TYPE_UNSIGNED (type1))
1094 result_type = type1;
1095 else if (TYPE_UNSIGNED (type2))
1096 result_type = type2;
1098 result_type = type1;
1100 if (TYPE_UNSIGNED (result_type))
1102 LONGEST v2_signed = value_as_long (arg2);
1103 ULONGEST v1, v2, v = 0;
1105 v1 = (ULONGEST) value_as_long (arg1);
1106 v2 = (ULONGEST) v2_signed;
1127 error (_("Division by zero"));
1131 v = uinteger_pow (v1, v2_signed);
1138 error (_("Division by zero"));
1142 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1143 v1 mod 0 has a defined value, v1. */
1151 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1164 case BINOP_BITWISE_AND:
1168 case BINOP_BITWISE_IOR:
1172 case BINOP_BITWISE_XOR:
1176 case BINOP_LOGICAL_AND:
1180 case BINOP_LOGICAL_OR:
1185 v = v1 < v2 ? v1 : v2;
1189 v = v1 > v2 ? v1 : v2;
1196 case BINOP_NOTEQUAL:
1217 error (_("Invalid binary operation on numbers."));
1220 val = allocate_value (result_type);
1221 store_unsigned_integer (value_contents_raw (val),
1222 TYPE_LENGTH (value_type (val)),
1224 (get_type_arch (result_type)),
1229 LONGEST v1, v2, v = 0;
1231 v1 = value_as_long (arg1);
1232 v2 = value_as_long (arg2);
1253 error (_("Division by zero"));
1257 v = integer_pow (v1, v2);
1264 error (_("Division by zero"));
1268 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1269 X mod 0 has a defined value, X. */
1277 /* Compute floor. */
1278 if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0))
1294 case BINOP_BITWISE_AND:
1298 case BINOP_BITWISE_IOR:
1302 case BINOP_BITWISE_XOR:
1306 case BINOP_LOGICAL_AND:
1310 case BINOP_LOGICAL_OR:
1315 v = v1 < v2 ? v1 : v2;
1319 v = v1 > v2 ? v1 : v2;
1326 case BINOP_NOTEQUAL:
1347 error (_("Invalid binary operation on numbers."));
1350 val = allocate_value (result_type);
1351 store_signed_integer (value_contents_raw (val),
1352 TYPE_LENGTH (value_type (val)),
1354 (get_type_arch (result_type)),
1362 /* Widen a scalar value SCALAR_VALUE to vector type VECTOR_TYPE by
1363 replicating SCALAR_VALUE for each element of the vector. Only scalar
1364 types that can be cast to the type of one element of the vector are
1365 acceptable. The newly created vector value is returned upon success,
1366 otherwise an error is thrown. */
1369 value_vector_widen (struct value *scalar_value, struct type *vector_type)
1371 /* Widen the scalar to a vector. */
1372 struct type *eltype, *scalar_type;
1373 struct value *val, *elval;
1374 LONGEST low_bound, high_bound;
1377 CHECK_TYPEDEF (vector_type);
1379 gdb_assert (TYPE_CODE (vector_type) == TYPE_CODE_ARRAY
1380 && TYPE_VECTOR (vector_type));
1382 if (!get_array_bounds (vector_type, &low_bound, &high_bound))
1383 error (_("Could not determine the vector bounds"));
1385 eltype = check_typedef (TYPE_TARGET_TYPE (vector_type));
1386 elval = value_cast (eltype, scalar_value);
1388 scalar_type = check_typedef (value_type (scalar_value));
1390 /* If we reduced the length of the scalar then check we didn't loose any
1392 if (TYPE_LENGTH (eltype) < TYPE_LENGTH (scalar_type)
1393 && !value_equal (elval, scalar_value))
1394 error (_("conversion of scalar to vector involves truncation"));
1396 val = allocate_value (vector_type);
1397 for (i = 0; i < high_bound - low_bound + 1; i++)
1398 /* Duplicate the contents of elval into the destination vector. */
1399 memcpy (value_contents_writeable (val) + (i * TYPE_LENGTH (eltype)),
1400 value_contents_all (elval), TYPE_LENGTH (eltype));
1405 /* Performs a binary operation on two vector operands by calling scalar_binop
1406 for each pair of vector components. */
1408 static struct value *
1409 vector_binop (struct value *val1, struct value *val2, enum exp_opcode op)
1411 struct value *val, *tmp, *mark;
1412 struct type *type1, *type2, *eltype1, *eltype2;
1413 int t1_is_vec, t2_is_vec, elsize, i;
1414 LONGEST low_bound1, high_bound1, low_bound2, high_bound2;
1416 type1 = check_typedef (value_type (val1));
1417 type2 = check_typedef (value_type (val2));
1419 t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
1420 && TYPE_VECTOR (type1)) ? 1 : 0;
1421 t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
1422 && TYPE_VECTOR (type2)) ? 1 : 0;
1424 if (!t1_is_vec || !t2_is_vec)
1425 error (_("Vector operations are only supported among vectors"));
1427 if (!get_array_bounds (type1, &low_bound1, &high_bound1)
1428 || !get_array_bounds (type2, &low_bound2, &high_bound2))
1429 error (_("Could not determine the vector bounds"));
1431 eltype1 = check_typedef (TYPE_TARGET_TYPE (type1));
1432 eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
1433 elsize = TYPE_LENGTH (eltype1);
1435 if (TYPE_CODE (eltype1) != TYPE_CODE (eltype2)
1436 || elsize != TYPE_LENGTH (eltype2)
1437 || TYPE_UNSIGNED (eltype1) != TYPE_UNSIGNED (eltype2)
1438 || low_bound1 != low_bound2 || high_bound1 != high_bound2)
1439 error (_("Cannot perform operation on vectors with different types"));
1441 val = allocate_value (type1);
1442 mark = value_mark ();
1443 for (i = 0; i < high_bound1 - low_bound1 + 1; i++)
1445 tmp = value_binop (value_subscript (val1, i),
1446 value_subscript (val2, i), op);
1447 memcpy (value_contents_writeable (val) + i * elsize,
1448 value_contents_all (tmp),
1451 value_free_to_mark (mark);
1456 /* Perform a binary operation on two operands. */
1459 value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
1462 struct type *type1 = check_typedef (value_type (arg1));
1463 struct type *type2 = check_typedef (value_type (arg2));
1464 int t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
1465 && TYPE_VECTOR (type1));
1466 int t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
1467 && TYPE_VECTOR (type2));
1469 if (!t1_is_vec && !t2_is_vec)
1470 val = scalar_binop (arg1, arg2, op);
1471 else if (t1_is_vec && t2_is_vec)
1472 val = vector_binop (arg1, arg2, op);
1475 /* Widen the scalar operand to a vector. */
1476 struct value **v = t1_is_vec ? &arg2 : &arg1;
1477 struct type *t = t1_is_vec ? type2 : type1;
1479 if (TYPE_CODE (t) != TYPE_CODE_FLT
1480 && TYPE_CODE (t) != TYPE_CODE_DECFLOAT
1481 && !is_integral_type (t))
1482 error (_("Argument to operation not a number or boolean."));
1484 /* Replicate the scalar value to make a vector value. */
1485 *v = value_vector_widen (*v, t1_is_vec ? type1 : type2);
1487 val = vector_binop (arg1, arg2, op);
1493 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1496 value_logical_not (struct value *arg1)
1502 arg1 = coerce_array (arg1);
1503 type1 = check_typedef (value_type (arg1));
1505 if (TYPE_CODE (type1) == TYPE_CODE_FLT)
1506 return 0 == value_as_double (arg1);
1507 else if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
1508 return decimal_is_zero (value_contents (arg1), TYPE_LENGTH (type1),
1509 gdbarch_byte_order (get_type_arch (type1)));
1511 len = TYPE_LENGTH (type1);
1512 p = value_contents (arg1);
1523 /* Perform a comparison on two string values (whose content are not
1524 necessarily null terminated) based on their length. */
1527 value_strcmp (struct value *arg1, struct value *arg2)
1529 int len1 = TYPE_LENGTH (value_type (arg1));
1530 int len2 = TYPE_LENGTH (value_type (arg2));
1531 const gdb_byte *s1 = value_contents (arg1);
1532 const gdb_byte *s2 = value_contents (arg2);
1533 int i, len = len1 < len2 ? len1 : len2;
1535 for (i = 0; i < len; i++)
1539 else if (s1[i] > s2[i])
1547 else if (len1 > len2)
1553 /* Simulate the C operator == by returning a 1
1554 iff ARG1 and ARG2 have equal contents. */
1557 value_equal (struct value *arg1, struct value *arg2)
1562 struct type *type1, *type2;
1563 enum type_code code1;
1564 enum type_code code2;
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 ((code1 == TYPE_CODE_FLT || is_int1)
1581 && (code2 == TYPE_CODE_FLT || is_int2))
1583 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1584 `long double' values are returned in static storage (m68k). */
1585 DOUBLEST d = value_as_double (arg1);
1587 return d == value_as_double (arg2);
1589 else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
1590 && (code2 == TYPE_CODE_DECFLOAT || is_int2))
1592 gdb_byte v1[16], v2[16];
1594 enum bfd_endian byte_order_v1, byte_order_v2;
1596 value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
1597 v2, &len_v2, &byte_order_v2);
1599 return decimal_compare (v1, len_v1, byte_order_v1,
1600 v2, len_v2, byte_order_v2) == 0;
1603 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1605 else if (code1 == TYPE_CODE_PTR && is_int2)
1606 return value_as_address (arg1) == (CORE_ADDR) value_as_long (arg2);
1607 else if (code2 == TYPE_CODE_PTR && is_int1)
1608 return (CORE_ADDR) value_as_long (arg1) == value_as_address (arg2);
1610 else if (code1 == code2
1611 && ((len = (int) TYPE_LENGTH (type1))
1612 == (int) TYPE_LENGTH (type2)))
1614 p1 = value_contents (arg1);
1615 p2 = value_contents (arg2);
1623 else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1625 return value_strcmp (arg1, arg2) == 0;
1629 error (_("Invalid type combination in equality test."));
1630 return 0; /* For lint -- never reached. */
1634 /* Compare values based on their raw contents. Useful for arrays since
1635 value_equal coerces them to pointers, thus comparing just the address
1636 of the array instead of its contents. */
1639 value_equal_contents (struct value *arg1, struct value *arg2)
1641 struct type *type1, *type2;
1643 type1 = check_typedef (value_type (arg1));
1644 type2 = check_typedef (value_type (arg2));
1646 return (TYPE_CODE (type1) == TYPE_CODE (type2)
1647 && TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
1648 && memcmp (value_contents (arg1), value_contents (arg2),
1649 TYPE_LENGTH (type1)) == 0);
1652 /* Simulate the C operator < by returning 1
1653 iff ARG1's contents are less than ARG2's. */
1656 value_less (struct value *arg1, struct value *arg2)
1658 enum type_code code1;
1659 enum type_code code2;
1660 struct type *type1, *type2;
1661 int is_int1, is_int2;
1663 arg1 = coerce_array (arg1);
1664 arg2 = coerce_array (arg2);
1666 type1 = check_typedef (value_type (arg1));
1667 type2 = check_typedef (value_type (arg2));
1668 code1 = TYPE_CODE (type1);
1669 code2 = TYPE_CODE (type2);
1670 is_int1 = is_integral_type (type1);
1671 is_int2 = is_integral_type (type2);
1673 if (is_int1 && is_int2)
1674 return longest_to_int (value_as_long (value_binop (arg1, arg2,
1676 else if ((code1 == TYPE_CODE_FLT || is_int1)
1677 && (code2 == TYPE_CODE_FLT || is_int2))
1679 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1680 `long double' values are returned in static storage (m68k). */
1681 DOUBLEST d = value_as_double (arg1);
1683 return d < value_as_double (arg2);
1685 else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
1686 && (code2 == TYPE_CODE_DECFLOAT || is_int2))
1688 gdb_byte v1[16], v2[16];
1690 enum bfd_endian byte_order_v1, byte_order_v2;
1692 value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
1693 v2, &len_v2, &byte_order_v2);
1695 return decimal_compare (v1, len_v1, byte_order_v1,
1696 v2, len_v2, byte_order_v2) == -1;
1698 else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
1699 return value_as_address (arg1) < value_as_address (arg2);
1701 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1703 else if (code1 == TYPE_CODE_PTR && is_int2)
1704 return value_as_address (arg1) < (CORE_ADDR) value_as_long (arg2);
1705 else if (code2 == TYPE_CODE_PTR && is_int1)
1706 return (CORE_ADDR) value_as_long (arg1) < value_as_address (arg2);
1707 else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1708 return value_strcmp (arg1, arg2) < 0;
1711 error (_("Invalid type combination in ordering comparison."));
1716 /* The unary operators +, - and ~. They free the argument ARG1. */
1719 value_pos (struct value *arg1)
1723 arg1 = coerce_ref (arg1);
1724 type = check_typedef (value_type (arg1));
1726 if (TYPE_CODE (type) == TYPE_CODE_FLT)
1727 return value_from_double (type, value_as_double (arg1));
1728 else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1729 return value_from_decfloat (type, value_contents (arg1));
1730 else if (is_integral_type (type))
1732 return value_from_longest (type, value_as_long (arg1));
1734 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
1736 struct value *val = allocate_value (type);
1738 memcpy (value_contents_raw (val), value_contents (arg1),
1739 TYPE_LENGTH (type));
1744 error (_("Argument to positive operation not a number."));
1745 return 0; /* For lint -- never reached. */
1750 value_neg (struct value *arg1)
1754 arg1 = coerce_ref (arg1);
1755 type = check_typedef (value_type (arg1));
1757 if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1759 struct value *val = allocate_value (type);
1760 int len = TYPE_LENGTH (type);
1761 gdb_byte decbytes[16]; /* a decfloat is at most 128 bits long. */
1763 memcpy (decbytes, value_contents (arg1), len);
1765 if (gdbarch_byte_order (get_type_arch (type)) == BFD_ENDIAN_LITTLE)
1766 decbytes[len-1] = decbytes[len - 1] | 0x80;
1768 decbytes[0] = decbytes[0] | 0x80;
1770 memcpy (value_contents_raw (val), decbytes, len);
1773 else if (TYPE_CODE (type) == TYPE_CODE_FLT)
1774 return value_from_double (type, -value_as_double (arg1));
1775 else if (is_integral_type (type))
1777 return value_from_longest (type, -value_as_long (arg1));
1779 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
1781 struct value *tmp, *val = allocate_value (type);
1782 struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
1784 LONGEST low_bound, high_bound;
1786 if (!get_array_bounds (type, &low_bound, &high_bound))
1787 error (_("Could not determine the vector bounds"));
1789 for (i = 0; i < high_bound - low_bound + 1; i++)
1791 tmp = value_neg (value_subscript (arg1, i));
1792 memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
1793 value_contents_all (tmp), TYPE_LENGTH (eltype));
1799 error (_("Argument to negate operation not a number."));
1800 return 0; /* For lint -- never reached. */
1805 value_complement (struct value *arg1)
1810 arg1 = coerce_ref (arg1);
1811 type = check_typedef (value_type (arg1));
1813 if (is_integral_type (type))
1814 val = value_from_longest (type, ~value_as_long (arg1));
1815 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
1818 struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
1820 LONGEST low_bound, high_bound;
1822 if (!get_array_bounds (type, &low_bound, &high_bound))
1823 error (_("Could not determine the vector bounds"));
1825 val = allocate_value (type);
1826 for (i = 0; i < high_bound - low_bound + 1; i++)
1828 tmp = value_complement (value_subscript (arg1, i));
1829 memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
1830 value_contents_all (tmp), TYPE_LENGTH (eltype));
1834 error (_("Argument to complement operation not an integer, boolean."));
1839 /* The INDEX'th bit of SET value whose value_type is TYPE,
1840 and whose value_contents is valaddr.
1841 Return -1 if out of range, -2 other error. */
1844 value_bit_index (struct type *type, const gdb_byte *valaddr, int index)
1846 struct gdbarch *gdbarch = get_type_arch (type);
1847 LONGEST low_bound, high_bound;
1850 struct type *range = TYPE_INDEX_TYPE (type);
1852 if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
1854 if (index < low_bound || index > high_bound)
1856 rel_index = index - low_bound;
1857 word = extract_unsigned_integer (valaddr + (rel_index / TARGET_CHAR_BIT), 1,
1858 gdbarch_byte_order (gdbarch));
1859 rel_index %= TARGET_CHAR_BIT;
1860 if (gdbarch_bits_big_endian (gdbarch))
1861 rel_index = TARGET_CHAR_BIT - 1 - rel_index;
1862 return (word >> rel_index) & 1;
1866 value_in (struct value *element, struct value *set)
1869 struct type *settype = check_typedef (value_type (set));
1870 struct type *eltype = check_typedef (value_type (element));
1872 if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
1873 eltype = TYPE_TARGET_TYPE (eltype);
1874 if (TYPE_CODE (settype) != TYPE_CODE_SET)
1875 error (_("Second argument of 'IN' has wrong type"));
1876 if (TYPE_CODE (eltype) != TYPE_CODE_INT
1877 && TYPE_CODE (eltype) != TYPE_CODE_CHAR
1878 && TYPE_CODE (eltype) != TYPE_CODE_ENUM
1879 && TYPE_CODE (eltype) != TYPE_CODE_BOOL)
1880 error (_("First argument of 'IN' has wrong type"));
1881 member = value_bit_index (settype, value_contents (set),
1882 value_as_long (element));
1884 error (_("First argument of 'IN' not in range"));
1889 _initialize_valarith (void)