1 /* Perform arithmetic and other operations on values, for GDB.
3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
27 #include "gdb_string.h"
32 #include "exceptions.h"
34 /* Define whether or not the C operator '/' truncates towards zero for
35 differently signed operands (truncation direction is undefined in C). */
37 #ifndef TRUNCATION_TOWARDS_ZERO
38 #define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
41 void _initialize_valarith (void);
44 /* Given a pointer, return the size of its target.
45 If the pointer type is void *, then return 1.
46 If the target type is incomplete, then error out.
47 This isn't a general purpose function, but just a
48 helper for value_ptradd. */
51 find_size_for_pointer_math (struct type
*ptr_type
)
54 struct type
*ptr_target
;
56 gdb_assert (TYPE_CODE (ptr_type
) == TYPE_CODE_PTR
);
57 ptr_target
= check_typedef (TYPE_TARGET_TYPE (ptr_type
));
59 sz
= TYPE_LENGTH (ptr_target
);
62 if (TYPE_CODE (ptr_type
) == TYPE_CODE_VOID
)
68 name
= TYPE_NAME (ptr_target
);
70 name
= TYPE_TAG_NAME (ptr_target
);
72 error (_("Cannot perform pointer math on incomplete types, "
73 "try casting to a known type, or void *."));
75 error (_("Cannot perform pointer math on incomplete type \"%s\", "
76 "try casting to a known type, or void *."), name
);
82 /* Given a pointer ARG1 and an integral value ARG2, return the
83 result of C-style pointer arithmetic ARG1 + ARG2. */
86 value_ptradd (struct value
*arg1
, LONGEST arg2
)
88 struct type
*valptrtype
;
92 arg1
= coerce_array (arg1
);
93 valptrtype
= check_typedef (value_type (arg1
));
94 sz
= find_size_for_pointer_math (valptrtype
);
96 result
= value_from_pointer (valptrtype
,
97 value_as_address (arg1
) + sz
* arg2
);
98 if (VALUE_LVAL (result
) != lval_internalvar
)
99 set_value_component_location (result
, arg1
);
103 /* Given two compatible pointer values ARG1 and ARG2, return the
104 result of C-style pointer arithmetic ARG1 - ARG2. */
107 value_ptrdiff (struct value
*arg1
, struct value
*arg2
)
109 struct type
*type1
, *type2
;
112 arg1
= coerce_array (arg1
);
113 arg2
= coerce_array (arg2
);
114 type1
= check_typedef (value_type (arg1
));
115 type2
= check_typedef (value_type (arg2
));
117 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_PTR
);
118 gdb_assert (TYPE_CODE (type2
) == TYPE_CODE_PTR
);
120 if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)))
121 != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2
))))
122 error (_("First argument of `-' is a pointer and "
123 "second argument is neither\n"
124 "an integer nor a pointer of the same type."));
126 sz
= TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)));
129 warning (_("Type size unknown, assuming 1. "
130 "Try casting to a known type, or void *."));
134 return (value_as_long (arg1
) - value_as_long (arg2
)) / sz
;
137 /* Return the value of ARRAY[IDX].
139 ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING. If the
140 current language supports C-style arrays, it may also be TYPE_CODE_PTR.
142 See comments in value_coerce_array() for rationale for reason for
143 doing lower bounds adjustment here rather than there.
144 FIXME: Perhaps we should validate that the index is valid and if
145 verbosity is set, warn about invalid indices (but still use them). */
148 value_subscript (struct value
*array
, LONGEST index
)
150 int c_style
= current_language
->c_style_arrays
;
153 array
= coerce_ref (array
);
154 tarray
= check_typedef (value_type (array
));
156 if (TYPE_CODE (tarray
) == TYPE_CODE_ARRAY
157 || TYPE_CODE (tarray
) == TYPE_CODE_STRING
)
159 struct type
*range_type
= TYPE_INDEX_TYPE (tarray
);
160 LONGEST lowerbound
, upperbound
;
162 get_discrete_bounds (range_type
, &lowerbound
, &upperbound
);
163 if (VALUE_LVAL (array
) != lval_memory
)
164 return value_subscripted_rvalue (array
, index
, lowerbound
);
168 if (index
>= lowerbound
&& index
<= upperbound
)
169 return value_subscripted_rvalue (array
, index
, lowerbound
);
170 /* Emit warning unless we have an array of unknown size.
171 An array of unknown size has lowerbound 0 and upperbound -1. */
173 warning (_("array or string index out of range"));
174 /* fall doing C stuff */
179 array
= value_coerce_array (array
);
183 return value_ind (value_ptradd (array
, index
));
185 error (_("not an array or string"));
188 /* Return the value of EXPR[IDX], expr an aggregate rvalue
189 (eg, a vector register). This routine used to promote floats
190 to doubles, but no longer does. */
193 value_subscripted_rvalue (struct value
*array
, LONGEST index
, int lowerbound
)
195 struct type
*array_type
= check_typedef (value_type (array
));
196 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (array_type
));
197 unsigned int elt_size
= TYPE_LENGTH (elt_type
);
198 unsigned int elt_offs
= elt_size
* longest_to_int (index
- lowerbound
);
201 if (index
< lowerbound
|| (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type
)
202 && elt_offs
>= TYPE_LENGTH (array_type
)))
203 error (_("no such vector element"));
205 if (VALUE_LVAL (array
) == lval_memory
&& value_lazy (array
))
206 v
= allocate_value_lazy (elt_type
);
209 v
= allocate_value (elt_type
);
210 value_contents_copy (v
, value_embedded_offset (v
),
211 array
, value_embedded_offset (array
) + elt_offs
,
215 set_value_component_location (v
, array
);
216 VALUE_REGNUM (v
) = VALUE_REGNUM (array
);
217 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (array
);
218 set_value_offset (v
, value_offset (array
) + elt_offs
);
223 /* Check to see if either argument is a structure, or a reference to
224 one. This is called so we know whether to go ahead with the normal
225 binop or look for a user defined function instead.
227 For now, we do not overload the `=' operator. */
230 binop_types_user_defined_p (enum exp_opcode op
,
231 struct type
*type1
, struct type
*type2
)
233 if (op
== BINOP_ASSIGN
|| op
== BINOP_CONCAT
)
236 type1
= check_typedef (type1
);
237 if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
238 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
240 type2
= check_typedef (type2
);
241 if (TYPE_CODE (type2
) == TYPE_CODE_REF
)
242 type2
= check_typedef (TYPE_TARGET_TYPE (type2
));
244 return (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
245 || TYPE_CODE (type2
) == TYPE_CODE_STRUCT
);
248 /* Check to see if either argument is a structure, or a reference to
249 one. This is called so we know whether to go ahead with the normal
250 binop or look for a user defined function instead.
252 For now, we do not overload the `=' operator. */
255 binop_user_defined_p (enum exp_opcode op
,
256 struct value
*arg1
, struct value
*arg2
)
258 return binop_types_user_defined_p (op
, value_type (arg1
), value_type (arg2
));
261 /* Check to see if argument is a structure. This is called so
262 we know whether to go ahead with the normal unop or look for a
263 user defined function instead.
265 For now, we do not overload the `&' operator. */
268 unop_user_defined_p (enum exp_opcode op
, struct value
*arg1
)
274 type1
= check_typedef (value_type (arg1
));
275 if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
276 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
277 return TYPE_CODE (type1
) == TYPE_CODE_STRUCT
;
280 /* Try to find an operator named OPERATOR which takes NARGS arguments
281 specified in ARGS. If the operator found is a static member operator
282 *STATIC_MEMFUNP will be set to 1, and otherwise 0.
283 The search if performed through find_overload_match which will handle
284 member operators, non member operators, operators imported implicitly or
285 explicitly, and perform correct overload resolution in all of the above
286 situations or combinations thereof. */
288 static struct value
*
289 value_user_defined_cpp_op (struct value
**args
, int nargs
, char *operator,
290 int *static_memfuncp
)
293 struct symbol
*symp
= NULL
;
294 struct value
*valp
= NULL
;
296 find_overload_match (args
, nargs
, operator, BOTH
/* could be method */,
297 0 /* strict match */, &args
[0], /* objp */
298 NULL
/* pass NULL symbol since symbol is unknown */,
299 &valp
, &symp
, static_memfuncp
, 0);
306 /* This is a non member function and does not
307 expect a reference as its first argument
308 rather the explicit structure. */
309 args
[0] = value_ind (args
[0]);
310 return value_of_variable (symp
, 0);
313 error (_("Could not find %s."), operator);
316 /* Lookup user defined operator NAME. Return a value representing the
317 function, otherwise return NULL. */
319 static struct value
*
320 value_user_defined_op (struct value
**argp
, struct value
**args
, char *name
,
321 int *static_memfuncp
, int nargs
)
323 struct value
*result
= NULL
;
325 if (current_language
->la_language
== language_cplus
)
326 result
= value_user_defined_cpp_op (args
, nargs
, name
, static_memfuncp
);
328 result
= value_struct_elt (argp
, args
, name
, static_memfuncp
,
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_user_defined_op (&arg1
, argvec
+ 1, tstr
,
475 &static_memfuncp
, 2);
481 argvec
[1] = argvec
[0];
484 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
486 struct type
*return_type
;
489 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
490 return value_zero (return_type
, VALUE_LVAL (arg1
));
492 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
,
495 throw_error (NOT_FOUND_ERROR
,
496 _("member function %s not found"), tstr
);
498 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
502 /* We know that arg1 is a structure, so try to find a unary user
503 defined operator that matches the operator in question.
504 Create an argument vector that calls arg1.operator @ (arg1)
505 and return that value (where '@' is (almost) any unary operator which
506 is legal for GNU C++). */
509 value_x_unop (struct value
*arg1
, enum exp_opcode op
, enum noside noside
)
511 struct gdbarch
*gdbarch
= get_type_arch (value_type (arg1
));
512 struct value
**argvec
;
513 char *ptr
, *mangle_ptr
;
514 char tstr
[13], mangle_tstr
[13];
515 int static_memfuncp
, nargs
;
517 arg1
= coerce_ref (arg1
);
519 /* now we know that what we have to do is construct our
520 arg vector and find the right function to call it with. */
522 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
523 error (_("Can't do that unary op on that type")); /* FIXME be explicit */
525 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
526 argvec
[1] = value_addr (arg1
);
531 /* Make the right function name up. */
532 strcpy (tstr
, "operator__");
534 strcpy (mangle_tstr
, "__");
535 mangle_ptr
= mangle_tstr
+ 2;
538 case UNOP_PREINCREMENT
:
541 case UNOP_PREDECREMENT
:
544 case UNOP_POSTINCREMENT
:
546 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
550 case UNOP_POSTDECREMENT
:
552 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
556 case UNOP_LOGICAL_NOT
:
559 case UNOP_COMPLEMENT
:
575 error (_("Invalid unary operation specified."));
578 argvec
[0] = value_user_defined_op (&arg1
, argvec
+ 1, tstr
,
579 &static_memfuncp
, nargs
);
585 argvec
[1] = argvec
[0];
589 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
591 struct type
*return_type
;
594 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
595 return value_zero (return_type
, VALUE_LVAL (arg1
));
597 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
599 throw_error (NOT_FOUND_ERROR
,
600 _("member function %s not found"), tstr
);
602 return 0; /* For lint -- never reached */
606 /* Concatenate two values with the following conditions:
608 (1) Both values must be either bitstring values or character string
609 values and the resulting value consists of the concatenation of
610 ARG1 followed by ARG2.
614 One value must be an integer value and the other value must be
615 either a bitstring value or character string value, which is
616 to be repeated by the number of times specified by the integer
620 (2) Boolean values are also allowed and are treated as bit string
623 (3) Character values are also allowed and are treated as character
624 string values of length 1. */
627 value_concat (struct value
*arg1
, struct value
*arg2
)
629 struct value
*inval1
;
630 struct value
*inval2
;
631 struct value
*outval
= NULL
;
632 int inval1len
, inval2len
;
636 struct type
*type1
= check_typedef (value_type (arg1
));
637 struct type
*type2
= check_typedef (value_type (arg2
));
638 struct type
*char_type
;
640 /* First figure out if we are dealing with two values to be concatenated
641 or a repeat count and a value to be repeated. INVAL1 is set to the
642 first of two concatenated values, or the repeat count. INVAL2 is set
643 to the second of the two concatenated values or the value to be
646 if (TYPE_CODE (type2
) == TYPE_CODE_INT
)
648 struct type
*tmp
= type1
;
661 /* Now process the input values. */
663 if (TYPE_CODE (type1
) == TYPE_CODE_INT
)
665 /* We have a repeat count. Validate the second value and then
666 construct a value repeated that many times. */
667 if (TYPE_CODE (type2
) == TYPE_CODE_STRING
668 || TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
670 struct cleanup
*back_to
;
672 count
= longest_to_int (value_as_long (inval1
));
673 inval2len
= TYPE_LENGTH (type2
);
674 ptr
= (char *) xmalloc (count
* inval2len
);
675 back_to
= make_cleanup (xfree
, ptr
);
676 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
680 inchar
= (char) unpack_long (type2
,
681 value_contents (inval2
));
682 for (idx
= 0; idx
< count
; idx
++)
684 *(ptr
+ idx
) = inchar
;
689 char_type
= TYPE_TARGET_TYPE (type2
);
691 for (idx
= 0; idx
< count
; idx
++)
693 memcpy (ptr
+ (idx
* inval2len
), value_contents (inval2
),
697 outval
= value_string (ptr
, count
* inval2len
, char_type
);
698 do_cleanups (back_to
);
700 else if (TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
702 error (_("unimplemented support for boolean repeats"));
706 error (_("can't repeat values of that type"));
709 else if (TYPE_CODE (type1
) == TYPE_CODE_STRING
710 || TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
712 struct cleanup
*back_to
;
714 /* We have two character strings to concatenate. */
715 if (TYPE_CODE (type2
) != TYPE_CODE_STRING
716 && TYPE_CODE (type2
) != TYPE_CODE_CHAR
)
718 error (_("Strings can only be concatenated with other strings."));
720 inval1len
= TYPE_LENGTH (type1
);
721 inval2len
= TYPE_LENGTH (type2
);
722 ptr
= (char *) xmalloc (inval1len
+ inval2len
);
723 back_to
= make_cleanup (xfree
, ptr
);
724 if (TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
728 *ptr
= (char) unpack_long (type1
, value_contents (inval1
));
732 char_type
= TYPE_TARGET_TYPE (type1
);
734 memcpy (ptr
, value_contents (inval1
), inval1len
);
736 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
739 (char) unpack_long (type2
, value_contents (inval2
));
743 memcpy (ptr
+ inval1len
, value_contents (inval2
), inval2len
);
745 outval
= value_string (ptr
, inval1len
+ inval2len
, char_type
);
746 do_cleanups (back_to
);
748 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
)
750 /* We have two bitstrings to concatenate. */
751 if (TYPE_CODE (type2
) != TYPE_CODE_BOOL
)
753 error (_("Booleans can only be concatenated "
754 "with other bitstrings or booleans."));
756 error (_("unimplemented support for boolean concatenation."));
760 /* We don't know how to concatenate these operands. */
761 error (_("illegal operands for concatenation."));
766 /* Integer exponentiation: V1**V2, where both arguments are
767 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
770 integer_pow (LONGEST v1
, LONGEST v2
)
775 error (_("Attempt to raise 0 to negative power."));
781 /* The Russian Peasant's Algorithm. */
797 /* Integer exponentiation: V1**V2, where both arguments are
798 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
801 uinteger_pow (ULONGEST v1
, LONGEST v2
)
806 error (_("Attempt to raise 0 to negative power."));
812 /* The Russian Peasant's Algorithm. */
828 /* Obtain decimal value of arguments for binary operation, converting from
829 other types if one of them is not decimal floating point. */
831 value_args_as_decimal (struct value
*arg1
, struct value
*arg2
,
832 gdb_byte
*x
, int *len_x
, enum bfd_endian
*byte_order_x
,
833 gdb_byte
*y
, int *len_y
, enum bfd_endian
*byte_order_y
)
835 struct type
*type1
, *type2
;
837 type1
= check_typedef (value_type (arg1
));
838 type2
= check_typedef (value_type (arg2
));
840 /* At least one of the arguments must be of decimal float type. */
841 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
842 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
);
844 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
845 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
846 /* The DFP extension to the C language does not allow mixing of
847 * decimal float types with other float types in expressions
848 * (see WDTR 24732, page 12). */
849 error (_("Mixing decimal floating types with "
850 "other floating types is not allowed."));
852 /* Obtain decimal value of arg1, converting from other types
855 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
857 *byte_order_x
= gdbarch_byte_order (get_type_arch (type1
));
858 *len_x
= TYPE_LENGTH (type1
);
859 memcpy (x
, value_contents (arg1
), *len_x
);
861 else if (is_integral_type (type1
))
863 *byte_order_x
= gdbarch_byte_order (get_type_arch (type2
));
864 *len_x
= TYPE_LENGTH (type2
);
865 decimal_from_integral (arg1
, x
, *len_x
, *byte_order_x
);
868 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
871 /* Obtain decimal value of arg2, converting from other types
874 if (TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
876 *byte_order_y
= gdbarch_byte_order (get_type_arch (type2
));
877 *len_y
= TYPE_LENGTH (type2
);
878 memcpy (y
, value_contents (arg2
), *len_y
);
880 else if (is_integral_type (type2
))
882 *byte_order_y
= gdbarch_byte_order (get_type_arch (type1
));
883 *len_y
= TYPE_LENGTH (type1
);
884 decimal_from_integral (arg2
, y
, *len_y
, *byte_order_y
);
887 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
891 /* Perform a binary operation on two operands which have reasonable
892 representations as integers or floats. This includes booleans,
893 characters, integers, or floats.
894 Does not support addition and subtraction on pointers;
895 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
897 static struct value
*
898 scalar_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
901 struct type
*type1
, *type2
, *result_type
;
903 arg1
= coerce_ref (arg1
);
904 arg2
= coerce_ref (arg2
);
906 type1
= check_typedef (value_type (arg1
));
907 type2
= check_typedef (value_type (arg2
));
909 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
910 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
911 && !is_integral_type (type1
))
912 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
913 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
914 && !is_integral_type (type2
)))
915 error (_("Argument to arithmetic operation not a number or boolean."));
917 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
918 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
920 int len_v1
, len_v2
, len_v
;
921 enum bfd_endian byte_order_v1
, byte_order_v2
, byte_order_v
;
922 gdb_byte v1
[16], v2
[16];
925 /* If only one type is decimal float, use its type.
926 Otherwise use the bigger type. */
927 if (TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
)
929 else if (TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
)
931 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
936 len_v
= TYPE_LENGTH (result_type
);
937 byte_order_v
= gdbarch_byte_order (get_type_arch (result_type
));
939 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
940 v2
, &len_v2
, &byte_order_v2
);
949 decimal_binop (op
, v1
, len_v1
, byte_order_v1
,
950 v2
, len_v2
, byte_order_v2
,
951 v
, len_v
, byte_order_v
);
955 error (_("Operation not valid for decimal floating point number."));
958 val
= value_from_decfloat (result_type
, v
);
960 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
961 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
963 /* FIXME-if-picky-about-floating-accuracy: Should be doing this
964 in target format. real.c in GCC probably has the necessary
966 DOUBLEST v1
, v2
, v
= 0;
968 v1
= value_as_double (arg1
);
969 v2
= value_as_double (arg2
);
993 error (_("Cannot perform exponentiation: %s"),
994 safe_strerror (errno
));
998 v
= v1
< v2
? v1
: v2
;
1002 v
= v1
> v2
? v1
: v2
;
1006 error (_("Integer-only operation on floating point number."));
1009 /* If only one type is float, use its type.
1010 Otherwise use the bigger type. */
1011 if (TYPE_CODE (type1
) != TYPE_CODE_FLT
)
1012 result_type
= type2
;
1013 else if (TYPE_CODE (type2
) != TYPE_CODE_FLT
)
1014 result_type
= type1
;
1015 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1016 result_type
= type2
;
1018 result_type
= type1
;
1020 val
= allocate_value (result_type
);
1021 store_typed_floating (value_contents_raw (val
), value_type (val
), v
);
1023 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
1024 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
1026 LONGEST v1
, v2
, v
= 0;
1028 v1
= value_as_long (arg1
);
1029 v2
= value_as_long (arg2
);
1033 case BINOP_BITWISE_AND
:
1037 case BINOP_BITWISE_IOR
:
1041 case BINOP_BITWISE_XOR
:
1049 case BINOP_NOTEQUAL
:
1054 error (_("Invalid operation on booleans."));
1057 result_type
= type1
;
1059 val
= allocate_value (result_type
);
1060 store_signed_integer (value_contents_raw (val
),
1061 TYPE_LENGTH (result_type
),
1062 gdbarch_byte_order (get_type_arch (result_type
)),
1066 /* Integral operations here. */
1068 /* Determine type length of the result, and if the operation should
1069 be done unsigned. For exponentiation and shift operators,
1070 use the length and type of the left operand. Otherwise,
1071 use the signedness of the operand with the greater length.
1072 If both operands are of equal length, use unsigned operation
1073 if one of the operands is unsigned. */
1074 if (op
== BINOP_RSH
|| op
== BINOP_LSH
|| op
== BINOP_EXP
)
1075 result_type
= type1
;
1076 else if (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
))
1077 result_type
= type1
;
1078 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1079 result_type
= type2
;
1080 else if (TYPE_UNSIGNED (type1
))
1081 result_type
= type1
;
1082 else if (TYPE_UNSIGNED (type2
))
1083 result_type
= type2
;
1085 result_type
= type1
;
1087 if (TYPE_UNSIGNED (result_type
))
1089 LONGEST v2_signed
= value_as_long (arg2
);
1090 ULONGEST v1
, v2
, v
= 0;
1092 v1
= (ULONGEST
) value_as_long (arg1
);
1093 v2
= (ULONGEST
) v2_signed
;
1114 error (_("Division by zero"));
1118 v
= uinteger_pow (v1
, v2_signed
);
1125 error (_("Division by zero"));
1129 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1130 v1 mod 0 has a defined value, v1. */
1138 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1151 case BINOP_BITWISE_AND
:
1155 case BINOP_BITWISE_IOR
:
1159 case BINOP_BITWISE_XOR
:
1163 case BINOP_LOGICAL_AND
:
1167 case BINOP_LOGICAL_OR
:
1172 v
= v1
< v2
? v1
: v2
;
1176 v
= v1
> v2
? v1
: v2
;
1183 case BINOP_NOTEQUAL
:
1204 error (_("Invalid binary operation on numbers."));
1207 val
= allocate_value (result_type
);
1208 store_unsigned_integer (value_contents_raw (val
),
1209 TYPE_LENGTH (value_type (val
)),
1211 (get_type_arch (result_type
)),
1216 LONGEST v1
, v2
, v
= 0;
1218 v1
= value_as_long (arg1
);
1219 v2
= value_as_long (arg2
);
1240 error (_("Division by zero"));
1244 v
= integer_pow (v1
, v2
);
1251 error (_("Division by zero"));
1255 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1256 X mod 0 has a defined value, X. */
1264 /* Compute floor. */
1265 if (TRUNCATION_TOWARDS_ZERO
&& (v
< 0) && ((v1
% v2
) != 0))
1281 case BINOP_BITWISE_AND
:
1285 case BINOP_BITWISE_IOR
:
1289 case BINOP_BITWISE_XOR
:
1293 case BINOP_LOGICAL_AND
:
1297 case BINOP_LOGICAL_OR
:
1302 v
= v1
< v2
? v1
: v2
;
1306 v
= v1
> v2
? v1
: v2
;
1313 case BINOP_NOTEQUAL
:
1334 error (_("Invalid binary operation on numbers."));
1337 val
= allocate_value (result_type
);
1338 store_signed_integer (value_contents_raw (val
),
1339 TYPE_LENGTH (value_type (val
)),
1341 (get_type_arch (result_type
)),
1349 /* Performs a binary operation on two vector operands by calling scalar_binop
1350 for each pair of vector components. */
1352 static struct value
*
1353 vector_binop (struct value
*val1
, struct value
*val2
, enum exp_opcode op
)
1355 struct value
*val
, *tmp
, *mark
;
1356 struct type
*type1
, *type2
, *eltype1
, *eltype2
;
1357 int t1_is_vec
, t2_is_vec
, elsize
, i
;
1358 LONGEST low_bound1
, high_bound1
, low_bound2
, high_bound2
;
1360 type1
= check_typedef (value_type (val1
));
1361 type2
= check_typedef (value_type (val2
));
1363 t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
1364 && TYPE_VECTOR (type1
)) ? 1 : 0;
1365 t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
1366 && TYPE_VECTOR (type2
)) ? 1 : 0;
1368 if (!t1_is_vec
|| !t2_is_vec
)
1369 error (_("Vector operations are only supported among vectors"));
1371 if (!get_array_bounds (type1
, &low_bound1
, &high_bound1
)
1372 || !get_array_bounds (type2
, &low_bound2
, &high_bound2
))
1373 error (_("Could not determine the vector bounds"));
1375 eltype1
= check_typedef (TYPE_TARGET_TYPE (type1
));
1376 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
));
1377 elsize
= TYPE_LENGTH (eltype1
);
1379 if (TYPE_CODE (eltype1
) != TYPE_CODE (eltype2
)
1380 || elsize
!= TYPE_LENGTH (eltype2
)
1381 || TYPE_UNSIGNED (eltype1
) != TYPE_UNSIGNED (eltype2
)
1382 || low_bound1
!= low_bound2
|| high_bound1
!= high_bound2
)
1383 error (_("Cannot perform operation on vectors with different types"));
1385 val
= allocate_value (type1
);
1386 mark
= value_mark ();
1387 for (i
= 0; i
< high_bound1
- low_bound1
+ 1; i
++)
1389 tmp
= value_binop (value_subscript (val1
, i
),
1390 value_subscript (val2
, i
), op
);
1391 memcpy (value_contents_writeable (val
) + i
* elsize
,
1392 value_contents_all (tmp
),
1395 value_free_to_mark (mark
);
1400 /* Perform a binary operation on two operands. */
1403 value_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
1406 struct type
*type1
= check_typedef (value_type (arg1
));
1407 struct type
*type2
= check_typedef (value_type (arg2
));
1408 int t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
1409 && TYPE_VECTOR (type1
));
1410 int t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
1411 && TYPE_VECTOR (type2
));
1413 if (!t1_is_vec
&& !t2_is_vec
)
1414 val
= scalar_binop (arg1
, arg2
, op
);
1415 else if (t1_is_vec
&& t2_is_vec
)
1416 val
= vector_binop (arg1
, arg2
, op
);
1419 /* Widen the scalar operand to a vector. */
1420 struct value
**v
= t1_is_vec
? &arg2
: &arg1
;
1421 struct type
*t
= t1_is_vec
? type2
: type1
;
1423 if (TYPE_CODE (t
) != TYPE_CODE_FLT
1424 && TYPE_CODE (t
) != TYPE_CODE_DECFLOAT
1425 && !is_integral_type (t
))
1426 error (_("Argument to operation not a number or boolean."));
1428 *v
= value_cast (t1_is_vec
? type1
: type2
, *v
);
1429 val
= vector_binop (arg1
, arg2
, op
);
1435 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1438 value_logical_not (struct value
*arg1
)
1444 arg1
= coerce_array (arg1
);
1445 type1
= check_typedef (value_type (arg1
));
1447 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
)
1448 return 0 == value_as_double (arg1
);
1449 else if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
1450 return decimal_is_zero (value_contents (arg1
), TYPE_LENGTH (type1
),
1451 gdbarch_byte_order (get_type_arch (type1
)));
1453 len
= TYPE_LENGTH (type1
);
1454 p
= value_contents (arg1
);
1465 /* Perform a comparison on two string values (whose content are not
1466 necessarily null terminated) based on their length. */
1469 value_strcmp (struct value
*arg1
, struct value
*arg2
)
1471 int len1
= TYPE_LENGTH (value_type (arg1
));
1472 int len2
= TYPE_LENGTH (value_type (arg2
));
1473 const gdb_byte
*s1
= value_contents (arg1
);
1474 const gdb_byte
*s2
= value_contents (arg2
);
1475 int i
, len
= len1
< len2
? len1
: len2
;
1477 for (i
= 0; i
< len
; i
++)
1481 else if (s1
[i
] > s2
[i
])
1489 else if (len1
> len2
)
1495 /* Simulate the C operator == by returning a 1
1496 iff ARG1 and ARG2 have equal contents. */
1499 value_equal (struct value
*arg1
, struct value
*arg2
)
1504 struct type
*type1
, *type2
;
1505 enum type_code code1
;
1506 enum type_code code2
;
1507 int is_int1
, is_int2
;
1509 arg1
= coerce_array (arg1
);
1510 arg2
= coerce_array (arg2
);
1512 type1
= check_typedef (value_type (arg1
));
1513 type2
= check_typedef (value_type (arg2
));
1514 code1
= TYPE_CODE (type1
);
1515 code2
= TYPE_CODE (type2
);
1516 is_int1
= is_integral_type (type1
);
1517 is_int2
= is_integral_type (type2
);
1519 if (is_int1
&& is_int2
)
1520 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1522 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1523 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1525 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1526 `long double' values are returned in static storage (m68k). */
1527 DOUBLEST d
= value_as_double (arg1
);
1529 return d
== value_as_double (arg2
);
1531 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1532 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1534 gdb_byte v1
[16], v2
[16];
1536 enum bfd_endian byte_order_v1
, byte_order_v2
;
1538 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
1539 v2
, &len_v2
, &byte_order_v2
);
1541 return decimal_compare (v1
, len_v1
, byte_order_v1
,
1542 v2
, len_v2
, byte_order_v2
) == 0;
1545 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1547 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1548 return value_as_address (arg1
) == (CORE_ADDR
) value_as_long (arg2
);
1549 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1550 return (CORE_ADDR
) value_as_long (arg1
) == value_as_address (arg2
);
1552 else if (code1
== code2
1553 && ((len
= (int) TYPE_LENGTH (type1
))
1554 == (int) TYPE_LENGTH (type2
)))
1556 p1
= value_contents (arg1
);
1557 p2
= value_contents (arg2
);
1565 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1567 return value_strcmp (arg1
, arg2
) == 0;
1571 error (_("Invalid type combination in equality test."));
1572 return 0; /* For lint -- never reached. */
1576 /* Compare values based on their raw contents. Useful for arrays since
1577 value_equal coerces them to pointers, thus comparing just the address
1578 of the array instead of its contents. */
1581 value_equal_contents (struct value
*arg1
, struct value
*arg2
)
1583 struct type
*type1
, *type2
;
1585 type1
= check_typedef (value_type (arg1
));
1586 type2
= check_typedef (value_type (arg2
));
1588 return (TYPE_CODE (type1
) == TYPE_CODE (type2
)
1589 && TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
1590 && memcmp (value_contents (arg1
), value_contents (arg2
),
1591 TYPE_LENGTH (type1
)) == 0);
1594 /* Simulate the C operator < by returning 1
1595 iff ARG1's contents are less than ARG2's. */
1598 value_less (struct value
*arg1
, struct value
*arg2
)
1600 enum type_code code1
;
1601 enum type_code code2
;
1602 struct type
*type1
, *type2
;
1603 int is_int1
, is_int2
;
1605 arg1
= coerce_array (arg1
);
1606 arg2
= coerce_array (arg2
);
1608 type1
= check_typedef (value_type (arg1
));
1609 type2
= check_typedef (value_type (arg2
));
1610 code1
= TYPE_CODE (type1
);
1611 code2
= TYPE_CODE (type2
);
1612 is_int1
= is_integral_type (type1
);
1613 is_int2
= is_integral_type (type2
);
1615 if (is_int1
&& is_int2
)
1616 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1618 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1619 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1621 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1622 `long double' values are returned in static storage (m68k). */
1623 DOUBLEST d
= value_as_double (arg1
);
1625 return d
< value_as_double (arg2
);
1627 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1628 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1630 gdb_byte v1
[16], v2
[16];
1632 enum bfd_endian byte_order_v1
, byte_order_v2
;
1634 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
1635 v2
, &len_v2
, &byte_order_v2
);
1637 return decimal_compare (v1
, len_v1
, byte_order_v1
,
1638 v2
, len_v2
, byte_order_v2
) == -1;
1640 else if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
1641 return value_as_address (arg1
) < value_as_address (arg2
);
1643 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1645 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1646 return value_as_address (arg1
) < (CORE_ADDR
) value_as_long (arg2
);
1647 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1648 return (CORE_ADDR
) value_as_long (arg1
) < value_as_address (arg2
);
1649 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1650 return value_strcmp (arg1
, arg2
) < 0;
1653 error (_("Invalid type combination in ordering comparison."));
1658 /* The unary operators +, - and ~. They free the argument ARG1. */
1661 value_pos (struct value
*arg1
)
1665 arg1
= coerce_ref (arg1
);
1666 type
= check_typedef (value_type (arg1
));
1668 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1669 return value_from_double (type
, value_as_double (arg1
));
1670 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1671 return value_from_decfloat (type
, value_contents (arg1
));
1672 else if (is_integral_type (type
))
1674 return value_from_longest (type
, value_as_long (arg1
));
1676 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1678 struct value
*val
= allocate_value (type
);
1680 memcpy (value_contents_raw (val
), value_contents (arg1
),
1681 TYPE_LENGTH (type
));
1686 error (_("Argument to positive operation not a number."));
1687 return 0; /* For lint -- never reached. */
1692 value_neg (struct value
*arg1
)
1696 arg1
= coerce_ref (arg1
);
1697 type
= check_typedef (value_type (arg1
));
1699 if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1701 struct value
*val
= allocate_value (type
);
1702 int len
= TYPE_LENGTH (type
);
1703 gdb_byte decbytes
[16]; /* a decfloat is at most 128 bits long. */
1705 memcpy (decbytes
, value_contents (arg1
), len
);
1707 if (gdbarch_byte_order (get_type_arch (type
)) == BFD_ENDIAN_LITTLE
)
1708 decbytes
[len
-1] = decbytes
[len
- 1] | 0x80;
1710 decbytes
[0] = decbytes
[0] | 0x80;
1712 memcpy (value_contents_raw (val
), decbytes
, len
);
1715 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1716 return value_from_double (type
, -value_as_double (arg1
));
1717 else if (is_integral_type (type
))
1719 return value_from_longest (type
, -value_as_long (arg1
));
1721 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1723 struct value
*tmp
, *val
= allocate_value (type
);
1724 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1726 LONGEST low_bound
, high_bound
;
1728 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1729 error (_("Could not determine the vector bounds"));
1731 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1733 tmp
= value_neg (value_subscript (arg1
, i
));
1734 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
1735 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
1741 error (_("Argument to negate operation not a number."));
1742 return 0; /* For lint -- never reached. */
1747 value_complement (struct value
*arg1
)
1752 arg1
= coerce_ref (arg1
);
1753 type
= check_typedef (value_type (arg1
));
1755 if (is_integral_type (type
))
1756 val
= value_from_longest (type
, ~value_as_long (arg1
));
1757 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1760 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1762 LONGEST low_bound
, high_bound
;
1764 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1765 error (_("Could not determine the vector bounds"));
1767 val
= allocate_value (type
);
1768 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1770 tmp
= value_complement (value_subscript (arg1
, i
));
1771 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
1772 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
1776 error (_("Argument to complement operation not an integer, boolean."));
1781 /* The INDEX'th bit of SET value whose value_type is TYPE,
1782 and whose value_contents is valaddr.
1783 Return -1 if out of range, -2 other error. */
1786 value_bit_index (struct type
*type
, const gdb_byte
*valaddr
, int index
)
1788 struct gdbarch
*gdbarch
= get_type_arch (type
);
1789 LONGEST low_bound
, high_bound
;
1792 struct type
*range
= TYPE_INDEX_TYPE (type
);
1794 if (get_discrete_bounds (range
, &low_bound
, &high_bound
) < 0)
1796 if (index
< low_bound
|| index
> high_bound
)
1798 rel_index
= index
- low_bound
;
1799 word
= extract_unsigned_integer (valaddr
+ (rel_index
/ TARGET_CHAR_BIT
), 1,
1800 gdbarch_byte_order (gdbarch
));
1801 rel_index
%= TARGET_CHAR_BIT
;
1802 if (gdbarch_bits_big_endian (gdbarch
))
1803 rel_index
= TARGET_CHAR_BIT
- 1 - rel_index
;
1804 return (word
>> rel_index
) & 1;
1808 value_in (struct value
*element
, struct value
*set
)
1811 struct type
*settype
= check_typedef (value_type (set
));
1812 struct type
*eltype
= check_typedef (value_type (element
));
1814 if (TYPE_CODE (eltype
) == TYPE_CODE_RANGE
)
1815 eltype
= TYPE_TARGET_TYPE (eltype
);
1816 if (TYPE_CODE (settype
) != TYPE_CODE_SET
)
1817 error (_("Second argument of 'IN' has wrong type"));
1818 if (TYPE_CODE (eltype
) != TYPE_CODE_INT
1819 && TYPE_CODE (eltype
) != TYPE_CODE_CHAR
1820 && TYPE_CODE (eltype
) != TYPE_CODE_ENUM
1821 && TYPE_CODE (eltype
) != TYPE_CODE_BOOL
)
1822 error (_("First argument of 'IN' has wrong type"));
1823 member
= value_bit_index (settype
, value_contents (set
),
1824 value_as_long (element
));
1826 error (_("First argument of 'IN' not in range"));
1831 _initialize_valarith (void)
This page took 0.066903 seconds and 4 git commands to generate.