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 2010 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"
34 #include "exceptions.h"
36 /* Define whether or not the C operator '/' truncates towards zero for
37 differently signed operands (truncation direction is undefined in C). */
39 #ifndef TRUNCATION_TOWARDS_ZERO
40 #define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
43 void _initialize_valarith (void);
46 /* Given a pointer, return the size of its target.
47 If the pointer type is void *, then return 1.
48 If the target type is incomplete, then error out.
49 This isn't a general purpose function, but just a
50 helper for value_ptradd.
54 find_size_for_pointer_math (struct type
*ptr_type
)
57 struct type
*ptr_target
;
59 gdb_assert (TYPE_CODE (ptr_type
) == TYPE_CODE_PTR
);
60 ptr_target
= check_typedef (TYPE_TARGET_TYPE (ptr_type
));
62 sz
= TYPE_LENGTH (ptr_target
);
65 if (TYPE_CODE (ptr_type
) == TYPE_CODE_VOID
)
71 name
= TYPE_NAME (ptr_target
);
73 name
= TYPE_TAG_NAME (ptr_target
);
75 error (_("Cannot perform pointer math on incomplete types, "
76 "try casting to a known type, or void *."));
78 error (_("Cannot perform pointer math on incomplete type \"%s\", "
79 "try casting to a known type, or void *."), name
);
85 /* Given a pointer ARG1 and an integral value ARG2, return the
86 result of C-style pointer arithmetic ARG1 + ARG2. */
89 value_ptradd (struct value
*arg1
, LONGEST arg2
)
91 struct type
*valptrtype
;
94 arg1
= coerce_array (arg1
);
95 valptrtype
= check_typedef (value_type (arg1
));
96 sz
= find_size_for_pointer_math (valptrtype
);
98 return value_from_pointer (valptrtype
,
99 value_as_address (arg1
) + sz
* arg2
);
102 /* Given two compatible pointer values ARG1 and ARG2, return the
103 result of C-style pointer arithmetic ARG1 - ARG2. */
106 value_ptrdiff (struct value
*arg1
, struct value
*arg2
)
108 struct type
*type1
, *type2
;
111 arg1
= coerce_array (arg1
);
112 arg2
= coerce_array (arg2
);
113 type1
= check_typedef (value_type (arg1
));
114 type2
= check_typedef (value_type (arg2
));
116 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_PTR
);
117 gdb_assert (TYPE_CODE (type2
) == TYPE_CODE_PTR
);
119 if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)))
120 != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2
))))
122 First argument of `-' is a pointer and second argument is neither\n\
123 an integer nor a pointer of the same type."));
125 sz
= TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)));
128 warning (_("Type size unknown, assuming 1. "
129 "Try casting to a known type, or void *."));
133 return (value_as_long (arg1
) - value_as_long (arg2
)) / sz
;
136 /* Return the value of ARRAY[IDX].
138 ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING. If the
139 current language supports C-style arrays, it may also be TYPE_CODE_PTR.
140 To access TYPE_CODE_BITSTRING values, use value_bitstring_subscript.
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 v
= allocate_value (elt_type
);
206 if (VALUE_LVAL (array
) == lval_memory
&& value_lazy (array
))
207 set_value_lazy (v
, 1);
209 memcpy (value_contents_writeable (v
),
210 value_contents (array
) + elt_offs
, elt_size
);
212 set_value_component_location (v
, array
);
213 VALUE_REGNUM (v
) = VALUE_REGNUM (array
);
214 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (array
);
215 set_value_offset (v
, value_offset (array
) + elt_offs
);
219 /* Return the value of BITSTRING[IDX] as (boolean) type TYPE. */
222 value_bitstring_subscript (struct type
*type
,
223 struct value
*bitstring
, LONGEST index
)
226 struct type
*bitstring_type
, *range_type
;
228 int offset
, byte
, bit_index
;
229 LONGEST lowerbound
, upperbound
;
231 bitstring_type
= check_typedef (value_type (bitstring
));
232 gdb_assert (TYPE_CODE (bitstring_type
) == TYPE_CODE_BITSTRING
);
234 range_type
= TYPE_INDEX_TYPE (bitstring_type
);
235 get_discrete_bounds (range_type
, &lowerbound
, &upperbound
);
236 if (index
< lowerbound
|| index
> upperbound
)
237 error (_("bitstring index out of range"));
240 offset
= index
/ TARGET_CHAR_BIT
;
241 byte
= *((char *) value_contents (bitstring
) + offset
);
243 bit_index
= index
% TARGET_CHAR_BIT
;
244 byte
>>= (gdbarch_bits_big_endian (get_type_arch (bitstring_type
)) ?
245 TARGET_CHAR_BIT
- 1 - bit_index
: bit_index
);
247 v
= value_from_longest (type
, byte
& 1);
249 set_value_bitpos (v
, bit_index
);
250 set_value_bitsize (v
, 1);
251 set_value_component_location (v
, bitstring
);
252 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (bitstring
);
254 set_value_offset (v
, offset
+ value_offset (bitstring
));
260 /* Check to see if either argument is a structure, or a reference to
261 one. This is called so we know whether to go ahead with the normal
262 binop or look for a user defined function instead.
264 For now, we do not overload the `=' operator. */
267 binop_types_user_defined_p (enum exp_opcode op
,
268 struct type
*type1
, struct type
*type2
)
270 if (op
== BINOP_ASSIGN
|| op
== BINOP_CONCAT
)
273 type1
= check_typedef (type1
);
274 if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
275 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
277 type2
= check_typedef (type1
);
278 if (TYPE_CODE (type2
) == TYPE_CODE_REF
)
279 type2
= check_typedef (TYPE_TARGET_TYPE (type2
));
281 return (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
282 || TYPE_CODE (type2
) == TYPE_CODE_STRUCT
);
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
,
293 struct value
*arg1
, struct value
*arg2
)
295 return binop_types_user_defined_p (op
, value_type (arg1
), value_type (arg2
));
298 /* Check to see if argument is a structure. This is called so
299 we know whether to go ahead with the normal unop or look for a
300 user defined function instead.
302 For now, we do not overload the `&' operator. */
305 unop_user_defined_p (enum exp_opcode op
, struct value
*arg1
)
311 type1
= check_typedef (value_type (arg1
));
314 if (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
)
316 else if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
317 type1
= TYPE_TARGET_TYPE (type1
);
323 /* Try to find an operator named OPERATOR which takes NARGS arguments
324 specified in ARGS. If the operator found is a static member operator
325 *STATIC_MEMFUNP will be set to 1, and otherwise 0.
326 The search if performed through find_overload_match which will handle
327 member operators, non member operators, operators imported implicitly or
328 explicitly, and perform correct overload resolution in all of the above
329 situations or combinations thereof. */
331 static struct value
*
332 value_user_defined_cpp_op (struct value
**args
, int nargs
, char *operator,
333 int *static_memfuncp
)
336 struct symbol
*symp
= NULL
;
337 struct value
*valp
= NULL
;
338 struct type
**arg_types
;
341 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
342 /* Prepare list of argument types for overload resolution */
343 for (i
= 0; i
< nargs
; i
++)
344 arg_types
[i
] = value_type (args
[i
]);
346 find_overload_match (arg_types
, nargs
, operator, BOTH
/* could be method */,
347 0 /* strict match */, &args
[0], /* objp */
348 NULL
/* pass NULL symbol since symbol is unknown */,
349 &valp
, &symp
, static_memfuncp
, 0);
356 /* This is a non member function and does not
357 expect a reference as its first argument
358 rather the explicit structure. */
359 args
[0] = value_ind (args
[0]);
360 return value_of_variable (symp
, 0);
363 error (_("Could not find %s."), operator);
366 /* Lookup user defined operator NAME. Return a value representing the
367 function, otherwise return NULL. */
369 static struct value
*
370 value_user_defined_op (struct value
**argp
, struct value
**args
, char *name
,
371 int *static_memfuncp
, int nargs
)
373 struct value
*result
= NULL
;
375 if (current_language
->la_language
== language_cplus
)
376 result
= value_user_defined_cpp_op (args
, nargs
, name
, static_memfuncp
);
378 result
= value_struct_elt (argp
, args
, name
, static_memfuncp
,
384 /* We know either arg1 or arg2 is a structure, so try to find the right
385 user defined function. Create an argument vector that calls
386 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
387 binary operator which is legal for GNU C++).
389 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
390 is the opcode saying how to modify it. Otherwise, OTHEROP is
394 value_x_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
,
395 enum exp_opcode otherop
, enum noside noside
)
397 struct value
**argvec
;
402 arg1
= coerce_ref (arg1
);
403 arg2
= coerce_ref (arg2
);
405 /* now we know that what we have to do is construct our
406 arg vector and find the right function to call it with. */
408 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
409 error (_("Can't do that binary op on that type")); /* FIXME be explicit */
411 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
412 argvec
[1] = value_addr (arg1
);
416 /* make the right function name up */
417 strcpy (tstr
, "operator__");
442 case BINOP_BITWISE_AND
:
445 case BINOP_BITWISE_IOR
:
448 case BINOP_BITWISE_XOR
:
451 case BINOP_LOGICAL_AND
:
454 case BINOP_LOGICAL_OR
:
466 case BINOP_ASSIGN_MODIFY
:
484 case BINOP_BITWISE_AND
:
487 case BINOP_BITWISE_IOR
:
490 case BINOP_BITWISE_XOR
:
493 case BINOP_MOD
: /* invalid */
495 error (_("Invalid binary operation specified."));
498 case BINOP_SUBSCRIPT
:
519 case BINOP_MOD
: /* invalid */
521 error (_("Invalid binary operation specified."));
524 argvec
[0] = value_user_defined_op (&arg1
, argvec
+ 1, tstr
,
525 &static_memfuncp
, 2);
531 argvec
[1] = argvec
[0];
534 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
536 struct type
*return_type
;
539 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
540 return value_zero (return_type
, VALUE_LVAL (arg1
));
542 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
544 error (_("member function %s not found"), tstr
);
546 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
550 /* We know that arg1 is a structure, so try to find a unary user
551 defined operator that matches the operator in question.
552 Create an argument vector that calls arg1.operator @ (arg1)
553 and return that value (where '@' is (almost) any unary operator which
554 is legal for GNU C++). */
557 value_x_unop (struct value
*arg1
, enum exp_opcode op
, enum noside noside
)
559 struct gdbarch
*gdbarch
= get_type_arch (value_type (arg1
));
560 struct value
**argvec
;
561 char *ptr
, *mangle_ptr
;
562 char tstr
[13], mangle_tstr
[13];
563 int static_memfuncp
, nargs
;
565 arg1
= coerce_ref (arg1
);
567 /* now we know that what we have to do is construct our
568 arg vector and find the right function to call it with. */
570 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
571 error (_("Can't do that unary op on that type")); /* FIXME be explicit */
573 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
574 argvec
[1] = value_addr (arg1
);
579 /* make the right function name up */
580 strcpy (tstr
, "operator__");
582 strcpy (mangle_tstr
, "__");
583 mangle_ptr
= mangle_tstr
+ 2;
586 case UNOP_PREINCREMENT
:
589 case UNOP_PREDECREMENT
:
592 case UNOP_POSTINCREMENT
:
594 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
598 case UNOP_POSTDECREMENT
:
600 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
604 case UNOP_LOGICAL_NOT
:
607 case UNOP_COMPLEMENT
:
620 error (_("Invalid unary operation specified."));
623 argvec
[0] = value_user_defined_op (&arg1
, argvec
+ 1, tstr
,
624 &static_memfuncp
, nargs
);
630 argvec
[1] = argvec
[0];
634 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
636 struct type
*return_type
;
639 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
640 return value_zero (return_type
, VALUE_LVAL (arg1
));
642 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
644 error (_("member function %s not found"), tstr
);
645 return 0; /* For lint -- never reached */
649 /* Concatenate two values with the following conditions:
651 (1) Both values must be either bitstring values or character string
652 values and the resulting value consists of the concatenation of
653 ARG1 followed by ARG2.
657 One value must be an integer value and the other value must be
658 either a bitstring value or character string value, which is
659 to be repeated by the number of times specified by the integer
663 (2) Boolean values are also allowed and are treated as bit string
666 (3) Character values are also allowed and are treated as character
667 string values of length 1.
671 value_concat (struct value
*arg1
, struct value
*arg2
)
673 struct value
*inval1
;
674 struct value
*inval2
;
675 struct value
*outval
= NULL
;
676 int inval1len
, inval2len
;
680 struct type
*type1
= check_typedef (value_type (arg1
));
681 struct type
*type2
= check_typedef (value_type (arg2
));
682 struct type
*char_type
;
684 /* First figure out if we are dealing with two values to be concatenated
685 or a repeat count and a value to be repeated. INVAL1 is set to the
686 first of two concatenated values, or the repeat count. INVAL2 is set
687 to the second of the two concatenated values or the value to be
690 if (TYPE_CODE (type2
) == TYPE_CODE_INT
)
692 struct type
*tmp
= type1
;
705 /* Now process the input values. */
707 if (TYPE_CODE (type1
) == TYPE_CODE_INT
)
709 /* We have a repeat count. Validate the second value and then
710 construct a value repeated that many times. */
711 if (TYPE_CODE (type2
) == TYPE_CODE_STRING
712 || TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
714 count
= longest_to_int (value_as_long (inval1
));
715 inval2len
= TYPE_LENGTH (type2
);
716 ptr
= (char *) alloca (count
* inval2len
);
717 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
721 inchar
= (char) unpack_long (type2
,
722 value_contents (inval2
));
723 for (idx
= 0; idx
< count
; idx
++)
725 *(ptr
+ idx
) = inchar
;
730 char_type
= TYPE_TARGET_TYPE (type2
);
732 for (idx
= 0; idx
< count
; idx
++)
734 memcpy (ptr
+ (idx
* inval2len
), value_contents (inval2
),
738 outval
= value_string (ptr
, count
* inval2len
, char_type
);
740 else if (TYPE_CODE (type2
) == TYPE_CODE_BITSTRING
741 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
743 error (_("unimplemented support for bitstring/boolean repeats"));
747 error (_("can't repeat values of that type"));
750 else if (TYPE_CODE (type1
) == TYPE_CODE_STRING
751 || TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
753 /* We have two character strings to concatenate. */
754 if (TYPE_CODE (type2
) != TYPE_CODE_STRING
755 && TYPE_CODE (type2
) != TYPE_CODE_CHAR
)
757 error (_("Strings can only be concatenated with other strings."));
759 inval1len
= TYPE_LENGTH (type1
);
760 inval2len
= TYPE_LENGTH (type2
);
761 ptr
= (char *) alloca (inval1len
+ inval2len
);
762 if (TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
766 *ptr
= (char) unpack_long (type1
, value_contents (inval1
));
770 char_type
= TYPE_TARGET_TYPE (type1
);
772 memcpy (ptr
, value_contents (inval1
), inval1len
);
774 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
777 (char) unpack_long (type2
, value_contents (inval2
));
781 memcpy (ptr
+ inval1len
, value_contents (inval2
), inval2len
);
783 outval
= value_string (ptr
, inval1len
+ inval2len
, char_type
);
785 else if (TYPE_CODE (type1
) == TYPE_CODE_BITSTRING
786 || TYPE_CODE (type1
) == TYPE_CODE_BOOL
)
788 /* We have two bitstrings to concatenate. */
789 if (TYPE_CODE (type2
) != TYPE_CODE_BITSTRING
790 && TYPE_CODE (type2
) != TYPE_CODE_BOOL
)
792 error (_("Bitstrings or booleans can only be concatenated with other bitstrings or booleans."));
794 error (_("unimplemented support for bitstring/boolean concatenation."));
798 /* We don't know how to concatenate these operands. */
799 error (_("illegal operands for concatenation."));
804 /* Integer exponentiation: V1**V2, where both arguments are
805 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
807 integer_pow (LONGEST v1
, LONGEST v2
)
812 error (_("Attempt to raise 0 to negative power."));
818 /* The Russian Peasant's Algorithm */
834 /* Integer exponentiation: V1**V2, where both arguments are
835 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
837 uinteger_pow (ULONGEST v1
, LONGEST v2
)
842 error (_("Attempt to raise 0 to negative power."));
848 /* The Russian Peasant's Algorithm */
864 /* Obtain decimal value of arguments for binary operation, converting from
865 other types if one of them is not decimal floating point. */
867 value_args_as_decimal (struct value
*arg1
, struct value
*arg2
,
868 gdb_byte
*x
, int *len_x
, enum bfd_endian
*byte_order_x
,
869 gdb_byte
*y
, int *len_y
, enum bfd_endian
*byte_order_y
)
871 struct type
*type1
, *type2
;
873 type1
= check_typedef (value_type (arg1
));
874 type2
= check_typedef (value_type (arg2
));
876 /* At least one of the arguments must be of decimal float type. */
877 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
878 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
);
880 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
881 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
882 /* The DFP extension to the C language does not allow mixing of
883 * decimal float types with other float types in expressions
884 * (see WDTR 24732, page 12). */
885 error (_("Mixing decimal floating types with other floating types is not allowed."));
887 /* Obtain decimal value of arg1, converting from other types
890 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
892 *byte_order_x
= gdbarch_byte_order (get_type_arch (type1
));
893 *len_x
= TYPE_LENGTH (type1
);
894 memcpy (x
, value_contents (arg1
), *len_x
);
896 else if (is_integral_type (type1
))
898 *byte_order_x
= gdbarch_byte_order (get_type_arch (type2
));
899 *len_x
= TYPE_LENGTH (type2
);
900 decimal_from_integral (arg1
, x
, *len_x
, *byte_order_x
);
903 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
906 /* Obtain decimal value of arg2, converting from other types
909 if (TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
911 *byte_order_y
= gdbarch_byte_order (get_type_arch (type2
));
912 *len_y
= TYPE_LENGTH (type2
);
913 memcpy (y
, value_contents (arg2
), *len_y
);
915 else if (is_integral_type (type2
))
917 *byte_order_y
= gdbarch_byte_order (get_type_arch (type1
));
918 *len_y
= TYPE_LENGTH (type1
);
919 decimal_from_integral (arg2
, y
, *len_y
, *byte_order_y
);
922 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
926 /* Perform a binary operation on two operands which have reasonable
927 representations as integers or floats. This includes booleans,
928 characters, integers, or floats.
929 Does not support addition and subtraction on pointers;
930 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
932 static struct value
*
933 scalar_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
936 struct type
*type1
, *type2
, *result_type
;
938 arg1
= coerce_ref (arg1
);
939 arg2
= coerce_ref (arg2
);
941 type1
= check_typedef (value_type (arg1
));
942 type2
= check_typedef (value_type (arg2
));
944 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
945 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
946 && !is_integral_type (type1
))
947 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
948 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
949 && !is_integral_type (type2
)))
950 error (_("Argument to arithmetic operation not a number or boolean."));
952 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
953 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
955 int len_v1
, len_v2
, len_v
;
956 enum bfd_endian byte_order_v1
, byte_order_v2
, byte_order_v
;
957 gdb_byte v1
[16], v2
[16];
960 /* If only one type is decimal float, use its type.
961 Otherwise use the bigger type. */
962 if (TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
)
964 else if (TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
)
966 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
971 len_v
= TYPE_LENGTH (result_type
);
972 byte_order_v
= gdbarch_byte_order (get_type_arch (result_type
));
974 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
975 v2
, &len_v2
, &byte_order_v2
);
984 decimal_binop (op
, v1
, len_v1
, byte_order_v1
,
985 v2
, len_v2
, byte_order_v2
,
986 v
, len_v
, byte_order_v
);
990 error (_("Operation not valid for decimal floating point number."));
993 val
= value_from_decfloat (result_type
, v
);
995 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
996 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
998 /* FIXME-if-picky-about-floating-accuracy: Should be doing this
999 in target format. real.c in GCC probably has the necessary
1001 DOUBLEST v1
, v2
, v
= 0;
1003 v1
= value_as_double (arg1
);
1004 v2
= value_as_double (arg2
);
1028 error (_("Cannot perform exponentiation: %s"), safe_strerror (errno
));
1032 v
= v1
< v2
? v1
: v2
;
1036 v
= v1
> v2
? v1
: v2
;
1040 error (_("Integer-only operation on floating point number."));
1043 /* If only one type is float, use its type.
1044 Otherwise use the bigger type. */
1045 if (TYPE_CODE (type1
) != TYPE_CODE_FLT
)
1046 result_type
= type2
;
1047 else if (TYPE_CODE (type2
) != TYPE_CODE_FLT
)
1048 result_type
= type1
;
1049 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1050 result_type
= type2
;
1052 result_type
= type1
;
1054 val
= allocate_value (result_type
);
1055 store_typed_floating (value_contents_raw (val
), value_type (val
), v
);
1057 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
1058 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
1060 LONGEST v1
, v2
, v
= 0;
1062 v1
= value_as_long (arg1
);
1063 v2
= value_as_long (arg2
);
1067 case BINOP_BITWISE_AND
:
1071 case BINOP_BITWISE_IOR
:
1075 case BINOP_BITWISE_XOR
:
1083 case BINOP_NOTEQUAL
:
1088 error (_("Invalid operation on booleans."));
1091 result_type
= type1
;
1093 val
= allocate_value (result_type
);
1094 store_signed_integer (value_contents_raw (val
),
1095 TYPE_LENGTH (result_type
),
1096 gdbarch_byte_order (get_type_arch (result_type
)),
1100 /* Integral operations here. */
1102 /* Determine type length of the result, and if the operation should
1103 be done unsigned. For exponentiation and shift operators,
1104 use the length and type of the left operand. Otherwise,
1105 use the signedness of the operand with the greater length.
1106 If both operands are of equal length, use unsigned operation
1107 if one of the operands is unsigned. */
1108 if (op
== BINOP_RSH
|| op
== BINOP_LSH
|| op
== BINOP_EXP
)
1109 result_type
= type1
;
1110 else if (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
))
1111 result_type
= type1
;
1112 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1113 result_type
= type2
;
1114 else if (TYPE_UNSIGNED (type1
))
1115 result_type
= type1
;
1116 else if (TYPE_UNSIGNED (type2
))
1117 result_type
= type2
;
1119 result_type
= type1
;
1121 if (TYPE_UNSIGNED (result_type
))
1123 LONGEST v2_signed
= value_as_long (arg2
);
1124 ULONGEST v1
, v2
, v
= 0;
1126 v1
= (ULONGEST
) value_as_long (arg1
);
1127 v2
= (ULONGEST
) v2_signed
;
1148 error (_("Division by zero"));
1152 v
= uinteger_pow (v1
, v2_signed
);
1159 error (_("Division by zero"));
1163 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1164 v1 mod 0 has a defined value, v1. */
1172 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1185 case BINOP_BITWISE_AND
:
1189 case BINOP_BITWISE_IOR
:
1193 case BINOP_BITWISE_XOR
:
1197 case BINOP_LOGICAL_AND
:
1201 case BINOP_LOGICAL_OR
:
1206 v
= v1
< v2
? v1
: v2
;
1210 v
= v1
> v2
? v1
: v2
;
1217 case BINOP_NOTEQUAL
:
1238 error (_("Invalid binary operation on numbers."));
1241 val
= allocate_value (result_type
);
1242 store_unsigned_integer (value_contents_raw (val
),
1243 TYPE_LENGTH (value_type (val
)),
1245 (get_type_arch (result_type
)),
1250 LONGEST v1
, v2
, v
= 0;
1252 v1
= value_as_long (arg1
);
1253 v2
= value_as_long (arg2
);
1274 error (_("Division by zero"));
1278 v
= integer_pow (v1
, v2
);
1285 error (_("Division by zero"));
1289 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1290 X mod 0 has a defined value, X. */
1298 /* Compute floor. */
1299 if (TRUNCATION_TOWARDS_ZERO
&& (v
< 0) && ((v1
% v2
) != 0))
1315 case BINOP_BITWISE_AND
:
1319 case BINOP_BITWISE_IOR
:
1323 case BINOP_BITWISE_XOR
:
1327 case BINOP_LOGICAL_AND
:
1331 case BINOP_LOGICAL_OR
:
1336 v
= v1
< v2
? v1
: v2
;
1340 v
= v1
> v2
? v1
: v2
;
1347 case BINOP_NOTEQUAL
:
1368 error (_("Invalid binary operation on numbers."));
1371 val
= allocate_value (result_type
);
1372 store_signed_integer (value_contents_raw (val
),
1373 TYPE_LENGTH (value_type (val
)),
1375 (get_type_arch (result_type
)),
1383 /* Performs a binary operation on two vector operands by calling scalar_binop
1384 for each pair of vector components. */
1386 static struct value
*
1387 vector_binop (struct value
*val1
, struct value
*val2
, enum exp_opcode op
)
1389 struct value
*val
, *tmp
, *mark
;
1390 struct type
*type1
, *type2
, *eltype1
, *eltype2
, *result_type
;
1391 int t1_is_vec
, t2_is_vec
, elsize
, n
, i
;
1393 type1
= check_typedef (value_type (val1
));
1394 type2
= check_typedef (value_type (val2
));
1396 t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
1397 && TYPE_VECTOR (type1
)) ? 1 : 0;
1398 t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
1399 && TYPE_VECTOR (type2
)) ? 1 : 0;
1401 if (!t1_is_vec
|| !t2_is_vec
)
1402 error (_("Vector operations are only supported among vectors"));
1404 eltype1
= check_typedef (TYPE_TARGET_TYPE (type1
));
1405 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
));
1407 if (TYPE_CODE (eltype1
) != TYPE_CODE (eltype2
)
1408 || TYPE_LENGTH (eltype1
) != TYPE_LENGTH (eltype2
)
1409 || TYPE_UNSIGNED (eltype1
) != TYPE_UNSIGNED (eltype2
))
1410 error (_("Cannot perform operation on vectors with different types"));
1412 elsize
= TYPE_LENGTH (eltype1
);
1413 n
= TYPE_LENGTH (type1
) / elsize
;
1415 if (n
!= TYPE_LENGTH (type2
) / TYPE_LENGTH (eltype2
))
1416 error (_("Cannot perform operation on vectors with different sizes"));
1418 val
= allocate_value (type1
);
1419 mark
= value_mark ();
1420 for (i
= 0; i
< n
; i
++)
1422 tmp
= value_binop (value_subscript (val1
, i
),
1423 value_subscript (val2
, i
), op
);
1424 memcpy (value_contents_writeable (val
) + i
* elsize
,
1425 value_contents_all (tmp
),
1428 value_free_to_mark (mark
);
1433 /* Perform a binary operation on two operands. */
1436 value_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
1438 struct type
*type1
= check_typedef (value_type (arg1
));
1439 struct type
*type2
= check_typedef (value_type (arg2
));
1441 if ((TYPE_CODE (type1
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type1
))
1442 || (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type2
)))
1443 return vector_binop (arg1
, arg2
, op
);
1445 return scalar_binop (arg1
, arg2
, op
);
1448 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1451 value_logical_not (struct value
*arg1
)
1457 arg1
= coerce_array (arg1
);
1458 type1
= check_typedef (value_type (arg1
));
1460 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
)
1461 return 0 == value_as_double (arg1
);
1462 else if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
1463 return decimal_is_zero (value_contents (arg1
), TYPE_LENGTH (type1
),
1464 gdbarch_byte_order (get_type_arch (type1
)));
1466 len
= TYPE_LENGTH (type1
);
1467 p
= value_contents (arg1
);
1478 /* Perform a comparison on two string values (whose content are not
1479 necessarily null terminated) based on their length */
1482 value_strcmp (struct value
*arg1
, struct value
*arg2
)
1484 int len1
= TYPE_LENGTH (value_type (arg1
));
1485 int len2
= TYPE_LENGTH (value_type (arg2
));
1486 const gdb_byte
*s1
= value_contents (arg1
);
1487 const gdb_byte
*s2
= value_contents (arg2
);
1488 int i
, len
= len1
< len2
? len1
: len2
;
1490 for (i
= 0; i
< len
; i
++)
1494 else if (s1
[i
] > s2
[i
])
1502 else if (len1
> len2
)
1508 /* Simulate the C operator == by returning a 1
1509 iff ARG1 and ARG2 have equal contents. */
1512 value_equal (struct value
*arg1
, struct value
*arg2
)
1517 struct type
*type1
, *type2
;
1518 enum type_code code1
;
1519 enum type_code code2
;
1520 int is_int1
, is_int2
;
1522 arg1
= coerce_array (arg1
);
1523 arg2
= coerce_array (arg2
);
1525 type1
= check_typedef (value_type (arg1
));
1526 type2
= check_typedef (value_type (arg2
));
1527 code1
= TYPE_CODE (type1
);
1528 code2
= TYPE_CODE (type2
);
1529 is_int1
= is_integral_type (type1
);
1530 is_int2
= is_integral_type (type2
);
1532 if (is_int1
&& is_int2
)
1533 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1535 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1536 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1538 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1539 `long double' values are returned in static storage (m68k). */
1540 DOUBLEST d
= value_as_double (arg1
);
1542 return d
== value_as_double (arg2
);
1544 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1545 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1547 gdb_byte v1
[16], v2
[16];
1549 enum bfd_endian byte_order_v1
, byte_order_v2
;
1551 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
1552 v2
, &len_v2
, &byte_order_v2
);
1554 return decimal_compare (v1
, len_v1
, byte_order_v1
,
1555 v2
, len_v2
, byte_order_v2
) == 0;
1558 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1560 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1561 return value_as_address (arg1
) == (CORE_ADDR
) value_as_long (arg2
);
1562 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1563 return (CORE_ADDR
) value_as_long (arg1
) == value_as_address (arg2
);
1565 else if (code1
== code2
1566 && ((len
= (int) TYPE_LENGTH (type1
))
1567 == (int) TYPE_LENGTH (type2
)))
1569 p1
= value_contents (arg1
);
1570 p2
= value_contents (arg2
);
1578 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1580 return value_strcmp (arg1
, arg2
) == 0;
1584 error (_("Invalid type combination in equality test."));
1585 return 0; /* For lint -- never reached */
1589 /* Compare values based on their raw contents. Useful for arrays since
1590 value_equal coerces them to pointers, thus comparing just the address
1591 of the array instead of its contents. */
1594 value_equal_contents (struct value
*arg1
, struct value
*arg2
)
1596 struct type
*type1
, *type2
;
1598 type1
= check_typedef (value_type (arg1
));
1599 type2
= check_typedef (value_type (arg2
));
1601 return (TYPE_CODE (type1
) == TYPE_CODE (type2
)
1602 && TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
1603 && memcmp (value_contents (arg1
), value_contents (arg2
),
1604 TYPE_LENGTH (type1
)) == 0);
1607 /* Simulate the C operator < by returning 1
1608 iff ARG1's contents are less than ARG2's. */
1611 value_less (struct value
*arg1
, struct value
*arg2
)
1613 enum type_code code1
;
1614 enum type_code code2
;
1615 struct type
*type1
, *type2
;
1616 int is_int1
, is_int2
;
1618 arg1
= coerce_array (arg1
);
1619 arg2
= coerce_array (arg2
);
1621 type1
= check_typedef (value_type (arg1
));
1622 type2
= check_typedef (value_type (arg2
));
1623 code1
= TYPE_CODE (type1
);
1624 code2
= TYPE_CODE (type2
);
1625 is_int1
= is_integral_type (type1
);
1626 is_int2
= is_integral_type (type2
);
1628 if (is_int1
&& is_int2
)
1629 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1631 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1632 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1634 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1635 `long double' values are returned in static storage (m68k). */
1636 DOUBLEST d
= value_as_double (arg1
);
1638 return d
< value_as_double (arg2
);
1640 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1641 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1643 gdb_byte v1
[16], v2
[16];
1645 enum bfd_endian byte_order_v1
, byte_order_v2
;
1647 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
1648 v2
, &len_v2
, &byte_order_v2
);
1650 return decimal_compare (v1
, len_v1
, byte_order_v1
,
1651 v2
, len_v2
, byte_order_v2
) == -1;
1653 else if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
1654 return value_as_address (arg1
) < value_as_address (arg2
);
1656 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1658 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1659 return value_as_address (arg1
) < (CORE_ADDR
) value_as_long (arg2
);
1660 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1661 return (CORE_ADDR
) value_as_long (arg1
) < value_as_address (arg2
);
1662 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1663 return value_strcmp (arg1
, arg2
) < 0;
1666 error (_("Invalid type combination in ordering comparison."));
1671 /* The unary operators +, - and ~. They free the argument ARG1. */
1674 value_pos (struct value
*arg1
)
1678 arg1
= coerce_ref (arg1
);
1679 type
= check_typedef (value_type (arg1
));
1681 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1682 return value_from_double (type
, value_as_double (arg1
));
1683 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1684 return value_from_decfloat (type
, value_contents (arg1
));
1685 else if (is_integral_type (type
))
1687 return value_from_longest (type
, value_as_long (arg1
));
1691 error ("Argument to positive operation not a number.");
1692 return 0; /* For lint -- never reached */
1697 value_neg (struct value
*arg1
)
1701 arg1
= coerce_ref (arg1
);
1702 type
= check_typedef (value_type (arg1
));
1704 if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1706 struct value
*val
= allocate_value (type
);
1707 int len
= TYPE_LENGTH (type
);
1708 gdb_byte decbytes
[16]; /* a decfloat is at most 128 bits long */
1710 memcpy (decbytes
, value_contents (arg1
), len
);
1712 if (gdbarch_byte_order (get_type_arch (type
)) == BFD_ENDIAN_LITTLE
)
1713 decbytes
[len
-1] = decbytes
[len
- 1] | 0x80;
1715 decbytes
[0] = decbytes
[0] | 0x80;
1717 memcpy (value_contents_raw (val
), decbytes
, len
);
1720 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1721 return value_from_double (type
, -value_as_double (arg1
));
1722 else if (is_integral_type (type
))
1724 return value_from_longest (type
, -value_as_long (arg1
));
1728 error (_("Argument to negate operation not a number."));
1729 return 0; /* For lint -- never reached */
1734 value_complement (struct value
*arg1
)
1738 arg1
= coerce_ref (arg1
);
1739 type
= check_typedef (value_type (arg1
));
1741 if (!is_integral_type (type
))
1742 error (_("Argument to complement operation not an integer or boolean."));
1744 return value_from_longest (type
, ~value_as_long (arg1
));
1747 /* The INDEX'th bit of SET value whose value_type is TYPE,
1748 and whose value_contents is valaddr.
1749 Return -1 if out of range, -2 other error. */
1752 value_bit_index (struct type
*type
, const gdb_byte
*valaddr
, int index
)
1754 struct gdbarch
*gdbarch
= get_type_arch (type
);
1755 LONGEST low_bound
, high_bound
;
1758 struct type
*range
= TYPE_INDEX_TYPE (type
);
1760 if (get_discrete_bounds (range
, &low_bound
, &high_bound
) < 0)
1762 if (index
< low_bound
|| index
> high_bound
)
1764 rel_index
= index
- low_bound
;
1765 word
= extract_unsigned_integer (valaddr
+ (rel_index
/ TARGET_CHAR_BIT
), 1,
1766 gdbarch_byte_order (gdbarch
));
1767 rel_index
%= TARGET_CHAR_BIT
;
1768 if (gdbarch_bits_big_endian (gdbarch
))
1769 rel_index
= TARGET_CHAR_BIT
- 1 - rel_index
;
1770 return (word
>> rel_index
) & 1;
1774 value_in (struct value
*element
, struct value
*set
)
1777 struct type
*settype
= check_typedef (value_type (set
));
1778 struct type
*eltype
= check_typedef (value_type (element
));
1780 if (TYPE_CODE (eltype
) == TYPE_CODE_RANGE
)
1781 eltype
= TYPE_TARGET_TYPE (eltype
);
1782 if (TYPE_CODE (settype
) != TYPE_CODE_SET
)
1783 error (_("Second argument of 'IN' has wrong type"));
1784 if (TYPE_CODE (eltype
) != TYPE_CODE_INT
1785 && TYPE_CODE (eltype
) != TYPE_CODE_CHAR
1786 && TYPE_CODE (eltype
) != TYPE_CODE_ENUM
1787 && TYPE_CODE (eltype
) != TYPE_CODE_BOOL
)
1788 error (_("First argument of 'IN' has wrong type"));
1789 member
= value_bit_index (settype
, value_contents (set
),
1790 value_as_long (element
));
1792 error (_("First argument of 'IN' not in range"));
1797 _initialize_valarith (void)
This page took 0.06581 seconds and 5 git commands to generate.