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, 2009
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 set_value_component_location (v
, array
);
237 VALUE_REGNUM (v
) = VALUE_REGNUM (array
);
238 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (array
);
239 set_value_offset (v
, value_offset (array
) + elt_offs
);
243 /* Return the value of BITSTRING[IDX] as (boolean) type TYPE. */
246 value_bitstring_subscript (struct type
*type
,
247 struct value
*bitstring
, struct value
*idx
)
250 struct type
*bitstring_type
, *range_type
;
251 LONGEST index
= value_as_long (idx
);
253 int offset
, byte
, bit_index
;
254 LONGEST lowerbound
, upperbound
;
256 bitstring_type
= check_typedef (value_type (bitstring
));
257 gdb_assert (TYPE_CODE (bitstring_type
) == TYPE_CODE_BITSTRING
);
259 range_type
= TYPE_INDEX_TYPE (bitstring_type
);
260 get_discrete_bounds (range_type
, &lowerbound
, &upperbound
);
261 if (index
< lowerbound
|| index
> upperbound
)
262 error (_("bitstring index out of range"));
265 offset
= index
/ TARGET_CHAR_BIT
;
266 byte
= *((char *) value_contents (bitstring
) + offset
);
268 bit_index
= index
% TARGET_CHAR_BIT
;
269 byte
>>= (gdbarch_bits_big_endian (current_gdbarch
) ?
270 TARGET_CHAR_BIT
- 1 - bit_index
: bit_index
);
272 v
= value_from_longest (type
, byte
& 1);
274 set_value_bitpos (v
, bit_index
);
275 set_value_bitsize (v
, 1);
276 set_value_component_location (v
, bitstring
);
277 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (bitstring
);
279 set_value_offset (v
, offset
+ value_offset (bitstring
));
285 /* Check to see if either argument is a structure, or a reference to
286 one. This is called so we know whether to go ahead with the normal
287 binop or look for a user defined function instead.
289 For now, we do not overload the `=' operator. */
292 binop_user_defined_p (enum exp_opcode op
, struct value
*arg1
, struct value
*arg2
)
294 struct type
*type1
, *type2
;
295 if (op
== BINOP_ASSIGN
|| op
== BINOP_CONCAT
)
298 type1
= check_typedef (value_type (arg1
));
299 if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
300 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
302 type2
= check_typedef (value_type (arg2
));
303 if (TYPE_CODE (type2
) == TYPE_CODE_REF
)
304 type2
= check_typedef (TYPE_TARGET_TYPE (type2
));
306 return (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
307 || TYPE_CODE (type2
) == TYPE_CODE_STRUCT
);
310 /* Check to see if argument is a structure. This is called so
311 we know whether to go ahead with the normal unop or look for a
312 user defined function instead.
314 For now, we do not overload the `&' operator. */
317 unop_user_defined_p (enum exp_opcode op
, struct value
*arg1
)
322 type1
= check_typedef (value_type (arg1
));
325 if (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
)
327 else if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
328 type1
= TYPE_TARGET_TYPE (type1
);
334 /* We know either arg1 or arg2 is a structure, so try to find the right
335 user defined function. Create an argument vector that calls
336 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
337 binary operator which is legal for GNU C++).
339 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
340 is the opcode saying how to modify it. Otherwise, OTHEROP is
344 value_x_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
,
345 enum exp_opcode otherop
, enum noside noside
)
347 struct value
**argvec
;
352 arg1
= coerce_ref (arg1
);
353 arg2
= coerce_ref (arg2
);
355 /* now we know that what we have to do is construct our
356 arg vector and find the right function to call it with. */
358 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
359 error (_("Can't do that binary op on that type")); /* FIXME be explicit */
361 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
362 argvec
[1] = value_addr (arg1
);
366 /* make the right function name up */
367 strcpy (tstr
, "operator__");
392 case BINOP_BITWISE_AND
:
395 case BINOP_BITWISE_IOR
:
398 case BINOP_BITWISE_XOR
:
401 case BINOP_LOGICAL_AND
:
404 case BINOP_LOGICAL_OR
:
416 case BINOP_ASSIGN_MODIFY
:
434 case BINOP_BITWISE_AND
:
437 case BINOP_BITWISE_IOR
:
440 case BINOP_BITWISE_XOR
:
443 case BINOP_MOD
: /* invalid */
445 error (_("Invalid binary operation specified."));
448 case BINOP_SUBSCRIPT
:
469 case BINOP_MOD
: /* invalid */
471 error (_("Invalid binary operation specified."));
474 argvec
[0] = value_struct_elt (&arg1
, argvec
+ 1, tstr
, &static_memfuncp
, "structure");
480 argvec
[1] = argvec
[0];
483 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
485 struct type
*return_type
;
487 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
488 return value_zero (return_type
, VALUE_LVAL (arg1
));
490 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
492 error (_("member function %s not found"), tstr
);
494 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
498 /* We know that arg1 is a structure, so try to find a unary user
499 defined operator that matches the operator in question.
500 Create an argument vector that calls arg1.operator @ (arg1)
501 and return that value (where '@' is (almost) any unary operator which
502 is legal for GNU C++). */
505 value_x_unop (struct value
*arg1
, enum exp_opcode op
, enum noside noside
)
507 struct value
**argvec
;
508 char *ptr
, *mangle_ptr
;
509 char tstr
[13], mangle_tstr
[13];
510 int static_memfuncp
, nargs
;
512 arg1
= coerce_ref (arg1
);
514 /* now we know that what we have to do is construct our
515 arg vector and find the right function to call it with. */
517 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
518 error (_("Can't do that unary op on that type")); /* FIXME be explicit */
520 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
521 argvec
[1] = value_addr (arg1
);
526 /* make the right function name up */
527 strcpy (tstr
, "operator__");
529 strcpy (mangle_tstr
, "__");
530 mangle_ptr
= mangle_tstr
+ 2;
533 case UNOP_PREINCREMENT
:
536 case UNOP_PREDECREMENT
:
539 case UNOP_POSTINCREMENT
:
541 argvec
[2] = value_from_longest (builtin_type_int8
, 0);
545 case UNOP_POSTDECREMENT
:
547 argvec
[2] = value_from_longest (builtin_type_int8
, 0);
551 case UNOP_LOGICAL_NOT
:
554 case UNOP_COMPLEMENT
:
567 error (_("Invalid unary operation specified."));
570 argvec
[0] = value_struct_elt (&arg1
, argvec
+ 1, tstr
, &static_memfuncp
, "structure");
576 argvec
[1] = argvec
[0];
580 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
582 struct type
*return_type
;
584 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
585 return value_zero (return_type
, VALUE_LVAL (arg1
));
587 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
589 error (_("member function %s not found"), tstr
);
590 return 0; /* For lint -- never reached */
594 /* Concatenate two values with the following conditions:
596 (1) Both values must be either bitstring values or character string
597 values and the resulting value consists of the concatenation of
598 ARG1 followed by ARG2.
602 One value must be an integer value and the other value must be
603 either a bitstring value or character string value, which is
604 to be repeated by the number of times specified by the integer
608 (2) Boolean values are also allowed and are treated as bit string
611 (3) Character values are also allowed and are treated as character
612 string values of length 1.
616 value_concat (struct value
*arg1
, struct value
*arg2
)
618 struct value
*inval1
;
619 struct value
*inval2
;
620 struct value
*outval
= NULL
;
621 int inval1len
, inval2len
;
625 struct type
*type1
= check_typedef (value_type (arg1
));
626 struct type
*type2
= check_typedef (value_type (arg2
));
628 /* First figure out if we are dealing with two values to be concatenated
629 or a repeat count and a value to be repeated. INVAL1 is set to the
630 first of two concatenated values, or the repeat count. INVAL2 is set
631 to the second of the two concatenated values or the value to be
634 if (TYPE_CODE (type2
) == TYPE_CODE_INT
)
636 struct type
*tmp
= type1
;
648 /* Now process the input values. */
650 if (TYPE_CODE (type1
) == TYPE_CODE_INT
)
652 /* We have a repeat count. Validate the second value and then
653 construct a value repeated that many times. */
654 if (TYPE_CODE (type2
) == TYPE_CODE_STRING
655 || TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
657 count
= longest_to_int (value_as_long (inval1
));
658 inval2len
= TYPE_LENGTH (type2
);
659 ptr
= (char *) alloca (count
* inval2len
);
660 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
662 inchar
= (char) unpack_long (type2
,
663 value_contents (inval2
));
664 for (idx
= 0; idx
< count
; idx
++)
666 *(ptr
+ idx
) = inchar
;
671 for (idx
= 0; idx
< count
; idx
++)
673 memcpy (ptr
+ (idx
* inval2len
), value_contents (inval2
),
677 outval
= value_string (ptr
, count
* inval2len
);
679 else if (TYPE_CODE (type2
) == TYPE_CODE_BITSTRING
680 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
682 error (_("unimplemented support for bitstring/boolean repeats"));
686 error (_("can't repeat values of that type"));
689 else if (TYPE_CODE (type1
) == TYPE_CODE_STRING
690 || TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
692 /* We have two character strings to concatenate. */
693 if (TYPE_CODE (type2
) != TYPE_CODE_STRING
694 && TYPE_CODE (type2
) != TYPE_CODE_CHAR
)
696 error (_("Strings can only be concatenated with other strings."));
698 inval1len
= TYPE_LENGTH (type1
);
699 inval2len
= TYPE_LENGTH (type2
);
700 ptr
= (char *) alloca (inval1len
+ inval2len
);
701 if (TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
703 *ptr
= (char) unpack_long (type1
, value_contents (inval1
));
707 memcpy (ptr
, value_contents (inval1
), inval1len
);
709 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
712 (char) unpack_long (type2
, value_contents (inval2
));
716 memcpy (ptr
+ inval1len
, value_contents (inval2
), inval2len
);
718 outval
= value_string (ptr
, inval1len
+ inval2len
);
720 else if (TYPE_CODE (type1
) == TYPE_CODE_BITSTRING
721 || TYPE_CODE (type1
) == TYPE_CODE_BOOL
)
723 /* We have two bitstrings to concatenate. */
724 if (TYPE_CODE (type2
) != TYPE_CODE_BITSTRING
725 && TYPE_CODE (type2
) != TYPE_CODE_BOOL
)
727 error (_("Bitstrings or booleans can only be concatenated with other bitstrings or booleans."));
729 error (_("unimplemented support for bitstring/boolean concatenation."));
733 /* We don't know how to concatenate these operands. */
734 error (_("illegal operands for concatenation."));
739 /* Integer exponentiation: V1**V2, where both arguments are
740 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
742 integer_pow (LONGEST v1
, LONGEST v2
)
747 error (_("Attempt to raise 0 to negative power."));
753 /* The Russian Peasant's Algorithm */
769 /* Integer exponentiation: V1**V2, where both arguments are
770 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
772 uinteger_pow (ULONGEST v1
, LONGEST v2
)
777 error (_("Attempt to raise 0 to negative power."));
783 /* The Russian Peasant's Algorithm */
799 /* Obtain decimal value of arguments for binary operation, converting from
800 other types if one of them is not decimal floating point. */
802 value_args_as_decimal (struct value
*arg1
, struct value
*arg2
,
803 gdb_byte
*x
, int *len_x
, gdb_byte
*y
, int *len_y
)
805 struct type
*type1
, *type2
;
807 type1
= check_typedef (value_type (arg1
));
808 type2
= check_typedef (value_type (arg2
));
810 /* At least one of the arguments must be of decimal float type. */
811 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
812 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
);
814 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
815 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
816 /* The DFP extension to the C language does not allow mixing of
817 * decimal float types with other float types in expressions
818 * (see WDTR 24732, page 12). */
819 error (_("Mixing decimal floating types with other floating types is not allowed."));
821 /* Obtain decimal value of arg1, converting from other types
824 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
826 *len_x
= TYPE_LENGTH (type1
);
827 memcpy (x
, value_contents (arg1
), *len_x
);
829 else if (is_integral_type (type1
))
831 *len_x
= TYPE_LENGTH (type2
);
832 decimal_from_integral (arg1
, x
, *len_x
);
835 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
838 /* Obtain decimal value of arg2, converting from other types
841 if (TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
843 *len_y
= TYPE_LENGTH (type2
);
844 memcpy (y
, value_contents (arg2
), *len_y
);
846 else if (is_integral_type (type2
))
848 *len_y
= TYPE_LENGTH (type1
);
849 decimal_from_integral (arg2
, y
, *len_y
);
852 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
856 /* Perform a binary operation on two operands which have reasonable
857 representations as integers or floats. This includes booleans,
858 characters, integers, or floats.
859 Does not support addition and subtraction on pointers;
860 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
863 value_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
866 struct type
*type1
, *type2
, *result_type
;
868 arg1
= coerce_ref (arg1
);
869 arg2
= coerce_ref (arg2
);
871 type1
= check_typedef (value_type (arg1
));
872 type2
= check_typedef (value_type (arg2
));
874 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
875 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
876 && !is_integral_type (type1
))
877 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
878 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
879 && !is_integral_type (type2
)))
880 error (_("Argument to arithmetic operation not a number or boolean."));
882 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
883 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
886 int len_v1
, len_v2
, len_v
;
887 gdb_byte v1
[16], v2
[16];
890 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, v2
, &len_v2
);
899 decimal_binop (op
, v1
, len_v1
, v2
, len_v2
, v
, &len_v
);
903 error (_("Operation not valid for decimal floating point number."));
906 /* If only one type is decimal float, use its type.
907 Otherwise use the bigger type. */
908 if (TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
)
910 else if (TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
)
912 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
917 val
= value_from_decfloat (result_type
, v
);
919 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
920 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
922 /* FIXME-if-picky-about-floating-accuracy: Should be doing this
923 in target format. real.c in GCC probably has the necessary
925 DOUBLEST v1
, v2
, v
= 0;
926 v1
= value_as_double (arg1
);
927 v2
= value_as_double (arg2
);
951 error (_("Cannot perform exponentiation: %s"), safe_strerror (errno
));
955 v
= v1
< v2
? v1
: v2
;
959 v
= v1
> v2
? v1
: v2
;
963 error (_("Integer-only operation on floating point number."));
966 /* If only one type is float, use its type.
967 Otherwise use the bigger type. */
968 if (TYPE_CODE (type1
) != TYPE_CODE_FLT
)
970 else if (TYPE_CODE (type2
) != TYPE_CODE_FLT
)
972 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
977 val
= allocate_value (result_type
);
978 store_typed_floating (value_contents_raw (val
), value_type (val
), v
);
980 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
981 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
983 LONGEST v1
, v2
, v
= 0;
984 v1
= value_as_long (arg1
);
985 v2
= value_as_long (arg2
);
989 case BINOP_BITWISE_AND
:
993 case BINOP_BITWISE_IOR
:
997 case BINOP_BITWISE_XOR
:
1005 case BINOP_NOTEQUAL
:
1010 error (_("Invalid operation on booleans."));
1013 result_type
= type1
;
1015 val
= allocate_value (result_type
);
1016 store_signed_integer (value_contents_raw (val
),
1017 TYPE_LENGTH (result_type
),
1021 /* Integral operations here. */
1023 /* Determine type length of the result, and if the operation should
1024 be done unsigned. For exponentiation and shift operators,
1025 use the length and type of the left operand. Otherwise,
1026 use the signedness of the operand with the greater length.
1027 If both operands are of equal length, use unsigned operation
1028 if one of the operands is unsigned. */
1029 if (op
== BINOP_RSH
|| op
== BINOP_LSH
|| op
== BINOP_EXP
)
1030 result_type
= type1
;
1031 else if (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
))
1032 result_type
= type1
;
1033 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1034 result_type
= type2
;
1035 else if (TYPE_UNSIGNED (type1
))
1036 result_type
= type1
;
1037 else if (TYPE_UNSIGNED (type2
))
1038 result_type
= type2
;
1040 result_type
= type1
;
1042 if (TYPE_UNSIGNED (result_type
))
1044 LONGEST v2_signed
= value_as_long (arg2
);
1045 ULONGEST v1
, v2
, v
= 0;
1046 v1
= (ULONGEST
) value_as_long (arg1
);
1047 v2
= (ULONGEST
) v2_signed
;
1068 error (_("Division by zero"));
1072 v
= uinteger_pow (v1
, v2_signed
);
1079 error (_("Division by zero"));
1083 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1084 v1 mod 0 has a defined value, v1. */
1092 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1105 case BINOP_BITWISE_AND
:
1109 case BINOP_BITWISE_IOR
:
1113 case BINOP_BITWISE_XOR
:
1117 case BINOP_LOGICAL_AND
:
1121 case BINOP_LOGICAL_OR
:
1126 v
= v1
< v2
? v1
: v2
;
1130 v
= v1
> v2
? v1
: v2
;
1137 case BINOP_NOTEQUAL
:
1146 error (_("Invalid binary operation on numbers."));
1149 val
= allocate_value (result_type
);
1150 store_unsigned_integer (value_contents_raw (val
),
1151 TYPE_LENGTH (value_type (val
)),
1156 LONGEST v1
, v2
, v
= 0;
1157 v1
= value_as_long (arg1
);
1158 v2
= value_as_long (arg2
);
1179 error (_("Division by zero"));
1183 v
= integer_pow (v1
, v2
);
1190 error (_("Division by zero"));
1194 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1195 X mod 0 has a defined value, X. */
1203 /* Compute floor. */
1204 if (TRUNCATION_TOWARDS_ZERO
&& (v
< 0) && ((v1
% v2
) != 0))
1220 case BINOP_BITWISE_AND
:
1224 case BINOP_BITWISE_IOR
:
1228 case BINOP_BITWISE_XOR
:
1232 case BINOP_LOGICAL_AND
:
1236 case BINOP_LOGICAL_OR
:
1241 v
= v1
< v2
? v1
: v2
;
1245 v
= v1
> v2
? v1
: v2
;
1257 error (_("Invalid binary operation on numbers."));
1260 val
= allocate_value (result_type
);
1261 store_signed_integer (value_contents_raw (val
),
1262 TYPE_LENGTH (value_type (val
)),
1270 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1273 value_logical_not (struct value
*arg1
)
1279 arg1
= coerce_array (arg1
);
1280 type1
= check_typedef (value_type (arg1
));
1282 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
)
1283 return 0 == value_as_double (arg1
);
1284 else if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
1285 return decimal_is_zero (value_contents (arg1
), TYPE_LENGTH (type1
));
1287 len
= TYPE_LENGTH (type1
);
1288 p
= value_contents (arg1
);
1299 /* Perform a comparison on two string values (whose content are not
1300 necessarily null terminated) based on their length */
1303 value_strcmp (struct value
*arg1
, struct value
*arg2
)
1305 int len1
= TYPE_LENGTH (value_type (arg1
));
1306 int len2
= TYPE_LENGTH (value_type (arg2
));
1307 const gdb_byte
*s1
= value_contents (arg1
);
1308 const gdb_byte
*s2
= value_contents (arg2
);
1309 int i
, len
= len1
< len2
? len1
: len2
;
1311 for (i
= 0; i
< len
; i
++)
1315 else if (s1
[i
] > s2
[i
])
1323 else if (len1
> len2
)
1329 /* Simulate the C operator == by returning a 1
1330 iff ARG1 and ARG2 have equal contents. */
1333 value_equal (struct value
*arg1
, struct value
*arg2
)
1338 struct type
*type1
, *type2
;
1339 enum type_code code1
;
1340 enum type_code code2
;
1341 int is_int1
, is_int2
;
1343 arg1
= coerce_array (arg1
);
1344 arg2
= coerce_array (arg2
);
1346 type1
= check_typedef (value_type (arg1
));
1347 type2
= check_typedef (value_type (arg2
));
1348 code1
= TYPE_CODE (type1
);
1349 code2
= TYPE_CODE (type2
);
1350 is_int1
= is_integral_type (type1
);
1351 is_int2
= is_integral_type (type2
);
1353 if (is_int1
&& is_int2
)
1354 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1356 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1357 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1359 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1360 `long double' values are returned in static storage (m68k). */
1361 DOUBLEST d
= value_as_double (arg1
);
1362 return d
== value_as_double (arg2
);
1364 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1365 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1367 gdb_byte v1
[16], v2
[16];
1370 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, v2
, &len_v2
);
1372 return decimal_compare (v1
, len_v1
, v2
, len_v2
) == 0;
1375 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1377 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1378 return value_as_address (arg1
) == (CORE_ADDR
) value_as_long (arg2
);
1379 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1380 return (CORE_ADDR
) value_as_long (arg1
) == value_as_address (arg2
);
1382 else if (code1
== code2
1383 && ((len
= (int) TYPE_LENGTH (type1
))
1384 == (int) TYPE_LENGTH (type2
)))
1386 p1
= value_contents (arg1
);
1387 p2
= value_contents (arg2
);
1395 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1397 return value_strcmp (arg1
, arg2
) == 0;
1401 error (_("Invalid type combination in equality test."));
1402 return 0; /* For lint -- never reached */
1406 /* Simulate the C operator < by returning 1
1407 iff ARG1's contents are less than ARG2's. */
1410 value_less (struct value
*arg1
, struct value
*arg2
)
1412 enum type_code code1
;
1413 enum type_code code2
;
1414 struct type
*type1
, *type2
;
1415 int is_int1
, is_int2
;
1417 arg1
= coerce_array (arg1
);
1418 arg2
= coerce_array (arg2
);
1420 type1
= check_typedef (value_type (arg1
));
1421 type2
= check_typedef (value_type (arg2
));
1422 code1
= TYPE_CODE (type1
);
1423 code2
= TYPE_CODE (type2
);
1424 is_int1
= is_integral_type (type1
);
1425 is_int2
= is_integral_type (type2
);
1427 if (is_int1
&& is_int2
)
1428 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1430 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1431 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1433 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1434 `long double' values are returned in static storage (m68k). */
1435 DOUBLEST d
= value_as_double (arg1
);
1436 return d
< value_as_double (arg2
);
1438 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1439 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1441 gdb_byte v1
[16], v2
[16];
1444 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, v2
, &len_v2
);
1446 return decimal_compare (v1
, len_v1
, v2
, len_v2
) == -1;
1448 else if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
1449 return value_as_address (arg1
) < value_as_address (arg2
);
1451 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1453 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1454 return value_as_address (arg1
) < (CORE_ADDR
) value_as_long (arg2
);
1455 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1456 return (CORE_ADDR
) value_as_long (arg1
) < value_as_address (arg2
);
1457 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1458 return value_strcmp (arg1
, arg2
) < 0;
1461 error (_("Invalid type combination in ordering comparison."));
1466 /* The unary operators +, - and ~. They free the argument ARG1. */
1469 value_pos (struct value
*arg1
)
1473 arg1
= coerce_ref (arg1
);
1474 type
= check_typedef (value_type (arg1
));
1476 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1477 return value_from_double (type
, value_as_double (arg1
));
1478 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1479 return value_from_decfloat (type
, value_contents (arg1
));
1480 else if (is_integral_type (type
))
1482 return value_from_longest (type
, value_as_long (arg1
));
1486 error ("Argument to positive operation not a number.");
1487 return 0; /* For lint -- never reached */
1492 value_neg (struct value
*arg1
)
1496 arg1
= coerce_ref (arg1
);
1497 type
= check_typedef (value_type (arg1
));
1499 if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1501 struct value
*val
= allocate_value (type
);
1502 int len
= TYPE_LENGTH (type
);
1503 gdb_byte decbytes
[16]; /* a decfloat is at most 128 bits long */
1505 memcpy (decbytes
, value_contents (arg1
), len
);
1507 if (gdbarch_byte_order (current_gdbarch
) == BFD_ENDIAN_LITTLE
)
1508 decbytes
[len
-1] = decbytes
[len
- 1] | 0x80;
1510 decbytes
[0] = decbytes
[0] | 0x80;
1512 memcpy (value_contents_raw (val
), decbytes
, len
);
1515 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1516 return value_from_double (type
, -value_as_double (arg1
));
1517 else if (is_integral_type (type
))
1519 return value_from_longest (type
, -value_as_long (arg1
));
1523 error (_("Argument to negate operation not a number."));
1524 return 0; /* For lint -- never reached */
1529 value_complement (struct value
*arg1
)
1533 arg1
= coerce_ref (arg1
);
1534 type
= check_typedef (value_type (arg1
));
1536 if (!is_integral_type (type
))
1537 error (_("Argument to complement operation not an integer or boolean."));
1539 return value_from_longest (type
, ~value_as_long (arg1
));
1542 /* The INDEX'th bit of SET value whose value_type is TYPE,
1543 and whose value_contents is valaddr.
1544 Return -1 if out of range, -2 other error. */
1547 value_bit_index (struct type
*type
, const gdb_byte
*valaddr
, int index
)
1549 LONGEST low_bound
, high_bound
;
1552 struct type
*range
= TYPE_INDEX_TYPE (type
);
1553 if (get_discrete_bounds (range
, &low_bound
, &high_bound
) < 0)
1555 if (index
< low_bound
|| index
> high_bound
)
1557 rel_index
= index
- low_bound
;
1558 word
= extract_unsigned_integer (valaddr
+ (rel_index
/ TARGET_CHAR_BIT
), 1);
1559 rel_index
%= TARGET_CHAR_BIT
;
1560 if (gdbarch_bits_big_endian (current_gdbarch
))
1561 rel_index
= TARGET_CHAR_BIT
- 1 - rel_index
;
1562 return (word
>> rel_index
) & 1;
1566 value_in (struct value
*element
, struct value
*set
)
1569 struct type
*settype
= check_typedef (value_type (set
));
1570 struct type
*eltype
= check_typedef (value_type (element
));
1571 if (TYPE_CODE (eltype
) == TYPE_CODE_RANGE
)
1572 eltype
= TYPE_TARGET_TYPE (eltype
);
1573 if (TYPE_CODE (settype
) != TYPE_CODE_SET
)
1574 error (_("Second argument of 'IN' has wrong type"));
1575 if (TYPE_CODE (eltype
) != TYPE_CODE_INT
1576 && TYPE_CODE (eltype
) != TYPE_CODE_CHAR
1577 && TYPE_CODE (eltype
) != TYPE_CODE_ENUM
1578 && TYPE_CODE (eltype
) != TYPE_CODE_BOOL
)
1579 error (_("First argument of 'IN' has wrong type"));
1580 member
= value_bit_index (settype
, value_contents (set
),
1581 value_as_long (element
));
1583 error (_("First argument of 'IN' not in range"));
1588 _initialize_valarith (void)
This page took 0.06371 seconds and 4 git commands to generate.