1 /* Perform arithmetic and other operations on values, for GDB.
3 Copyright (C) 1986, 1988-2005, 2007-2012 Free Software Foundation,
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "expression.h"
28 #include "gdb_string.h"
33 #include "exceptions.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_ptradd. */
52 find_size_for_pointer_math (struct type
*ptr_type
)
55 struct type
*ptr_target
;
57 gdb_assert (TYPE_CODE (ptr_type
) == TYPE_CODE_PTR
);
58 ptr_target
= check_typedef (TYPE_TARGET_TYPE (ptr_type
));
60 sz
= TYPE_LENGTH (ptr_target
);
63 if (TYPE_CODE (ptr_type
) == TYPE_CODE_VOID
)
69 name
= TYPE_NAME (ptr_target
);
71 name
= TYPE_TAG_NAME (ptr_target
);
73 error (_("Cannot perform pointer math on incomplete types, "
74 "try casting to a known type, or void *."));
76 error (_("Cannot perform pointer math on incomplete type \"%s\", "
77 "try casting to a known type, or void *."), name
);
83 /* Given a pointer ARG1 and an integral value ARG2, return the
84 result of C-style pointer arithmetic ARG1 + ARG2. */
87 value_ptradd (struct value
*arg1
, LONGEST arg2
)
89 struct type
*valptrtype
;
93 arg1
= coerce_array (arg1
);
94 valptrtype
= check_typedef (value_type (arg1
));
95 sz
= find_size_for_pointer_math (valptrtype
);
97 result
= value_from_pointer (valptrtype
,
98 value_as_address (arg1
) + sz
* arg2
);
99 if (VALUE_LVAL (result
) != lval_internalvar
)
100 set_value_component_location (result
, arg1
);
104 /* Given two compatible pointer values ARG1 and ARG2, return the
105 result of C-style pointer arithmetic ARG1 - ARG2. */
108 value_ptrdiff (struct value
*arg1
, struct value
*arg2
)
110 struct type
*type1
, *type2
;
113 arg1
= coerce_array (arg1
);
114 arg2
= coerce_array (arg2
);
115 type1
= check_typedef (value_type (arg1
));
116 type2
= check_typedef (value_type (arg2
));
118 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_PTR
);
119 gdb_assert (TYPE_CODE (type2
) == TYPE_CODE_PTR
);
121 if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)))
122 != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2
))))
123 error (_("First argument of `-' is a pointer and "
124 "second argument is neither\n"
125 "an integer nor a pointer of the same type."));
127 sz
= TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)));
130 warning (_("Type size unknown, assuming 1. "
131 "Try casting to a known type, or void *."));
135 return (value_as_long (arg1
) - value_as_long (arg2
)) / sz
;
138 /* Return the value of ARRAY[IDX].
140 ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING. If the
141 current language supports C-style arrays, it may also be TYPE_CODE_PTR.
143 See comments in value_coerce_array() for rationale for reason for
144 doing lower bounds adjustment here rather than there.
145 FIXME: Perhaps we should validate that the index is valid and if
146 verbosity is set, warn about invalid indices (but still use them). */
149 value_subscript (struct value
*array
, LONGEST index
)
151 int c_style
= current_language
->c_style_arrays
;
154 array
= coerce_ref (array
);
155 tarray
= check_typedef (value_type (array
));
157 if (TYPE_CODE (tarray
) == TYPE_CODE_ARRAY
158 || TYPE_CODE (tarray
) == TYPE_CODE_STRING
)
160 struct type
*range_type
= TYPE_INDEX_TYPE (tarray
);
161 LONGEST lowerbound
, upperbound
;
163 get_discrete_bounds (range_type
, &lowerbound
, &upperbound
);
164 if (VALUE_LVAL (array
) != lval_memory
)
165 return value_subscripted_rvalue (array
, index
, lowerbound
);
169 if (index
>= lowerbound
&& index
<= upperbound
)
170 return value_subscripted_rvalue (array
, index
, lowerbound
);
171 /* Emit warning unless we have an array of unknown size.
172 An array of unknown size has lowerbound 0 and upperbound -1. */
174 warning (_("array or string index out of range"));
175 /* fall doing C stuff */
180 array
= value_coerce_array (array
);
184 return value_ind (value_ptradd (array
, index
));
186 error (_("not an array or string"));
189 /* Return the value of EXPR[IDX], expr an aggregate rvalue
190 (eg, a vector register). This routine used to promote floats
191 to doubles, but no longer does. */
194 value_subscripted_rvalue (struct value
*array
, LONGEST index
, int lowerbound
)
196 struct type
*array_type
= check_typedef (value_type (array
));
197 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (array_type
));
198 unsigned int elt_size
= TYPE_LENGTH (elt_type
);
199 unsigned int elt_offs
= elt_size
* longest_to_int (index
- lowerbound
);
202 if (index
< lowerbound
|| (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type
)
203 && elt_offs
>= TYPE_LENGTH (array_type
)))
204 error (_("no such vector element"));
206 if (VALUE_LVAL (array
) == lval_memory
&& value_lazy (array
))
207 v
= allocate_value_lazy (elt_type
);
210 v
= allocate_value (elt_type
);
211 value_contents_copy (v
, value_embedded_offset (v
),
212 array
, value_embedded_offset (array
) + elt_offs
,
216 set_value_component_location (v
, array
);
217 VALUE_REGNUM (v
) = VALUE_REGNUM (array
);
218 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (array
);
219 set_value_offset (v
, value_offset (array
) + elt_offs
);
224 /* Check to see if either argument is a structure, or a reference to
225 one. This is called so we know whether to go ahead with the normal
226 binop or look for a user defined function instead.
228 For now, we do not overload the `=' operator. */
231 binop_types_user_defined_p (enum exp_opcode op
,
232 struct type
*type1
, struct type
*type2
)
234 if (op
== BINOP_ASSIGN
|| op
== BINOP_CONCAT
)
237 type1
= check_typedef (type1
);
238 if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
239 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
241 type2
= check_typedef (type2
);
242 if (TYPE_CODE (type2
) == TYPE_CODE_REF
)
243 type2
= check_typedef (TYPE_TARGET_TYPE (type2
));
245 return (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
246 || TYPE_CODE (type2
) == TYPE_CODE_STRUCT
);
249 /* Check to see if either argument is a structure, or a reference to
250 one. This is called so we know whether to go ahead with the normal
251 binop or look for a user defined function instead.
253 For now, we do not overload the `=' operator. */
256 binop_user_defined_p (enum exp_opcode op
,
257 struct value
*arg1
, struct value
*arg2
)
259 return binop_types_user_defined_p (op
, value_type (arg1
), value_type (arg2
));
262 /* Check to see if argument is a structure. This is called so
263 we know whether to go ahead with the normal unop or look for a
264 user defined function instead.
266 For now, we do not overload the `&' operator. */
269 unop_user_defined_p (enum exp_opcode op
, struct value
*arg1
)
275 type1
= check_typedef (value_type (arg1
));
276 if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
277 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
278 return TYPE_CODE (type1
) == TYPE_CODE_STRUCT
;
281 /* Try to find an operator named OPERATOR which takes NARGS arguments
282 specified in ARGS. If the operator found is a static member operator
283 *STATIC_MEMFUNP will be set to 1, and otherwise 0.
284 The search if performed through find_overload_match which will handle
285 member operators, non member operators, operators imported implicitly or
286 explicitly, and perform correct overload resolution in all of the above
287 situations or combinations thereof. */
289 static struct value
*
290 value_user_defined_cpp_op (struct value
**args
, int nargs
, char *operator,
291 int *static_memfuncp
)
294 struct symbol
*symp
= NULL
;
295 struct value
*valp
= NULL
;
297 find_overload_match (args
, nargs
, operator, BOTH
/* could be method */,
298 0 /* strict match */, &args
[0], /* objp */
299 NULL
/* pass NULL symbol since symbol is unknown */,
300 &valp
, &symp
, static_memfuncp
, 0);
307 /* This is a non member function and does not
308 expect a reference as its first argument
309 rather the explicit structure. */
310 args
[0] = value_ind (args
[0]);
311 return value_of_variable (symp
, 0);
314 error (_("Could not find %s."), operator);
317 /* Lookup user defined operator NAME. Return a value representing the
318 function, otherwise return NULL. */
320 static struct value
*
321 value_user_defined_op (struct value
**argp
, struct value
**args
, char *name
,
322 int *static_memfuncp
, int nargs
)
324 struct value
*result
= NULL
;
326 if (current_language
->la_language
== language_cplus
)
327 result
= value_user_defined_cpp_op (args
, nargs
, name
, static_memfuncp
);
329 result
= value_struct_elt (argp
, args
, name
, static_memfuncp
,
335 /* We know either arg1 or arg2 is a structure, so try to find the right
336 user defined function. Create an argument vector that calls
337 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
338 binary operator which is legal for GNU C++).
340 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
341 is the opcode saying how to modify it. Otherwise, OTHEROP is
345 value_x_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
,
346 enum exp_opcode otherop
, enum noside noside
)
348 struct value
**argvec
;
353 arg1
= coerce_ref (arg1
);
354 arg2
= coerce_ref (arg2
);
356 /* now we know that what we have to do is construct our
357 arg vector and find the right function to call it with. */
359 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
360 error (_("Can't do that binary op on that type")); /* FIXME be explicit */
362 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
363 argvec
[1] = value_addr (arg1
);
367 /* Make the right function name up. */
368 strcpy (tstr
, "operator__");
393 case BINOP_BITWISE_AND
:
396 case BINOP_BITWISE_IOR
:
399 case BINOP_BITWISE_XOR
:
402 case BINOP_LOGICAL_AND
:
405 case BINOP_LOGICAL_OR
:
417 case BINOP_ASSIGN_MODIFY
:
435 case BINOP_BITWISE_AND
:
438 case BINOP_BITWISE_IOR
:
441 case BINOP_BITWISE_XOR
:
444 case BINOP_MOD
: /* invalid */
446 error (_("Invalid binary operation specified."));
449 case BINOP_SUBSCRIPT
:
470 case BINOP_MOD
: /* invalid */
472 error (_("Invalid binary operation specified."));
475 argvec
[0] = value_user_defined_op (&arg1
, argvec
+ 1, tstr
,
476 &static_memfuncp
, 2);
482 argvec
[1] = argvec
[0];
485 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
487 struct type
*return_type
;
490 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
491 return value_zero (return_type
, VALUE_LVAL (arg1
));
493 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
,
496 throw_error (NOT_FOUND_ERROR
,
497 _("member function %s not found"), tstr
);
499 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
503 /* We know that arg1 is a structure, so try to find a unary user
504 defined operator that matches the operator in question.
505 Create an argument vector that calls arg1.operator @ (arg1)
506 and return that value (where '@' is (almost) any unary operator which
507 is legal for GNU C++). */
510 value_x_unop (struct value
*arg1
, enum exp_opcode op
, enum noside noside
)
512 struct gdbarch
*gdbarch
= get_type_arch (value_type (arg1
));
513 struct value
**argvec
;
514 char *ptr
, *mangle_ptr
;
515 char tstr
[13], mangle_tstr
[13];
516 int static_memfuncp
, nargs
;
518 arg1
= coerce_ref (arg1
);
520 /* now we know that what we have to do is construct our
521 arg vector and find the right function to call it with. */
523 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
524 error (_("Can't do that unary op on that type")); /* FIXME be explicit */
526 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
527 argvec
[1] = value_addr (arg1
);
532 /* Make the right function name up. */
533 strcpy (tstr
, "operator__");
535 strcpy (mangle_tstr
, "__");
536 mangle_ptr
= mangle_tstr
+ 2;
539 case UNOP_PREINCREMENT
:
542 case UNOP_PREDECREMENT
:
545 case UNOP_POSTINCREMENT
:
547 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
551 case UNOP_POSTDECREMENT
:
553 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
557 case UNOP_LOGICAL_NOT
:
560 case UNOP_COMPLEMENT
:
576 error (_("Invalid unary operation specified."));
579 argvec
[0] = value_user_defined_op (&arg1
, argvec
+ 1, tstr
,
580 &static_memfuncp
, nargs
);
586 argvec
[1] = argvec
[0];
590 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
592 struct type
*return_type
;
595 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
596 return value_zero (return_type
, VALUE_LVAL (arg1
));
598 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
600 throw_error (NOT_FOUND_ERROR
,
601 _("member function %s not found"), tstr
);
603 return 0; /* For lint -- never reached */
607 /* Concatenate two values with the following conditions:
609 (1) Both values must be either bitstring values or character string
610 values and the resulting value consists of the concatenation of
611 ARG1 followed by ARG2.
615 One value must be an integer value and the other value must be
616 either a bitstring value or character string value, which is
617 to be repeated by the number of times specified by the integer
621 (2) Boolean values are also allowed and are treated as bit string
624 (3) Character values are also allowed and are treated as character
625 string values of length 1. */
628 value_concat (struct value
*arg1
, struct value
*arg2
)
630 struct value
*inval1
;
631 struct value
*inval2
;
632 struct value
*outval
= NULL
;
633 int inval1len
, inval2len
;
637 struct type
*type1
= check_typedef (value_type (arg1
));
638 struct type
*type2
= check_typedef (value_type (arg2
));
639 struct type
*char_type
;
641 /* First figure out if we are dealing with two values to be concatenated
642 or a repeat count and a value to be repeated. INVAL1 is set to the
643 first of two concatenated values, or the repeat count. INVAL2 is set
644 to the second of the two concatenated values or the value to be
647 if (TYPE_CODE (type2
) == TYPE_CODE_INT
)
649 struct type
*tmp
= type1
;
662 /* Now process the input values. */
664 if (TYPE_CODE (type1
) == TYPE_CODE_INT
)
666 /* We have a repeat count. Validate the second value and then
667 construct a value repeated that many times. */
668 if (TYPE_CODE (type2
) == TYPE_CODE_STRING
669 || TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
671 count
= longest_to_int (value_as_long (inval1
));
672 inval2len
= TYPE_LENGTH (type2
);
673 ptr
= (char *) alloca (count
* inval2len
);
674 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
678 inchar
= (char) unpack_long (type2
,
679 value_contents (inval2
));
680 for (idx
= 0; idx
< count
; idx
++)
682 *(ptr
+ idx
) = inchar
;
687 char_type
= TYPE_TARGET_TYPE (type2
);
689 for (idx
= 0; idx
< count
; idx
++)
691 memcpy (ptr
+ (idx
* inval2len
), value_contents (inval2
),
695 outval
= value_string (ptr
, count
* inval2len
, char_type
);
697 else if (TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
699 error (_("unimplemented support for boolean repeats"));
703 error (_("can't repeat values of that type"));
706 else if (TYPE_CODE (type1
) == TYPE_CODE_STRING
707 || TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
709 /* We have two character strings to concatenate. */
710 if (TYPE_CODE (type2
) != TYPE_CODE_STRING
711 && TYPE_CODE (type2
) != TYPE_CODE_CHAR
)
713 error (_("Strings can only be concatenated with other strings."));
715 inval1len
= TYPE_LENGTH (type1
);
716 inval2len
= TYPE_LENGTH (type2
);
717 ptr
= (char *) alloca (inval1len
+ inval2len
);
718 if (TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
722 *ptr
= (char) unpack_long (type1
, value_contents (inval1
));
726 char_type
= TYPE_TARGET_TYPE (type1
);
728 memcpy (ptr
, value_contents (inval1
), inval1len
);
730 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
733 (char) unpack_long (type2
, value_contents (inval2
));
737 memcpy (ptr
+ inval1len
, value_contents (inval2
), inval2len
);
739 outval
= value_string (ptr
, inval1len
+ inval2len
, char_type
);
741 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
)
743 /* We have two bitstrings to concatenate. */
744 if (TYPE_CODE (type2
) != TYPE_CODE_BOOL
)
746 error (_("Booleans can only be concatenated "
747 "with other bitstrings or booleans."));
749 error (_("unimplemented support for boolean concatenation."));
753 /* We don't know how to concatenate these operands. */
754 error (_("illegal operands for concatenation."));
759 /* Integer exponentiation: V1**V2, where both arguments are
760 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
763 integer_pow (LONGEST v1
, LONGEST v2
)
768 error (_("Attempt to raise 0 to negative power."));
774 /* The Russian Peasant's Algorithm. */
790 /* Integer exponentiation: V1**V2, where both arguments are
791 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
794 uinteger_pow (ULONGEST v1
, LONGEST v2
)
799 error (_("Attempt to raise 0 to negative power."));
805 /* The Russian Peasant's Algorithm. */
821 /* Obtain decimal value of arguments for binary operation, converting from
822 other types if one of them is not decimal floating point. */
824 value_args_as_decimal (struct value
*arg1
, struct value
*arg2
,
825 gdb_byte
*x
, int *len_x
, enum bfd_endian
*byte_order_x
,
826 gdb_byte
*y
, int *len_y
, enum bfd_endian
*byte_order_y
)
828 struct type
*type1
, *type2
;
830 type1
= check_typedef (value_type (arg1
));
831 type2
= check_typedef (value_type (arg2
));
833 /* At least one of the arguments must be of decimal float type. */
834 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
835 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
);
837 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
838 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
839 /* The DFP extension to the C language does not allow mixing of
840 * decimal float types with other float types in expressions
841 * (see WDTR 24732, page 12). */
842 error (_("Mixing decimal floating types with "
843 "other floating types is not allowed."));
845 /* Obtain decimal value of arg1, converting from other types
848 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
850 *byte_order_x
= gdbarch_byte_order (get_type_arch (type1
));
851 *len_x
= TYPE_LENGTH (type1
);
852 memcpy (x
, value_contents (arg1
), *len_x
);
854 else if (is_integral_type (type1
))
856 *byte_order_x
= gdbarch_byte_order (get_type_arch (type2
));
857 *len_x
= TYPE_LENGTH (type2
);
858 decimal_from_integral (arg1
, x
, *len_x
, *byte_order_x
);
861 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
864 /* Obtain decimal value of arg2, converting from other types
867 if (TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
869 *byte_order_y
= gdbarch_byte_order (get_type_arch (type2
));
870 *len_y
= TYPE_LENGTH (type2
);
871 memcpy (y
, value_contents (arg2
), *len_y
);
873 else if (is_integral_type (type2
))
875 *byte_order_y
= gdbarch_byte_order (get_type_arch (type1
));
876 *len_y
= TYPE_LENGTH (type1
);
877 decimal_from_integral (arg2
, y
, *len_y
, *byte_order_y
);
880 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
884 /* Perform a binary operation on two operands which have reasonable
885 representations as integers or floats. This includes booleans,
886 characters, integers, or floats.
887 Does not support addition and subtraction on pointers;
888 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
890 static struct value
*
891 scalar_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
894 struct type
*type1
, *type2
, *result_type
;
896 arg1
= coerce_ref (arg1
);
897 arg2
= coerce_ref (arg2
);
899 type1
= check_typedef (value_type (arg1
));
900 type2
= check_typedef (value_type (arg2
));
902 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
903 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
904 && !is_integral_type (type1
))
905 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
906 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
907 && !is_integral_type (type2
)))
908 error (_("Argument to arithmetic operation not a number or boolean."));
910 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
911 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
913 int len_v1
, len_v2
, len_v
;
914 enum bfd_endian byte_order_v1
, byte_order_v2
, byte_order_v
;
915 gdb_byte v1
[16], v2
[16];
918 /* If only one type is decimal float, use its type.
919 Otherwise use the bigger type. */
920 if (TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
)
922 else if (TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
)
924 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
929 len_v
= TYPE_LENGTH (result_type
);
930 byte_order_v
= gdbarch_byte_order (get_type_arch (result_type
));
932 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
933 v2
, &len_v2
, &byte_order_v2
);
942 decimal_binop (op
, v1
, len_v1
, byte_order_v1
,
943 v2
, len_v2
, byte_order_v2
,
944 v
, len_v
, byte_order_v
);
948 error (_("Operation not valid for decimal floating point number."));
951 val
= value_from_decfloat (result_type
, v
);
953 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
954 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
956 /* FIXME-if-picky-about-floating-accuracy: Should be doing this
957 in target format. real.c in GCC probably has the necessary
959 DOUBLEST v1
, v2
, v
= 0;
961 v1
= value_as_double (arg1
);
962 v2
= value_as_double (arg2
);
986 error (_("Cannot perform exponentiation: %s"),
987 safe_strerror (errno
));
991 v
= v1
< v2
? v1
: v2
;
995 v
= v1
> v2
? v1
: v2
;
999 error (_("Integer-only operation on floating point number."));
1002 /* If only one type is float, use its type.
1003 Otherwise use the bigger type. */
1004 if (TYPE_CODE (type1
) != TYPE_CODE_FLT
)
1005 result_type
= type2
;
1006 else if (TYPE_CODE (type2
) != TYPE_CODE_FLT
)
1007 result_type
= type1
;
1008 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1009 result_type
= type2
;
1011 result_type
= type1
;
1013 val
= allocate_value (result_type
);
1014 store_typed_floating (value_contents_raw (val
), value_type (val
), v
);
1016 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
1017 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
1019 LONGEST v1
, v2
, v
= 0;
1021 v1
= value_as_long (arg1
);
1022 v2
= value_as_long (arg2
);
1026 case BINOP_BITWISE_AND
:
1030 case BINOP_BITWISE_IOR
:
1034 case BINOP_BITWISE_XOR
:
1042 case BINOP_NOTEQUAL
:
1047 error (_("Invalid operation on booleans."));
1050 result_type
= type1
;
1052 val
= allocate_value (result_type
);
1053 store_signed_integer (value_contents_raw (val
),
1054 TYPE_LENGTH (result_type
),
1055 gdbarch_byte_order (get_type_arch (result_type
)),
1059 /* Integral operations here. */
1061 /* Determine type length of the result, and if the operation should
1062 be done unsigned. For exponentiation and shift operators,
1063 use the length and type of the left operand. Otherwise,
1064 use the signedness of the operand with the greater length.
1065 If both operands are of equal length, use unsigned operation
1066 if one of the operands is unsigned. */
1067 if (op
== BINOP_RSH
|| op
== BINOP_LSH
|| op
== BINOP_EXP
)
1068 result_type
= type1
;
1069 else if (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
))
1070 result_type
= type1
;
1071 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1072 result_type
= type2
;
1073 else if (TYPE_UNSIGNED (type1
))
1074 result_type
= type1
;
1075 else if (TYPE_UNSIGNED (type2
))
1076 result_type
= type2
;
1078 result_type
= type1
;
1080 if (TYPE_UNSIGNED (result_type
))
1082 LONGEST v2_signed
= value_as_long (arg2
);
1083 ULONGEST v1
, v2
, v
= 0;
1085 v1
= (ULONGEST
) value_as_long (arg1
);
1086 v2
= (ULONGEST
) v2_signed
;
1107 error (_("Division by zero"));
1111 v
= uinteger_pow (v1
, v2_signed
);
1118 error (_("Division by zero"));
1122 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1123 v1 mod 0 has a defined value, v1. */
1131 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1144 case BINOP_BITWISE_AND
:
1148 case BINOP_BITWISE_IOR
:
1152 case BINOP_BITWISE_XOR
:
1156 case BINOP_LOGICAL_AND
:
1160 case BINOP_LOGICAL_OR
:
1165 v
= v1
< v2
? v1
: v2
;
1169 v
= v1
> v2
? v1
: v2
;
1176 case BINOP_NOTEQUAL
:
1197 error (_("Invalid binary operation on numbers."));
1200 val
= allocate_value (result_type
);
1201 store_unsigned_integer (value_contents_raw (val
),
1202 TYPE_LENGTH (value_type (val
)),
1204 (get_type_arch (result_type
)),
1209 LONGEST v1
, v2
, v
= 0;
1211 v1
= value_as_long (arg1
);
1212 v2
= value_as_long (arg2
);
1233 error (_("Division by zero"));
1237 v
= integer_pow (v1
, v2
);
1244 error (_("Division by zero"));
1248 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1249 X mod 0 has a defined value, X. */
1257 /* Compute floor. */
1258 if (TRUNCATION_TOWARDS_ZERO
&& (v
< 0) && ((v1
% v2
) != 0))
1274 case BINOP_BITWISE_AND
:
1278 case BINOP_BITWISE_IOR
:
1282 case BINOP_BITWISE_XOR
:
1286 case BINOP_LOGICAL_AND
:
1290 case BINOP_LOGICAL_OR
:
1295 v
= v1
< v2
? v1
: v2
;
1299 v
= v1
> v2
? v1
: v2
;
1306 case BINOP_NOTEQUAL
:
1327 error (_("Invalid binary operation on numbers."));
1330 val
= allocate_value (result_type
);
1331 store_signed_integer (value_contents_raw (val
),
1332 TYPE_LENGTH (value_type (val
)),
1334 (get_type_arch (result_type
)),
1342 /* Performs a binary operation on two vector operands by calling scalar_binop
1343 for each pair of vector components. */
1345 static struct value
*
1346 vector_binop (struct value
*val1
, struct value
*val2
, enum exp_opcode op
)
1348 struct value
*val
, *tmp
, *mark
;
1349 struct type
*type1
, *type2
, *eltype1
, *eltype2
;
1350 int t1_is_vec
, t2_is_vec
, elsize
, i
;
1351 LONGEST low_bound1
, high_bound1
, low_bound2
, high_bound2
;
1353 type1
= check_typedef (value_type (val1
));
1354 type2
= check_typedef (value_type (val2
));
1356 t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
1357 && TYPE_VECTOR (type1
)) ? 1 : 0;
1358 t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
1359 && TYPE_VECTOR (type2
)) ? 1 : 0;
1361 if (!t1_is_vec
|| !t2_is_vec
)
1362 error (_("Vector operations are only supported among vectors"));
1364 if (!get_array_bounds (type1
, &low_bound1
, &high_bound1
)
1365 || !get_array_bounds (type2
, &low_bound2
, &high_bound2
))
1366 error (_("Could not determine the vector bounds"));
1368 eltype1
= check_typedef (TYPE_TARGET_TYPE (type1
));
1369 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
));
1370 elsize
= TYPE_LENGTH (eltype1
);
1372 if (TYPE_CODE (eltype1
) != TYPE_CODE (eltype2
)
1373 || elsize
!= TYPE_LENGTH (eltype2
)
1374 || TYPE_UNSIGNED (eltype1
) != TYPE_UNSIGNED (eltype2
)
1375 || low_bound1
!= low_bound2
|| high_bound1
!= high_bound2
)
1376 error (_("Cannot perform operation on vectors with different types"));
1378 val
= allocate_value (type1
);
1379 mark
= value_mark ();
1380 for (i
= 0; i
< high_bound1
- low_bound1
+ 1; i
++)
1382 tmp
= value_binop (value_subscript (val1
, i
),
1383 value_subscript (val2
, i
), op
);
1384 memcpy (value_contents_writeable (val
) + i
* elsize
,
1385 value_contents_all (tmp
),
1388 value_free_to_mark (mark
);
1393 /* Perform a binary operation on two operands. */
1396 value_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
1399 struct type
*type1
= check_typedef (value_type (arg1
));
1400 struct type
*type2
= check_typedef (value_type (arg2
));
1401 int t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
1402 && TYPE_VECTOR (type1
));
1403 int t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
1404 && TYPE_VECTOR (type2
));
1406 if (!t1_is_vec
&& !t2_is_vec
)
1407 val
= scalar_binop (arg1
, arg2
, op
);
1408 else if (t1_is_vec
&& t2_is_vec
)
1409 val
= vector_binop (arg1
, arg2
, op
);
1412 /* Widen the scalar operand to a vector. */
1413 struct value
**v
= t1_is_vec
? &arg2
: &arg1
;
1414 struct type
*t
= t1_is_vec
? type2
: type1
;
1416 if (TYPE_CODE (t
) != TYPE_CODE_FLT
1417 && TYPE_CODE (t
) != TYPE_CODE_DECFLOAT
1418 && !is_integral_type (t
))
1419 error (_("Argument to operation not a number or boolean."));
1421 *v
= value_cast (t1_is_vec
? type1
: type2
, *v
);
1422 val
= vector_binop (arg1
, arg2
, op
);
1428 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1431 value_logical_not (struct value
*arg1
)
1437 arg1
= coerce_array (arg1
);
1438 type1
= check_typedef (value_type (arg1
));
1440 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
)
1441 return 0 == value_as_double (arg1
);
1442 else if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
1443 return decimal_is_zero (value_contents (arg1
), TYPE_LENGTH (type1
),
1444 gdbarch_byte_order (get_type_arch (type1
)));
1446 len
= TYPE_LENGTH (type1
);
1447 p
= value_contents (arg1
);
1458 /* Perform a comparison on two string values (whose content are not
1459 necessarily null terminated) based on their length. */
1462 value_strcmp (struct value
*arg1
, struct value
*arg2
)
1464 int len1
= TYPE_LENGTH (value_type (arg1
));
1465 int len2
= TYPE_LENGTH (value_type (arg2
));
1466 const gdb_byte
*s1
= value_contents (arg1
);
1467 const gdb_byte
*s2
= value_contents (arg2
);
1468 int i
, len
= len1
< len2
? len1
: len2
;
1470 for (i
= 0; i
< len
; i
++)
1474 else if (s1
[i
] > s2
[i
])
1482 else if (len1
> len2
)
1488 /* Simulate the C operator == by returning a 1
1489 iff ARG1 and ARG2 have equal contents. */
1492 value_equal (struct value
*arg1
, struct value
*arg2
)
1497 struct type
*type1
, *type2
;
1498 enum type_code code1
;
1499 enum type_code code2
;
1500 int is_int1
, is_int2
;
1502 arg1
= coerce_array (arg1
);
1503 arg2
= coerce_array (arg2
);
1505 type1
= check_typedef (value_type (arg1
));
1506 type2
= check_typedef (value_type (arg2
));
1507 code1
= TYPE_CODE (type1
);
1508 code2
= TYPE_CODE (type2
);
1509 is_int1
= is_integral_type (type1
);
1510 is_int2
= is_integral_type (type2
);
1512 if (is_int1
&& is_int2
)
1513 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1515 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1516 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1518 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1519 `long double' values are returned in static storage (m68k). */
1520 DOUBLEST d
= value_as_double (arg1
);
1522 return d
== value_as_double (arg2
);
1524 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1525 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1527 gdb_byte v1
[16], v2
[16];
1529 enum bfd_endian byte_order_v1
, byte_order_v2
;
1531 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
1532 v2
, &len_v2
, &byte_order_v2
);
1534 return decimal_compare (v1
, len_v1
, byte_order_v1
,
1535 v2
, len_v2
, byte_order_v2
) == 0;
1538 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1540 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1541 return value_as_address (arg1
) == (CORE_ADDR
) value_as_long (arg2
);
1542 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1543 return (CORE_ADDR
) value_as_long (arg1
) == value_as_address (arg2
);
1545 else if (code1
== code2
1546 && ((len
= (int) TYPE_LENGTH (type1
))
1547 == (int) TYPE_LENGTH (type2
)))
1549 p1
= value_contents (arg1
);
1550 p2
= value_contents (arg2
);
1558 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1560 return value_strcmp (arg1
, arg2
) == 0;
1564 error (_("Invalid type combination in equality test."));
1565 return 0; /* For lint -- never reached. */
1569 /* Compare values based on their raw contents. Useful for arrays since
1570 value_equal coerces them to pointers, thus comparing just the address
1571 of the array instead of its contents. */
1574 value_equal_contents (struct value
*arg1
, struct value
*arg2
)
1576 struct type
*type1
, *type2
;
1578 type1
= check_typedef (value_type (arg1
));
1579 type2
= check_typedef (value_type (arg2
));
1581 return (TYPE_CODE (type1
) == TYPE_CODE (type2
)
1582 && TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
1583 && memcmp (value_contents (arg1
), value_contents (arg2
),
1584 TYPE_LENGTH (type1
)) == 0);
1587 /* Simulate the C operator < by returning 1
1588 iff ARG1's contents are less than ARG2's. */
1591 value_less (struct value
*arg1
, struct value
*arg2
)
1593 enum type_code code1
;
1594 enum type_code code2
;
1595 struct type
*type1
, *type2
;
1596 int is_int1
, is_int2
;
1598 arg1
= coerce_array (arg1
);
1599 arg2
= coerce_array (arg2
);
1601 type1
= check_typedef (value_type (arg1
));
1602 type2
= check_typedef (value_type (arg2
));
1603 code1
= TYPE_CODE (type1
);
1604 code2
= TYPE_CODE (type2
);
1605 is_int1
= is_integral_type (type1
);
1606 is_int2
= is_integral_type (type2
);
1608 if (is_int1
&& is_int2
)
1609 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1611 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1612 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1614 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1615 `long double' values are returned in static storage (m68k). */
1616 DOUBLEST d
= value_as_double (arg1
);
1618 return d
< value_as_double (arg2
);
1620 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1621 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1623 gdb_byte v1
[16], v2
[16];
1625 enum bfd_endian byte_order_v1
, byte_order_v2
;
1627 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
1628 v2
, &len_v2
, &byte_order_v2
);
1630 return decimal_compare (v1
, len_v1
, byte_order_v1
,
1631 v2
, len_v2
, byte_order_v2
) == -1;
1633 else if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
1634 return value_as_address (arg1
) < value_as_address (arg2
);
1636 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1638 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1639 return value_as_address (arg1
) < (CORE_ADDR
) value_as_long (arg2
);
1640 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1641 return (CORE_ADDR
) value_as_long (arg1
) < value_as_address (arg2
);
1642 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1643 return value_strcmp (arg1
, arg2
) < 0;
1646 error (_("Invalid type combination in ordering comparison."));
1651 /* The unary operators +, - and ~. They free the argument ARG1. */
1654 value_pos (struct value
*arg1
)
1658 arg1
= coerce_ref (arg1
);
1659 type
= check_typedef (value_type (arg1
));
1661 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1662 return value_from_double (type
, value_as_double (arg1
));
1663 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1664 return value_from_decfloat (type
, value_contents (arg1
));
1665 else if (is_integral_type (type
))
1667 return value_from_longest (type
, value_as_long (arg1
));
1669 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1671 struct value
*val
= allocate_value (type
);
1673 memcpy (value_contents_raw (val
), value_contents (arg1
),
1674 TYPE_LENGTH (type
));
1679 error (_("Argument to positive operation not a number."));
1680 return 0; /* For lint -- never reached. */
1685 value_neg (struct value
*arg1
)
1689 arg1
= coerce_ref (arg1
);
1690 type
= check_typedef (value_type (arg1
));
1692 if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1694 struct value
*val
= allocate_value (type
);
1695 int len
= TYPE_LENGTH (type
);
1696 gdb_byte decbytes
[16]; /* a decfloat is at most 128 bits long. */
1698 memcpy (decbytes
, value_contents (arg1
), len
);
1700 if (gdbarch_byte_order (get_type_arch (type
)) == BFD_ENDIAN_LITTLE
)
1701 decbytes
[len
-1] = decbytes
[len
- 1] | 0x80;
1703 decbytes
[0] = decbytes
[0] | 0x80;
1705 memcpy (value_contents_raw (val
), decbytes
, len
);
1708 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1709 return value_from_double (type
, -value_as_double (arg1
));
1710 else if (is_integral_type (type
))
1712 return value_from_longest (type
, -value_as_long (arg1
));
1714 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1716 struct value
*tmp
, *val
= allocate_value (type
);
1717 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1719 LONGEST low_bound
, high_bound
;
1721 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1722 error (_("Could not determine the vector bounds"));
1724 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1726 tmp
= value_neg (value_subscript (arg1
, i
));
1727 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
1728 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
1734 error (_("Argument to negate operation not a number."));
1735 return 0; /* For lint -- never reached. */
1740 value_complement (struct value
*arg1
)
1745 arg1
= coerce_ref (arg1
);
1746 type
= check_typedef (value_type (arg1
));
1748 if (is_integral_type (type
))
1749 val
= value_from_longest (type
, ~value_as_long (arg1
));
1750 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1753 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1755 LONGEST low_bound
, high_bound
;
1757 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1758 error (_("Could not determine the vector bounds"));
1760 val
= allocate_value (type
);
1761 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1763 tmp
= value_complement (value_subscript (arg1
, i
));
1764 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
1765 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
1769 error (_("Argument to complement operation not an integer, boolean."));
1774 /* The INDEX'th bit of SET value whose value_type is TYPE,
1775 and whose value_contents is valaddr.
1776 Return -1 if out of range, -2 other error. */
1779 value_bit_index (struct type
*type
, const gdb_byte
*valaddr
, int index
)
1781 struct gdbarch
*gdbarch
= get_type_arch (type
);
1782 LONGEST low_bound
, high_bound
;
1785 struct type
*range
= TYPE_INDEX_TYPE (type
);
1787 if (get_discrete_bounds (range
, &low_bound
, &high_bound
) < 0)
1789 if (index
< low_bound
|| index
> high_bound
)
1791 rel_index
= index
- low_bound
;
1792 word
= extract_unsigned_integer (valaddr
+ (rel_index
/ TARGET_CHAR_BIT
), 1,
1793 gdbarch_byte_order (gdbarch
));
1794 rel_index
%= TARGET_CHAR_BIT
;
1795 if (gdbarch_bits_big_endian (gdbarch
))
1796 rel_index
= TARGET_CHAR_BIT
- 1 - rel_index
;
1797 return (word
>> rel_index
) & 1;
1801 value_in (struct value
*element
, struct value
*set
)
1804 struct type
*settype
= check_typedef (value_type (set
));
1805 struct type
*eltype
= check_typedef (value_type (element
));
1807 if (TYPE_CODE (eltype
) == TYPE_CODE_RANGE
)
1808 eltype
= TYPE_TARGET_TYPE (eltype
);
1809 if (TYPE_CODE (settype
) != TYPE_CODE_SET
)
1810 error (_("Second argument of 'IN' has wrong type"));
1811 if (TYPE_CODE (eltype
) != TYPE_CODE_INT
1812 && TYPE_CODE (eltype
) != TYPE_CODE_CHAR
1813 && TYPE_CODE (eltype
) != TYPE_CODE_ENUM
1814 && TYPE_CODE (eltype
) != TYPE_CODE_BOOL
)
1815 error (_("First argument of 'IN' has wrong type"));
1816 member
= value_bit_index (settype
, value_contents (set
),
1817 value_as_long (element
));
1819 error (_("First argument of 'IN' not in range"));
1824 _initialize_valarith (void)
This page took 0.072212 seconds and 5 git commands to generate.