1 /* Perform arithmetic and other operations on values, for GDB.
3 Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
29 #include "gdb_string.h"
35 /* Define whether or not the C operator '/' truncates towards zero for
36 differently signed operands (truncation direction is undefined in C). */
38 #ifndef TRUNCATION_TOWARDS_ZERO
39 #define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
42 void _initialize_valarith (void);
45 /* Given a pointer, return the size of its target.
46 If the pointer type is void *, then return 1.
47 If the target type is incomplete, then error out.
48 This isn't a general purpose function, but just a
49 helper for value_ptrsub & value_ptradd.
53 find_size_for_pointer_math (struct type *ptr_type)
56 struct type *ptr_target;
58 gdb_assert (TYPE_CODE (ptr_type) == TYPE_CODE_PTR);
59 ptr_target = check_typedef (TYPE_TARGET_TYPE (ptr_type));
61 sz = TYPE_LENGTH (ptr_target);
64 if (TYPE_CODE (ptr_type) == TYPE_CODE_VOID)
70 name = TYPE_NAME (ptr_target);
72 name = TYPE_TAG_NAME (ptr_target);
74 error (_("Cannot perform pointer math on incomplete types, "
75 "try casting to a known type, or void *."));
77 error (_("Cannot perform pointer math on incomplete type \"%s\", "
78 "try casting to a known type, or void *."), name);
84 /* Given a pointer ARG1 and an integral value ARG2, return the
85 result of C-style pointer arithmetic ARG1 + ARG2. */
88 value_ptradd (struct value *arg1, struct value *arg2)
90 struct type *valptrtype;
93 arg1 = coerce_array (arg1);
94 valptrtype = check_typedef (value_type (arg1));
95 sz = find_size_for_pointer_math (valptrtype);
97 if (!is_integral_type (value_type (arg2)))
98 error (_("Argument to arithmetic operation not a number or boolean."));
100 return value_from_pointer (valptrtype,
101 value_as_address (arg1)
102 + (sz * value_as_long (arg2)));
105 /* Given a pointer ARG1 and an integral value ARG2, return the
106 result of C-style pointer arithmetic ARG1 - ARG2. */
109 value_ptrsub (struct value *arg1, struct value *arg2)
111 struct type *valptrtype;
114 arg1 = coerce_array (arg1);
115 valptrtype = check_typedef (value_type (arg1));
116 sz = find_size_for_pointer_math (valptrtype);
118 if (!is_integral_type (value_type (arg2)))
119 error (_("Argument to arithmetic operation not a number or boolean."));
121 return value_from_pointer (valptrtype,
122 value_as_address (arg1)
123 - (sz * value_as_long (arg2)));
126 /* Given two compatible pointer values ARG1 and ARG2, return the
127 result of C-style pointer arithmetic ARG1 - ARG2. */
130 value_ptrdiff (struct value *arg1, struct value *arg2)
132 struct type *type1, *type2;
135 arg1 = coerce_array (arg1);
136 arg2 = coerce_array (arg2);
137 type1 = check_typedef (value_type (arg1));
138 type2 = check_typedef (value_type (arg2));
140 gdb_assert (TYPE_CODE (type1) == TYPE_CODE_PTR);
141 gdb_assert (TYPE_CODE (type2) == TYPE_CODE_PTR);
143 if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)))
144 != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2))))
146 First argument of `-' is a pointer and second argument is neither\n\
147 an integer nor a pointer of the same type."));
149 sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
150 return (value_as_long (arg1) - value_as_long (arg2)) / sz;
153 /* Return the value of ARRAY[IDX].
155 ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING. If the
156 current language supports C-style arrays, it may also be TYPE_CODE_PTR.
157 To access TYPE_CODE_BITSTRING values, use value_bitstring_subscript.
159 See comments in value_coerce_array() for rationale for reason for
160 doing lower bounds adjustment here rather than there.
161 FIXME: Perhaps we should validate that the index is valid and if
162 verbosity is set, warn about invalid indices (but still use them). */
165 value_subscript (struct value *array, struct value *idx)
168 int c_style = current_language->c_style_arrays;
171 array = coerce_ref (array);
172 tarray = check_typedef (value_type (array));
174 if (TYPE_CODE (tarray) == TYPE_CODE_ARRAY
175 || TYPE_CODE (tarray) == TYPE_CODE_STRING)
177 struct type *range_type = TYPE_INDEX_TYPE (tarray);
178 LONGEST lowerbound, upperbound;
179 get_discrete_bounds (range_type, &lowerbound, &upperbound);
181 if (VALUE_LVAL (array) != lval_memory)
182 return value_subscripted_rvalue (array, idx, lowerbound);
186 LONGEST index = value_as_long (idx);
187 if (index >= lowerbound && index <= upperbound)
188 return value_subscripted_rvalue (array, idx, lowerbound);
189 /* Emit warning unless we have an array of unknown size.
190 An array of unknown size has lowerbound 0 and upperbound -1. */
192 warning (_("array or string index out of range"));
193 /* fall doing C stuff */
199 bound = value_from_longest (value_type (idx), (LONGEST) lowerbound);
200 idx = value_binop (idx, bound, BINOP_SUB);
203 array = value_coerce_array (array);
207 return value_ind (value_ptradd (array, idx));
209 error (_("not an array or string"));
212 /* Return the value of EXPR[IDX], expr an aggregate rvalue
213 (eg, a vector register). This routine used to promote floats
214 to doubles, but no longer does. */
217 value_subscripted_rvalue (struct value *array, struct value *idx, int lowerbound)
219 struct type *array_type = check_typedef (value_type (array));
220 struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
221 unsigned int elt_size = TYPE_LENGTH (elt_type);
222 LONGEST index = value_as_long (idx);
223 unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
226 if (index < lowerbound || elt_offs >= TYPE_LENGTH (array_type))
227 error (_("no such vector element"));
229 v = allocate_value (elt_type);
230 if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
231 set_value_lazy (v, 1);
233 memcpy (value_contents_writeable (v),
234 value_contents (array) + elt_offs, elt_size);
236 if (VALUE_LVAL (array) == lval_internalvar)
237 VALUE_LVAL (v) = lval_internalvar_component;
239 VALUE_LVAL (v) = VALUE_LVAL (array);
240 VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
241 VALUE_REGNUM (v) = VALUE_REGNUM (array);
242 VALUE_FRAME_ID (v) = VALUE_FRAME_ID (array);
243 set_value_offset (v, value_offset (array) + elt_offs);
247 /* Return the value of BITSTRING[IDX] as (boolean) type TYPE. */
250 value_bitstring_subscript (struct type *type,
251 struct value *bitstring, struct value *idx)
254 struct type *bitstring_type, *range_type;
255 LONGEST index = value_as_long (idx);
257 int offset, byte, bit_index;
258 LONGEST lowerbound, upperbound;
260 bitstring_type = check_typedef (value_type (bitstring));
261 gdb_assert (TYPE_CODE (bitstring_type) == TYPE_CODE_BITSTRING);
263 range_type = TYPE_INDEX_TYPE (bitstring_type);
264 get_discrete_bounds (range_type, &lowerbound, &upperbound);
265 if (index < lowerbound || index > upperbound)
266 error (_("bitstring index out of range"));
269 offset = index / TARGET_CHAR_BIT;
270 byte = *((char *) value_contents (bitstring) + offset);
272 bit_index = index % TARGET_CHAR_BIT;
273 byte >>= (gdbarch_bits_big_endian (current_gdbarch) ?
274 TARGET_CHAR_BIT - 1 - bit_index : bit_index);
276 v = value_from_longest (type, byte & 1);
278 set_value_bitpos (v, bit_index);
279 set_value_bitsize (v, 1);
281 VALUE_LVAL (v) = VALUE_LVAL (bitstring);
282 if (VALUE_LVAL (bitstring) == lval_internalvar)
283 VALUE_LVAL (v) = lval_internalvar_component;
284 VALUE_ADDRESS (v) = VALUE_ADDRESS (bitstring);
285 VALUE_FRAME_ID (v) = VALUE_FRAME_ID (bitstring);
287 set_value_offset (v, offset + value_offset (bitstring));
293 /* Check to see if either argument is a structure, or a reference to
294 one. This is called so we know whether to go ahead with the normal
295 binop or look for a user defined function instead.
297 For now, we do not overload the `=' operator. */
300 binop_user_defined_p (enum exp_opcode op, struct value *arg1, struct value *arg2)
302 struct type *type1, *type2;
303 if (op == BINOP_ASSIGN || op == BINOP_CONCAT)
306 type1 = check_typedef (value_type (arg1));
307 if (TYPE_CODE (type1) == TYPE_CODE_REF)
308 type1 = check_typedef (TYPE_TARGET_TYPE (type1));
310 type2 = check_typedef (value_type (arg2));
311 if (TYPE_CODE (type2) == TYPE_CODE_REF)
312 type2 = check_typedef (TYPE_TARGET_TYPE (type2));
314 return (TYPE_CODE (type1) == TYPE_CODE_STRUCT
315 || TYPE_CODE (type2) == TYPE_CODE_STRUCT);
318 /* Check to see if argument is a structure. This is called so
319 we know whether to go ahead with the normal unop or look for a
320 user defined function instead.
322 For now, we do not overload the `&' operator. */
325 unop_user_defined_p (enum exp_opcode op, struct value *arg1)
330 type1 = check_typedef (value_type (arg1));
333 if (TYPE_CODE (type1) == TYPE_CODE_STRUCT)
335 else if (TYPE_CODE (type1) == TYPE_CODE_REF)
336 type1 = TYPE_TARGET_TYPE (type1);
342 /* We know either arg1 or arg2 is a structure, so try to find the right
343 user defined function. Create an argument vector that calls
344 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
345 binary operator which is legal for GNU C++).
347 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
348 is the opcode saying how to modify it. Otherwise, OTHEROP is
352 value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
353 enum exp_opcode otherop, enum noside noside)
355 struct value **argvec;
360 arg1 = coerce_ref (arg1);
361 arg2 = coerce_ref (arg2);
363 /* now we know that what we have to do is construct our
364 arg vector and find the right function to call it with. */
366 if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT)
367 error (_("Can't do that binary op on that type")); /* FIXME be explicit */
369 argvec = (struct value **) alloca (sizeof (struct value *) * 4);
370 argvec[1] = value_addr (arg1);
374 /* make the right function name up */
375 strcpy (tstr, "operator__");
400 case BINOP_BITWISE_AND:
403 case BINOP_BITWISE_IOR:
406 case BINOP_BITWISE_XOR:
409 case BINOP_LOGICAL_AND:
412 case BINOP_LOGICAL_OR:
424 case BINOP_ASSIGN_MODIFY:
442 case BINOP_BITWISE_AND:
445 case BINOP_BITWISE_IOR:
448 case BINOP_BITWISE_XOR:
451 case BINOP_MOD: /* invalid */
453 error (_("Invalid binary operation specified."));
456 case BINOP_SUBSCRIPT:
477 case BINOP_MOD: /* invalid */
479 error (_("Invalid binary operation specified."));
482 argvec[0] = value_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure");
488 argvec[1] = argvec[0];
491 if (noside == EVAL_AVOID_SIDE_EFFECTS)
493 struct type *return_type;
495 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
496 return value_zero (return_type, VALUE_LVAL (arg1));
498 return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
500 error (_("member function %s not found"), tstr);
502 return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
506 /* We know that arg1 is a structure, so try to find a unary user
507 defined operator that matches the operator in question.
508 Create an argument vector that calls arg1.operator @ (arg1)
509 and return that value (where '@' is (almost) any unary operator which
510 is legal for GNU C++). */
513 value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
515 struct value **argvec;
516 char *ptr, *mangle_ptr;
517 char tstr[13], mangle_tstr[13];
518 int static_memfuncp, nargs;
520 arg1 = coerce_ref (arg1);
522 /* now we know that what we have to do is construct our
523 arg vector and find the right function to call it with. */
525 if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT)
526 error (_("Can't do that unary op on that type")); /* FIXME be explicit */
528 argvec = (struct value **) alloca (sizeof (struct value *) * 4);
529 argvec[1] = value_addr (arg1);
534 /* make the right function name up */
535 strcpy (tstr, "operator__");
537 strcpy (mangle_tstr, "__");
538 mangle_ptr = mangle_tstr + 2;
541 case UNOP_PREINCREMENT:
544 case UNOP_PREDECREMENT:
547 case UNOP_POSTINCREMENT:
549 argvec[2] = value_from_longest (builtin_type_int8, 0);
553 case UNOP_POSTDECREMENT:
555 argvec[2] = value_from_longest (builtin_type_int8, 0);
559 case UNOP_LOGICAL_NOT:
562 case UNOP_COMPLEMENT:
575 error (_("Invalid unary operation specified."));
578 argvec[0] = value_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure");
584 argvec[1] = argvec[0];
588 if (noside == EVAL_AVOID_SIDE_EFFECTS)
590 struct type *return_type;
592 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
593 return value_zero (return_type, VALUE_LVAL (arg1));
595 return call_function_by_hand (argvec[0], nargs, argvec + 1);
597 error (_("member function %s not found"), tstr);
598 return 0; /* For lint -- never reached */
602 /* Concatenate two values with the following conditions:
604 (1) Both values must be either bitstring values or character string
605 values and the resulting value consists of the concatenation of
606 ARG1 followed by ARG2.
610 One value must be an integer value and the other value must be
611 either a bitstring value or character string value, which is
612 to be repeated by the number of times specified by the integer
616 (2) Boolean values are also allowed and are treated as bit string
619 (3) Character values are also allowed and are treated as character
620 string values of length 1.
624 value_concat (struct value *arg1, struct value *arg2)
626 struct value *inval1;
627 struct value *inval2;
628 struct value *outval = NULL;
629 int inval1len, inval2len;
633 struct type *type1 = check_typedef (value_type (arg1));
634 struct type *type2 = check_typedef (value_type (arg2));
636 /* First figure out if we are dealing with two values to be concatenated
637 or a repeat count and a value to be repeated. INVAL1 is set to the
638 first of two concatenated values, or the repeat count. INVAL2 is set
639 to the second of the two concatenated values or the value to be
642 if (TYPE_CODE (type2) == TYPE_CODE_INT)
644 struct type *tmp = type1;
656 /* Now process the input values. */
658 if (TYPE_CODE (type1) == TYPE_CODE_INT)
660 /* We have a repeat count. Validate the second value and then
661 construct a value repeated that many times. */
662 if (TYPE_CODE (type2) == TYPE_CODE_STRING
663 || TYPE_CODE (type2) == TYPE_CODE_CHAR)
665 count = longest_to_int (value_as_long (inval1));
666 inval2len = TYPE_LENGTH (type2);
667 ptr = (char *) alloca (count * inval2len);
668 if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
670 inchar = (char) unpack_long (type2,
671 value_contents (inval2));
672 for (idx = 0; idx < count; idx++)
674 *(ptr + idx) = inchar;
679 for (idx = 0; idx < count; idx++)
681 memcpy (ptr + (idx * inval2len), value_contents (inval2),
685 outval = value_string (ptr, count * inval2len);
687 else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING
688 || TYPE_CODE (type2) == TYPE_CODE_BOOL)
690 error (_("unimplemented support for bitstring/boolean repeats"));
694 error (_("can't repeat values of that type"));
697 else if (TYPE_CODE (type1) == TYPE_CODE_STRING
698 || TYPE_CODE (type1) == TYPE_CODE_CHAR)
700 /* We have two character strings to concatenate. */
701 if (TYPE_CODE (type2) != TYPE_CODE_STRING
702 && TYPE_CODE (type2) != TYPE_CODE_CHAR)
704 error (_("Strings can only be concatenated with other strings."));
706 inval1len = TYPE_LENGTH (type1);
707 inval2len = TYPE_LENGTH (type2);
708 ptr = (char *) alloca (inval1len + inval2len);
709 if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
711 *ptr = (char) unpack_long (type1, value_contents (inval1));
715 memcpy (ptr, value_contents (inval1), inval1len);
717 if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
720 (char) unpack_long (type2, value_contents (inval2));
724 memcpy (ptr + inval1len, value_contents (inval2), inval2len);
726 outval = value_string (ptr, inval1len + inval2len);
728 else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING
729 || TYPE_CODE (type1) == TYPE_CODE_BOOL)
731 /* We have two bitstrings to concatenate. */
732 if (TYPE_CODE (type2) != TYPE_CODE_BITSTRING
733 && TYPE_CODE (type2) != TYPE_CODE_BOOL)
735 error (_("Bitstrings or booleans can only be concatenated with other bitstrings or booleans."));
737 error (_("unimplemented support for bitstring/boolean concatenation."));
741 /* We don't know how to concatenate these operands. */
742 error (_("illegal operands for concatenation."));
747 /* Integer exponentiation: V1**V2, where both arguments are
748 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
750 integer_pow (LONGEST v1, LONGEST v2)
755 error (_("Attempt to raise 0 to negative power."));
761 /* The Russian Peasant's Algorithm */
777 /* Integer exponentiation: V1**V2, where both arguments are
778 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
780 uinteger_pow (ULONGEST v1, LONGEST v2)
785 error (_("Attempt to raise 0 to negative power."));
791 /* The Russian Peasant's Algorithm */
807 /* Obtain decimal value of arguments for binary operation, converting from
808 other types if one of them is not decimal floating point. */
810 value_args_as_decimal (struct value *arg1, struct value *arg2,
811 gdb_byte *x, int *len_x, gdb_byte *y, int *len_y)
813 struct type *type1, *type2;
815 type1 = check_typedef (value_type (arg1));
816 type2 = check_typedef (value_type (arg2));
818 /* At least one of the arguments must be of decimal float type. */
819 gdb_assert (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
820 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT);
822 if (TYPE_CODE (type1) == TYPE_CODE_FLT
823 || TYPE_CODE (type2) == TYPE_CODE_FLT)
824 /* The DFP extension to the C language does not allow mixing of
825 * decimal float types with other float types in expressions
826 * (see WDTR 24732, page 12). */
827 error (_("Mixing decimal floating types with other floating types is not allowed."));
829 /* Obtain decimal value of arg1, converting from other types
832 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
834 *len_x = TYPE_LENGTH (type1);
835 memcpy (x, value_contents (arg1), *len_x);
837 else if (is_integral_type (type1))
839 *len_x = TYPE_LENGTH (type2);
840 decimal_from_integral (arg1, x, *len_x);
843 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1),
846 /* Obtain decimal value of arg2, converting from other types
849 if (TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
851 *len_y = TYPE_LENGTH (type2);
852 memcpy (y, value_contents (arg2), *len_y);
854 else if (is_integral_type (type2))
856 *len_y = TYPE_LENGTH (type1);
857 decimal_from_integral (arg2, y, *len_y);
860 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1),
864 /* Perform a binary operation on two operands which have reasonable
865 representations as integers or floats. This includes booleans,
866 characters, integers, or floats.
867 Does not support addition and subtraction on pointers;
868 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
871 value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
874 struct type *type1, *type2, *result_type;
876 arg1 = coerce_ref (arg1);
877 arg2 = coerce_ref (arg2);
879 type1 = check_typedef (value_type (arg1));
880 type2 = check_typedef (value_type (arg2));
882 if ((TYPE_CODE (type1) != TYPE_CODE_FLT
883 && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
884 && !is_integral_type (type1))
885 || (TYPE_CODE (type2) != TYPE_CODE_FLT
886 && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
887 && !is_integral_type (type2)))
888 error (_("Argument to arithmetic operation not a number or boolean."));
890 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
891 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
894 int len_v1, len_v2, len_v;
895 gdb_byte v1[16], v2[16];
898 value_args_as_decimal (arg1, arg2, v1, &len_v1, v2, &len_v2);
907 decimal_binop (op, v1, len_v1, v2, len_v2, v, &len_v);
911 error (_("Operation not valid for decimal floating point number."));
914 /* If only one type is decimal float, use its type.
915 Otherwise use the bigger type. */
916 if (TYPE_CODE (type1) != TYPE_CODE_DECFLOAT)
918 else if (TYPE_CODE (type2) != TYPE_CODE_DECFLOAT)
920 else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
925 val = value_from_decfloat (result_type, v);
927 else if (TYPE_CODE (type1) == TYPE_CODE_FLT
928 || TYPE_CODE (type2) == TYPE_CODE_FLT)
930 /* FIXME-if-picky-about-floating-accuracy: Should be doing this
931 in target format. real.c in GCC probably has the necessary
933 DOUBLEST v1, v2, v = 0;
934 v1 = value_as_double (arg1);
935 v2 = value_as_double (arg2);
959 error (_("Cannot perform exponentiation: %s"), safe_strerror (errno));
963 v = v1 < v2 ? v1 : v2;
967 v = v1 > v2 ? v1 : v2;
971 error (_("Integer-only operation on floating point number."));
974 /* If only one type is float, use its type.
975 Otherwise use the bigger type. */
976 if (TYPE_CODE (type1) != TYPE_CODE_FLT)
978 else if (TYPE_CODE (type2) != TYPE_CODE_FLT)
980 else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
985 val = allocate_value (result_type);
986 store_typed_floating (value_contents_raw (val), value_type (val), v);
988 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
989 || TYPE_CODE (type2) == TYPE_CODE_BOOL)
991 LONGEST v1, v2, v = 0;
992 v1 = value_as_long (arg1);
993 v2 = value_as_long (arg2);
997 case BINOP_BITWISE_AND:
1001 case BINOP_BITWISE_IOR:
1005 case BINOP_BITWISE_XOR:
1013 case BINOP_NOTEQUAL:
1018 error (_("Invalid operation on booleans."));
1021 result_type = type1;
1023 val = allocate_value (result_type);
1024 store_signed_integer (value_contents_raw (val),
1025 TYPE_LENGTH (result_type),
1029 /* Integral operations here. */
1031 /* Determine type length of the result, and if the operation should
1032 be done unsigned. For exponentiation and shift operators,
1033 use the length and type of the left operand. Otherwise,
1034 use the signedness of the operand with the greater length.
1035 If both operands are of equal length, use unsigned operation
1036 if one of the operands is unsigned. */
1037 if (op == BINOP_RSH || op == BINOP_LSH || op == BINOP_EXP)
1038 result_type = type1;
1039 else if (TYPE_LENGTH (type1) > TYPE_LENGTH (type2))
1040 result_type = type1;
1041 else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
1042 result_type = type2;
1043 else if (TYPE_UNSIGNED (type1))
1044 result_type = type1;
1045 else if (TYPE_UNSIGNED (type2))
1046 result_type = type2;
1048 result_type = type1;
1050 if (TYPE_UNSIGNED (result_type))
1052 LONGEST v2_signed = value_as_long (arg2);
1053 ULONGEST v1, v2, v = 0;
1054 v1 = (ULONGEST) value_as_long (arg1);
1055 v2 = (ULONGEST) v2_signed;
1076 error (_("Division by zero"));
1080 v = uinteger_pow (v1, v2_signed);
1087 error (_("Division by zero"));
1091 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1092 v1 mod 0 has a defined value, v1. */
1100 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1113 case BINOP_BITWISE_AND:
1117 case BINOP_BITWISE_IOR:
1121 case BINOP_BITWISE_XOR:
1125 case BINOP_LOGICAL_AND:
1129 case BINOP_LOGICAL_OR:
1134 v = v1 < v2 ? v1 : v2;
1138 v = v1 > v2 ? v1 : v2;
1145 case BINOP_NOTEQUAL:
1154 error (_("Invalid binary operation on numbers."));
1157 val = allocate_value (result_type);
1158 store_unsigned_integer (value_contents_raw (val),
1159 TYPE_LENGTH (value_type (val)),
1164 LONGEST v1, v2, v = 0;
1165 v1 = value_as_long (arg1);
1166 v2 = value_as_long (arg2);
1187 error (_("Division by zero"));
1191 v = integer_pow (v1, v2);
1198 error (_("Division by zero"));
1202 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1203 X mod 0 has a defined value, X. */
1211 /* Compute floor. */
1212 if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0))
1228 case BINOP_BITWISE_AND:
1232 case BINOP_BITWISE_IOR:
1236 case BINOP_BITWISE_XOR:
1240 case BINOP_LOGICAL_AND:
1244 case BINOP_LOGICAL_OR:
1249 v = v1 < v2 ? v1 : v2;
1253 v = v1 > v2 ? v1 : v2;
1265 error (_("Invalid binary operation on numbers."));
1268 val = allocate_value (result_type);
1269 store_signed_integer (value_contents_raw (val),
1270 TYPE_LENGTH (value_type (val)),
1278 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1281 value_logical_not (struct value *arg1)
1287 arg1 = coerce_array (arg1);
1288 type1 = check_typedef (value_type (arg1));
1290 if (TYPE_CODE (type1) == TYPE_CODE_FLT)
1291 return 0 == value_as_double (arg1);
1292 else if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
1293 return decimal_is_zero (value_contents (arg1), TYPE_LENGTH (type1));
1295 len = TYPE_LENGTH (type1);
1296 p = value_contents (arg1);
1307 /* Perform a comparison on two string values (whose content are not
1308 necessarily null terminated) based on their length */
1311 value_strcmp (struct value *arg1, struct value *arg2)
1313 int len1 = TYPE_LENGTH (value_type (arg1));
1314 int len2 = TYPE_LENGTH (value_type (arg2));
1315 const gdb_byte *s1 = value_contents (arg1);
1316 const gdb_byte *s2 = value_contents (arg2);
1317 int i, len = len1 < len2 ? len1 : len2;
1319 for (i = 0; i < len; i++)
1323 else if (s1[i] > s2[i])
1331 else if (len1 > len2)
1337 /* Simulate the C operator == by returning a 1
1338 iff ARG1 and ARG2 have equal contents. */
1341 value_equal (struct value *arg1, struct value *arg2)
1346 struct type *type1, *type2;
1347 enum type_code code1;
1348 enum type_code code2;
1349 int is_int1, is_int2;
1351 arg1 = coerce_array (arg1);
1352 arg2 = coerce_array (arg2);
1354 type1 = check_typedef (value_type (arg1));
1355 type2 = check_typedef (value_type (arg2));
1356 code1 = TYPE_CODE (type1);
1357 code2 = TYPE_CODE (type2);
1358 is_int1 = is_integral_type (type1);
1359 is_int2 = is_integral_type (type2);
1361 if (is_int1 && is_int2)
1362 return longest_to_int (value_as_long (value_binop (arg1, arg2,
1364 else if ((code1 == TYPE_CODE_FLT || is_int1)
1365 && (code2 == TYPE_CODE_FLT || is_int2))
1367 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1368 `long double' values are returned in static storage (m68k). */
1369 DOUBLEST d = value_as_double (arg1);
1370 return d == value_as_double (arg2);
1372 else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
1373 && (code2 == TYPE_CODE_DECFLOAT || is_int2))
1375 gdb_byte v1[16], v2[16];
1378 value_args_as_decimal (arg1, arg2, v1, &len_v1, v2, &len_v2);
1380 return decimal_compare (v1, len_v1, v2, len_v2) == 0;
1383 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1385 else if (code1 == TYPE_CODE_PTR && is_int2)
1386 return value_as_address (arg1) == (CORE_ADDR) value_as_long (arg2);
1387 else if (code2 == TYPE_CODE_PTR && is_int1)
1388 return (CORE_ADDR) value_as_long (arg1) == value_as_address (arg2);
1390 else if (code1 == code2
1391 && ((len = (int) TYPE_LENGTH (type1))
1392 == (int) TYPE_LENGTH (type2)))
1394 p1 = value_contents (arg1);
1395 p2 = value_contents (arg2);
1403 else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1405 return value_strcmp (arg1, arg2) == 0;
1409 error (_("Invalid type combination in equality test."));
1410 return 0; /* For lint -- never reached */
1414 /* Simulate the C operator < by returning 1
1415 iff ARG1's contents are less than ARG2's. */
1418 value_less (struct value *arg1, struct value *arg2)
1420 enum type_code code1;
1421 enum type_code code2;
1422 struct type *type1, *type2;
1423 int is_int1, is_int2;
1425 arg1 = coerce_array (arg1);
1426 arg2 = coerce_array (arg2);
1428 type1 = check_typedef (value_type (arg1));
1429 type2 = check_typedef (value_type (arg2));
1430 code1 = TYPE_CODE (type1);
1431 code2 = TYPE_CODE (type2);
1432 is_int1 = is_integral_type (type1);
1433 is_int2 = is_integral_type (type2);
1435 if (is_int1 && is_int2)
1436 return longest_to_int (value_as_long (value_binop (arg1, arg2,
1438 else if ((code1 == TYPE_CODE_FLT || is_int1)
1439 && (code2 == TYPE_CODE_FLT || is_int2))
1441 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1442 `long double' values are returned in static storage (m68k). */
1443 DOUBLEST d = value_as_double (arg1);
1444 return d < value_as_double (arg2);
1446 else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
1447 && (code2 == TYPE_CODE_DECFLOAT || is_int2))
1449 gdb_byte v1[16], v2[16];
1452 value_args_as_decimal (arg1, arg2, v1, &len_v1, v2, &len_v2);
1454 return decimal_compare (v1, len_v1, v2, len_v2) == -1;
1456 else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
1457 return value_as_address (arg1) < value_as_address (arg2);
1459 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1461 else if (code1 == TYPE_CODE_PTR && is_int2)
1462 return value_as_address (arg1) < (CORE_ADDR) value_as_long (arg2);
1463 else if (code2 == TYPE_CODE_PTR && is_int1)
1464 return (CORE_ADDR) value_as_long (arg1) < value_as_address (arg2);
1465 else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1466 return value_strcmp (arg1, arg2) < 0;
1469 error (_("Invalid type combination in ordering comparison."));
1474 /* The unary operators +, - and ~. They free the argument ARG1. */
1477 value_pos (struct value *arg1)
1481 arg1 = coerce_ref (arg1);
1482 type = check_typedef (value_type (arg1));
1484 if (TYPE_CODE (type) == TYPE_CODE_FLT)
1485 return value_from_double (type, value_as_double (arg1));
1486 else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1487 return value_from_decfloat (type, value_contents (arg1));
1488 else if (is_integral_type (type))
1490 return value_from_longest (type, value_as_long (arg1));
1494 error ("Argument to positive operation not a number.");
1495 return 0; /* For lint -- never reached */
1500 value_neg (struct value *arg1)
1504 arg1 = coerce_ref (arg1);
1505 type = check_typedef (value_type (arg1));
1507 if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1509 struct value *val = allocate_value (type);
1510 int len = TYPE_LENGTH (type);
1511 gdb_byte decbytes[16]; /* a decfloat is at most 128 bits long */
1513 memcpy (decbytes, value_contents (arg1), len);
1515 if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
1516 decbytes[len-1] = decbytes[len - 1] | 0x80;
1518 decbytes[0] = decbytes[0] | 0x80;
1520 memcpy (value_contents_raw (val), decbytes, len);
1523 else if (TYPE_CODE (type) == TYPE_CODE_FLT)
1524 return value_from_double (type, -value_as_double (arg1));
1525 else if (is_integral_type (type))
1527 return value_from_longest (type, -value_as_long (arg1));
1531 error (_("Argument to negate operation not a number."));
1532 return 0; /* For lint -- never reached */
1537 value_complement (struct value *arg1)
1541 arg1 = coerce_ref (arg1);
1542 type = check_typedef (value_type (arg1));
1544 if (!is_integral_type (type))
1545 error (_("Argument to complement operation not an integer or boolean."));
1547 return value_from_longest (type, ~value_as_long (arg1));
1550 /* The INDEX'th bit of SET value whose value_type is TYPE,
1551 and whose value_contents is valaddr.
1552 Return -1 if out of range, -2 other error. */
1555 value_bit_index (struct type *type, const gdb_byte *valaddr, int index)
1557 LONGEST low_bound, high_bound;
1560 struct type *range = TYPE_FIELD_TYPE (type, 0);
1561 if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
1563 if (index < low_bound || index > high_bound)
1565 rel_index = index - low_bound;
1566 word = extract_unsigned_integer (valaddr + (rel_index / TARGET_CHAR_BIT), 1);
1567 rel_index %= TARGET_CHAR_BIT;
1568 if (gdbarch_bits_big_endian (current_gdbarch))
1569 rel_index = TARGET_CHAR_BIT - 1 - rel_index;
1570 return (word >> rel_index) & 1;
1574 value_in (struct value *element, struct value *set)
1577 struct type *settype = check_typedef (value_type (set));
1578 struct type *eltype = check_typedef (value_type (element));
1579 if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
1580 eltype = TYPE_TARGET_TYPE (eltype);
1581 if (TYPE_CODE (settype) != TYPE_CODE_SET)
1582 error (_("Second argument of 'IN' has wrong type"));
1583 if (TYPE_CODE (eltype) != TYPE_CODE_INT
1584 && TYPE_CODE (eltype) != TYPE_CODE_CHAR
1585 && TYPE_CODE (eltype) != TYPE_CODE_ENUM
1586 && TYPE_CODE (eltype) != TYPE_CODE_BOOL)
1587 error (_("First argument of 'IN' has wrong type"));
1588 member = value_bit_index (settype, value_contents (set),
1589 value_as_long (element));
1591 error (_("First argument of 'IN' not in range"));
1596 _initialize_valarith (void)