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"
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.
53 find_size_for_pointer_math (struct type
*ptr_type
)
56 struct type
*ptr_target
;
58 gdb_assert (TYPE_CODE (ptr_type
) == TYPE_CODE_PTR
);
59 ptr_target
= check_typedef (TYPE_TARGET_TYPE (ptr_type
));
61 sz
= TYPE_LENGTH (ptr_target
);
64 if (TYPE_CODE (ptr_type
) == TYPE_CODE_VOID
)
70 name
= TYPE_NAME (ptr_target
);
72 name
= TYPE_TAG_NAME (ptr_target
);
74 error (_("Cannot perform pointer math on incomplete types, "
75 "try casting to a known type, or void *."));
77 error (_("Cannot perform pointer math on incomplete type \"%s\", "
78 "try casting to a known type, or void *."), name
);
84 /* Given a pointer ARG1 and an integral value ARG2, return the
85 result of C-style pointer arithmetic ARG1 + ARG2. */
88 value_ptradd (struct value
*arg1
, LONGEST arg2
)
90 struct type
*valptrtype
;
93 arg1
= coerce_array (arg1
);
94 valptrtype
= check_typedef (value_type (arg1
));
95 sz
= find_size_for_pointer_math (valptrtype
);
97 return value_from_pointer (valptrtype
,
98 value_as_address (arg1
) + sz
* arg2
);
101 /* Given two compatible pointer values ARG1 and ARG2, return the
102 result of C-style pointer arithmetic ARG1 - ARG2. */
105 value_ptrdiff (struct value
*arg1
, struct value
*arg2
)
107 struct type
*type1
, *type2
;
110 arg1
= coerce_array (arg1
);
111 arg2
= coerce_array (arg2
);
112 type1
= check_typedef (value_type (arg1
));
113 type2
= check_typedef (value_type (arg2
));
115 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_PTR
);
116 gdb_assert (TYPE_CODE (type2
) == TYPE_CODE_PTR
);
118 if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)))
119 != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2
))))
121 First argument of `-' is a pointer and second argument is neither\n\
122 an integer nor a pointer of the same type."));
124 sz
= TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)));
127 warning (_("Type size unknown, assuming 1. "
128 "Try casting to a known type, or void *."));
132 return (value_as_long (arg1
) - value_as_long (arg2
)) / sz
;
135 /* Return the value of ARRAY[IDX].
137 ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING. If the
138 current language supports C-style arrays, it may also be TYPE_CODE_PTR.
139 To access TYPE_CODE_BITSTRING values, use value_bitstring_subscript.
141 See comments in value_coerce_array() for rationale for reason for
142 doing lower bounds adjustment here rather than there.
143 FIXME: Perhaps we should validate that the index is valid and if
144 verbosity is set, warn about invalid indices (but still use them). */
147 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
;
161 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
|| elt_offs
>= TYPE_LENGTH (array_type
))
202 error (_("no such vector element"));
204 v
= allocate_value (elt_type
);
205 if (VALUE_LVAL (array
) == lval_memory
&& value_lazy (array
))
206 set_value_lazy (v
, 1);
208 memcpy (value_contents_writeable (v
),
209 value_contents (array
) + elt_offs
, elt_size
);
211 set_value_component_location (v
, array
);
212 VALUE_REGNUM (v
) = VALUE_REGNUM (array
);
213 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (array
);
214 set_value_offset (v
, value_offset (array
) + elt_offs
);
218 /* Return the value of BITSTRING[IDX] as (boolean) type TYPE. */
221 value_bitstring_subscript (struct type
*type
,
222 struct value
*bitstring
, LONGEST index
)
225 struct type
*bitstring_type
, *range_type
;
227 int offset
, byte
, bit_index
;
228 LONGEST lowerbound
, upperbound
;
230 bitstring_type
= check_typedef (value_type (bitstring
));
231 gdb_assert (TYPE_CODE (bitstring_type
) == TYPE_CODE_BITSTRING
);
233 range_type
= TYPE_INDEX_TYPE (bitstring_type
);
234 get_discrete_bounds (range_type
, &lowerbound
, &upperbound
);
235 if (index
< lowerbound
|| index
> upperbound
)
236 error (_("bitstring index out of range"));
239 offset
= index
/ TARGET_CHAR_BIT
;
240 byte
= *((char *) value_contents (bitstring
) + offset
);
242 bit_index
= index
% TARGET_CHAR_BIT
;
243 byte
>>= (gdbarch_bits_big_endian (get_type_arch (bitstring_type
)) ?
244 TARGET_CHAR_BIT
- 1 - bit_index
: bit_index
);
246 v
= value_from_longest (type
, byte
& 1);
248 set_value_bitpos (v
, bit_index
);
249 set_value_bitsize (v
, 1);
250 set_value_component_location (v
, bitstring
);
251 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (bitstring
);
253 set_value_offset (v
, offset
+ value_offset (bitstring
));
259 /* Check to see if either argument is a structure, or a reference to
260 one. This is called so we know whether to go ahead with the normal
261 binop or look for a user defined function instead.
263 For now, we do not overload the `=' operator. */
266 binop_user_defined_p (enum exp_opcode op
, struct value
*arg1
, struct value
*arg2
)
268 struct type
*type1
, *type2
;
269 if (op
== BINOP_ASSIGN
|| op
== BINOP_CONCAT
)
272 type1
= check_typedef (value_type (arg1
));
273 if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
274 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
276 type2
= check_typedef (value_type (arg2
));
277 if (TYPE_CODE (type2
) == TYPE_CODE_REF
)
278 type2
= check_typedef (TYPE_TARGET_TYPE (type2
));
280 return (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
281 || TYPE_CODE (type2
) == TYPE_CODE_STRUCT
);
284 /* Check to see if argument is a structure. This is called so
285 we know whether to go ahead with the normal unop or look for a
286 user defined function instead.
288 For now, we do not overload the `&' operator. */
291 unop_user_defined_p (enum exp_opcode op
, struct value
*arg1
)
296 type1
= check_typedef (value_type (arg1
));
299 if (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
)
301 else if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
302 type1
= TYPE_TARGET_TYPE (type1
);
308 /* We know either arg1 or arg2 is a structure, so try to find the right
309 user defined function. Create an argument vector that calls
310 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
311 binary operator which is legal for GNU C++).
313 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
314 is the opcode saying how to modify it. Otherwise, OTHEROP is
318 value_x_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
,
319 enum exp_opcode otherop
, enum noside noside
)
321 struct value
**argvec
;
326 arg1
= coerce_ref (arg1
);
327 arg2
= coerce_ref (arg2
);
329 /* now we know that what we have to do is construct our
330 arg vector and find the right function to call it with. */
332 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
333 error (_("Can't do that binary op on that type")); /* FIXME be explicit */
335 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
336 argvec
[1] = value_addr (arg1
);
340 /* make the right function name up */
341 strcpy (tstr
, "operator__");
366 case BINOP_BITWISE_AND
:
369 case BINOP_BITWISE_IOR
:
372 case BINOP_BITWISE_XOR
:
375 case BINOP_LOGICAL_AND
:
378 case BINOP_LOGICAL_OR
:
390 case BINOP_ASSIGN_MODIFY
:
408 case BINOP_BITWISE_AND
:
411 case BINOP_BITWISE_IOR
:
414 case BINOP_BITWISE_XOR
:
417 case BINOP_MOD
: /* invalid */
419 error (_("Invalid binary operation specified."));
422 case BINOP_SUBSCRIPT
:
443 case BINOP_MOD
: /* invalid */
445 error (_("Invalid binary operation specified."));
448 argvec
[0] = value_struct_elt (&arg1
, argvec
+ 1, tstr
, &static_memfuncp
, "structure");
454 argvec
[1] = argvec
[0];
457 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
459 struct type
*return_type
;
461 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
462 return value_zero (return_type
, VALUE_LVAL (arg1
));
464 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
466 error (_("member function %s not found"), tstr
);
468 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
472 /* We know that arg1 is a structure, so try to find a unary user
473 defined operator that matches the operator in question.
474 Create an argument vector that calls arg1.operator @ (arg1)
475 and return that value (where '@' is (almost) any unary operator which
476 is legal for GNU C++). */
479 value_x_unop (struct value
*arg1
, enum exp_opcode op
, enum noside noside
)
481 struct gdbarch
*gdbarch
= get_type_arch (value_type (arg1
));
482 struct value
**argvec
;
483 char *ptr
, *mangle_ptr
;
484 char tstr
[13], mangle_tstr
[13];
485 int static_memfuncp
, nargs
;
487 arg1
= coerce_ref (arg1
);
489 /* now we know that what we have to do is construct our
490 arg vector and find the right function to call it with. */
492 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
493 error (_("Can't do that unary op on that type")); /* FIXME be explicit */
495 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
496 argvec
[1] = value_addr (arg1
);
501 /* make the right function name up */
502 strcpy (tstr
, "operator__");
504 strcpy (mangle_tstr
, "__");
505 mangle_ptr
= mangle_tstr
+ 2;
508 case UNOP_PREINCREMENT
:
511 case UNOP_PREDECREMENT
:
514 case UNOP_POSTINCREMENT
:
516 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
520 case UNOP_POSTDECREMENT
:
522 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
526 case UNOP_LOGICAL_NOT
:
529 case UNOP_COMPLEMENT
:
542 error (_("Invalid unary operation specified."));
545 argvec
[0] = value_struct_elt (&arg1
, argvec
+ 1, tstr
, &static_memfuncp
, "structure");
551 argvec
[1] = argvec
[0];
555 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
557 struct type
*return_type
;
559 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
560 return value_zero (return_type
, VALUE_LVAL (arg1
));
562 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
564 error (_("member function %s not found"), tstr
);
565 return 0; /* For lint -- never reached */
569 /* Concatenate two values with the following conditions:
571 (1) Both values must be either bitstring values or character string
572 values and the resulting value consists of the concatenation of
573 ARG1 followed by ARG2.
577 One value must be an integer value and the other value must be
578 either a bitstring value or character string value, which is
579 to be repeated by the number of times specified by the integer
583 (2) Boolean values are also allowed and are treated as bit string
586 (3) Character values are also allowed and are treated as character
587 string values of length 1.
591 value_concat (struct value
*arg1
, struct value
*arg2
)
593 struct value
*inval1
;
594 struct value
*inval2
;
595 struct value
*outval
= NULL
;
596 int inval1len
, inval2len
;
600 struct type
*type1
= check_typedef (value_type (arg1
));
601 struct type
*type2
= check_typedef (value_type (arg2
));
602 struct type
*char_type
;
604 /* First figure out if we are dealing with two values to be concatenated
605 or a repeat count and a value to be repeated. INVAL1 is set to the
606 first of two concatenated values, or the repeat count. INVAL2 is set
607 to the second of the two concatenated values or the value to be
610 if (TYPE_CODE (type2
) == TYPE_CODE_INT
)
612 struct type
*tmp
= type1
;
624 /* Now process the input values. */
626 if (TYPE_CODE (type1
) == TYPE_CODE_INT
)
628 /* We have a repeat count. Validate the second value and then
629 construct a value repeated that many times. */
630 if (TYPE_CODE (type2
) == TYPE_CODE_STRING
631 || TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
633 count
= longest_to_int (value_as_long (inval1
));
634 inval2len
= TYPE_LENGTH (type2
);
635 ptr
= (char *) alloca (count
* inval2len
);
636 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
639 inchar
= (char) unpack_long (type2
,
640 value_contents (inval2
));
641 for (idx
= 0; idx
< count
; idx
++)
643 *(ptr
+ idx
) = inchar
;
648 char_type
= TYPE_TARGET_TYPE (type2
);
649 for (idx
= 0; idx
< count
; idx
++)
651 memcpy (ptr
+ (idx
* inval2len
), value_contents (inval2
),
655 outval
= value_string (ptr
, count
* inval2len
, char_type
);
657 else if (TYPE_CODE (type2
) == TYPE_CODE_BITSTRING
658 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
660 error (_("unimplemented support for bitstring/boolean repeats"));
664 error (_("can't repeat values of that type"));
667 else if (TYPE_CODE (type1
) == TYPE_CODE_STRING
668 || TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
670 /* We have two character strings to concatenate. */
671 if (TYPE_CODE (type2
) != TYPE_CODE_STRING
672 && TYPE_CODE (type2
) != TYPE_CODE_CHAR
)
674 error (_("Strings can only be concatenated with other strings."));
676 inval1len
= TYPE_LENGTH (type1
);
677 inval2len
= TYPE_LENGTH (type2
);
678 ptr
= (char *) alloca (inval1len
+ inval2len
);
679 if (TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
682 *ptr
= (char) unpack_long (type1
, value_contents (inval1
));
686 char_type
= TYPE_TARGET_TYPE (type1
);
687 memcpy (ptr
, value_contents (inval1
), inval1len
);
689 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
692 (char) unpack_long (type2
, value_contents (inval2
));
696 memcpy (ptr
+ inval1len
, value_contents (inval2
), inval2len
);
698 outval
= value_string (ptr
, inval1len
+ inval2len
, char_type
);
700 else if (TYPE_CODE (type1
) == TYPE_CODE_BITSTRING
701 || TYPE_CODE (type1
) == TYPE_CODE_BOOL
)
703 /* We have two bitstrings to concatenate. */
704 if (TYPE_CODE (type2
) != TYPE_CODE_BITSTRING
705 && TYPE_CODE (type2
) != TYPE_CODE_BOOL
)
707 error (_("Bitstrings or booleans can only be concatenated with other bitstrings or booleans."));
709 error (_("unimplemented support for bitstring/boolean concatenation."));
713 /* We don't know how to concatenate these operands. */
714 error (_("illegal operands for concatenation."));
719 /* Integer exponentiation: V1**V2, where both arguments are
720 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
722 integer_pow (LONGEST v1
, LONGEST v2
)
727 error (_("Attempt to raise 0 to negative power."));
733 /* The Russian Peasant's Algorithm */
749 /* Integer exponentiation: V1**V2, where both arguments are
750 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
752 uinteger_pow (ULONGEST v1
, LONGEST v2
)
757 error (_("Attempt to raise 0 to negative power."));
763 /* The Russian Peasant's Algorithm */
779 /* Obtain decimal value of arguments for binary operation, converting from
780 other types if one of them is not decimal floating point. */
782 value_args_as_decimal (struct value
*arg1
, struct value
*arg2
,
783 gdb_byte
*x
, int *len_x
, enum bfd_endian
*byte_order_x
,
784 gdb_byte
*y
, int *len_y
, enum bfd_endian
*byte_order_y
)
786 struct type
*type1
, *type2
;
788 type1
= check_typedef (value_type (arg1
));
789 type2
= check_typedef (value_type (arg2
));
791 /* At least one of the arguments must be of decimal float type. */
792 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
793 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
);
795 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
796 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
797 /* The DFP extension to the C language does not allow mixing of
798 * decimal float types with other float types in expressions
799 * (see WDTR 24732, page 12). */
800 error (_("Mixing decimal floating types with other floating types is not allowed."));
802 /* Obtain decimal value of arg1, converting from other types
805 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
807 *byte_order_x
= gdbarch_byte_order (get_type_arch (type1
));
808 *len_x
= TYPE_LENGTH (type1
);
809 memcpy (x
, value_contents (arg1
), *len_x
);
811 else if (is_integral_type (type1
))
813 *byte_order_x
= gdbarch_byte_order (get_type_arch (type2
));
814 *len_x
= TYPE_LENGTH (type2
);
815 decimal_from_integral (arg1
, x
, *len_x
, *byte_order_x
);
818 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
821 /* Obtain decimal value of arg2, converting from other types
824 if (TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
826 *byte_order_y
= gdbarch_byte_order (get_type_arch (type2
));
827 *len_y
= TYPE_LENGTH (type2
);
828 memcpy (y
, value_contents (arg2
), *len_y
);
830 else if (is_integral_type (type2
))
832 *byte_order_y
= gdbarch_byte_order (get_type_arch (type1
));
833 *len_y
= TYPE_LENGTH (type1
);
834 decimal_from_integral (arg2
, y
, *len_y
, *byte_order_y
);
837 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
841 /* Perform a binary operation on two operands which have reasonable
842 representations as integers or floats. This includes booleans,
843 characters, integers, or floats.
844 Does not support addition and subtraction on pointers;
845 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
848 value_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
851 struct type
*type1
, *type2
, *result_type
;
853 arg1
= coerce_ref (arg1
);
854 arg2
= coerce_ref (arg2
);
856 type1
= check_typedef (value_type (arg1
));
857 type2
= check_typedef (value_type (arg2
));
859 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
860 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
861 && !is_integral_type (type1
))
862 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
863 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
864 && !is_integral_type (type2
)))
865 error (_("Argument to arithmetic operation not a number or boolean."));
867 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
868 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
871 int len_v1
, len_v2
, len_v
;
872 enum bfd_endian byte_order_v1
, byte_order_v2
, byte_order_v
;
873 gdb_byte v1
[16], v2
[16];
876 /* If only one type is decimal float, use its type.
877 Otherwise use the bigger type. */
878 if (TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
)
880 else if (TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
)
882 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
887 len_v
= TYPE_LENGTH (result_type
);
888 byte_order_v
= gdbarch_byte_order (get_type_arch (result_type
));
890 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
891 v2
, &len_v2
, &byte_order_v2
);
900 decimal_binop (op
, v1
, len_v1
, byte_order_v1
,
901 v2
, len_v2
, byte_order_v2
,
902 v
, len_v
, byte_order_v
);
906 error (_("Operation not valid for decimal floating point number."));
909 val
= value_from_decfloat (result_type
, v
);
911 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
912 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
914 /* FIXME-if-picky-about-floating-accuracy: Should be doing this
915 in target format. real.c in GCC probably has the necessary
917 DOUBLEST v1
, v2
, v
= 0;
918 v1
= value_as_double (arg1
);
919 v2
= value_as_double (arg2
);
943 error (_("Cannot perform exponentiation: %s"), safe_strerror (errno
));
947 v
= v1
< v2
? v1
: v2
;
951 v
= v1
> v2
? v1
: v2
;
955 error (_("Integer-only operation on floating point number."));
958 /* If only one type is float, use its type.
959 Otherwise use the bigger type. */
960 if (TYPE_CODE (type1
) != TYPE_CODE_FLT
)
962 else if (TYPE_CODE (type2
) != TYPE_CODE_FLT
)
964 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
969 val
= allocate_value (result_type
);
970 store_typed_floating (value_contents_raw (val
), value_type (val
), v
);
972 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
973 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
975 LONGEST v1
, v2
, v
= 0;
976 v1
= value_as_long (arg1
);
977 v2
= value_as_long (arg2
);
981 case BINOP_BITWISE_AND
:
985 case BINOP_BITWISE_IOR
:
989 case BINOP_BITWISE_XOR
:
1002 error (_("Invalid operation on booleans."));
1005 result_type
= type1
;
1007 val
= allocate_value (result_type
);
1008 store_signed_integer (value_contents_raw (val
),
1009 TYPE_LENGTH (result_type
),
1010 gdbarch_byte_order (get_type_arch (result_type
)),
1014 /* Integral operations here. */
1016 /* Determine type length of the result, and if the operation should
1017 be done unsigned. For exponentiation and shift operators,
1018 use the length and type of the left operand. Otherwise,
1019 use the signedness of the operand with the greater length.
1020 If both operands are of equal length, use unsigned operation
1021 if one of the operands is unsigned. */
1022 if (op
== BINOP_RSH
|| op
== BINOP_LSH
|| op
== BINOP_EXP
)
1023 result_type
= type1
;
1024 else if (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
))
1025 result_type
= type1
;
1026 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1027 result_type
= type2
;
1028 else if (TYPE_UNSIGNED (type1
))
1029 result_type
= type1
;
1030 else if (TYPE_UNSIGNED (type2
))
1031 result_type
= type2
;
1033 result_type
= type1
;
1035 if (TYPE_UNSIGNED (result_type
))
1037 LONGEST v2_signed
= value_as_long (arg2
);
1038 ULONGEST v1
, v2
, v
= 0;
1039 v1
= (ULONGEST
) value_as_long (arg1
);
1040 v2
= (ULONGEST
) v2_signed
;
1061 error (_("Division by zero"));
1065 v
= uinteger_pow (v1
, v2_signed
);
1072 error (_("Division by zero"));
1076 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1077 v1 mod 0 has a defined value, v1. */
1085 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1098 case BINOP_BITWISE_AND
:
1102 case BINOP_BITWISE_IOR
:
1106 case BINOP_BITWISE_XOR
:
1110 case BINOP_LOGICAL_AND
:
1114 case BINOP_LOGICAL_OR
:
1119 v
= v1
< v2
? v1
: v2
;
1123 v
= v1
> v2
? v1
: v2
;
1130 case BINOP_NOTEQUAL
:
1151 error (_("Invalid binary operation on numbers."));
1154 val
= allocate_value (result_type
);
1155 store_unsigned_integer (value_contents_raw (val
),
1156 TYPE_LENGTH (value_type (val
)),
1158 (get_type_arch (result_type
)),
1163 LONGEST v1
, v2
, v
= 0;
1164 v1
= value_as_long (arg1
);
1165 v2
= value_as_long (arg2
);
1186 error (_("Division by zero"));
1190 v
= integer_pow (v1
, v2
);
1197 error (_("Division by zero"));
1201 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1202 X mod 0 has a defined value, X. */
1210 /* Compute floor. */
1211 if (TRUNCATION_TOWARDS_ZERO
&& (v
< 0) && ((v1
% v2
) != 0))
1227 case BINOP_BITWISE_AND
:
1231 case BINOP_BITWISE_IOR
:
1235 case BINOP_BITWISE_XOR
:
1239 case BINOP_LOGICAL_AND
:
1243 case BINOP_LOGICAL_OR
:
1248 v
= v1
< v2
? v1
: v2
;
1252 v
= v1
> v2
? v1
: v2
;
1259 case BINOP_NOTEQUAL
:
1280 error (_("Invalid binary operation on numbers."));
1283 val
= allocate_value (result_type
);
1284 store_signed_integer (value_contents_raw (val
),
1285 TYPE_LENGTH (value_type (val
)),
1287 (get_type_arch (result_type
)),
1295 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1298 value_logical_not (struct value
*arg1
)
1304 arg1
= coerce_array (arg1
);
1305 type1
= check_typedef (value_type (arg1
));
1307 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
)
1308 return 0 == value_as_double (arg1
);
1309 else if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
1310 return decimal_is_zero (value_contents (arg1
), TYPE_LENGTH (type1
),
1311 gdbarch_byte_order (get_type_arch (type1
)));
1313 len
= TYPE_LENGTH (type1
);
1314 p
= value_contents (arg1
);
1325 /* Perform a comparison on two string values (whose content are not
1326 necessarily null terminated) based on their length */
1329 value_strcmp (struct value
*arg1
, struct value
*arg2
)
1331 int len1
= TYPE_LENGTH (value_type (arg1
));
1332 int len2
= TYPE_LENGTH (value_type (arg2
));
1333 const gdb_byte
*s1
= value_contents (arg1
);
1334 const gdb_byte
*s2
= value_contents (arg2
);
1335 int i
, len
= len1
< len2
? len1
: len2
;
1337 for (i
= 0; i
< len
; i
++)
1341 else if (s1
[i
] > s2
[i
])
1349 else if (len1
> len2
)
1355 /* Simulate the C operator == by returning a 1
1356 iff ARG1 and ARG2 have equal contents. */
1359 value_equal (struct value
*arg1
, struct value
*arg2
)
1364 struct type
*type1
, *type2
;
1365 enum type_code code1
;
1366 enum type_code code2
;
1367 int is_int1
, is_int2
;
1369 arg1
= coerce_array (arg1
);
1370 arg2
= coerce_array (arg2
);
1372 type1
= check_typedef (value_type (arg1
));
1373 type2
= check_typedef (value_type (arg2
));
1374 code1
= TYPE_CODE (type1
);
1375 code2
= TYPE_CODE (type2
);
1376 is_int1
= is_integral_type (type1
);
1377 is_int2
= is_integral_type (type2
);
1379 if (is_int1
&& is_int2
)
1380 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1382 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1383 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1385 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1386 `long double' values are returned in static storage (m68k). */
1387 DOUBLEST d
= value_as_double (arg1
);
1388 return d
== value_as_double (arg2
);
1390 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1391 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1393 gdb_byte v1
[16], v2
[16];
1395 enum bfd_endian byte_order_v1
, byte_order_v2
;
1397 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
1398 v2
, &len_v2
, &byte_order_v2
);
1400 return decimal_compare (v1
, len_v1
, byte_order_v1
,
1401 v2
, len_v2
, byte_order_v2
) == 0;
1404 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1406 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1407 return value_as_address (arg1
) == (CORE_ADDR
) value_as_long (arg2
);
1408 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1409 return (CORE_ADDR
) value_as_long (arg1
) == value_as_address (arg2
);
1411 else if (code1
== code2
1412 && ((len
= (int) TYPE_LENGTH (type1
))
1413 == (int) TYPE_LENGTH (type2
)))
1415 p1
= value_contents (arg1
);
1416 p2
= value_contents (arg2
);
1424 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1426 return value_strcmp (arg1
, arg2
) == 0;
1430 error (_("Invalid type combination in equality test."));
1431 return 0; /* For lint -- never reached */
1435 /* Compare values based on their raw contents. Useful for arrays since
1436 value_equal coerces them to pointers, thus comparing just the address
1437 of the array instead of its contents. */
1440 value_equal_contents (struct value
*arg1
, struct value
*arg2
)
1442 struct type
*type1
, *type2
;
1444 type1
= check_typedef (value_type (arg1
));
1445 type2
= check_typedef (value_type (arg2
));
1447 return (TYPE_CODE (type1
) == TYPE_CODE (type2
)
1448 && TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
1449 && memcmp (value_contents (arg1
), value_contents (arg2
),
1450 TYPE_LENGTH (type1
)) == 0);
1453 /* Simulate the C operator < by returning 1
1454 iff ARG1's contents are less than ARG2's. */
1457 value_less (struct value
*arg1
, struct value
*arg2
)
1459 enum type_code code1
;
1460 enum type_code code2
;
1461 struct type
*type1
, *type2
;
1462 int is_int1
, is_int2
;
1464 arg1
= coerce_array (arg1
);
1465 arg2
= coerce_array (arg2
);
1467 type1
= check_typedef (value_type (arg1
));
1468 type2
= check_typedef (value_type (arg2
));
1469 code1
= TYPE_CODE (type1
);
1470 code2
= TYPE_CODE (type2
);
1471 is_int1
= is_integral_type (type1
);
1472 is_int2
= is_integral_type (type2
);
1474 if (is_int1
&& is_int2
)
1475 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1477 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1478 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1480 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1481 `long double' values are returned in static storage (m68k). */
1482 DOUBLEST d
= value_as_double (arg1
);
1483 return d
< value_as_double (arg2
);
1485 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1486 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1488 gdb_byte v1
[16], v2
[16];
1490 enum bfd_endian byte_order_v1
, byte_order_v2
;
1492 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
1493 v2
, &len_v2
, &byte_order_v2
);
1495 return decimal_compare (v1
, len_v1
, byte_order_v1
,
1496 v2
, len_v2
, byte_order_v2
) == -1;
1498 else if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
1499 return value_as_address (arg1
) < value_as_address (arg2
);
1501 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1503 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1504 return value_as_address (arg1
) < (CORE_ADDR
) value_as_long (arg2
);
1505 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1506 return (CORE_ADDR
) value_as_long (arg1
) < value_as_address (arg2
);
1507 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1508 return value_strcmp (arg1
, arg2
) < 0;
1511 error (_("Invalid type combination in ordering comparison."));
1516 /* The unary operators +, - and ~. They free the argument ARG1. */
1519 value_pos (struct value
*arg1
)
1523 arg1
= coerce_ref (arg1
);
1524 type
= check_typedef (value_type (arg1
));
1526 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1527 return value_from_double (type
, value_as_double (arg1
));
1528 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1529 return value_from_decfloat (type
, value_contents (arg1
));
1530 else if (is_integral_type (type
))
1532 return value_from_longest (type
, value_as_long (arg1
));
1536 error ("Argument to positive operation not a number.");
1537 return 0; /* For lint -- never reached */
1542 value_neg (struct value
*arg1
)
1546 arg1
= coerce_ref (arg1
);
1547 type
= check_typedef (value_type (arg1
));
1549 if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1551 struct value
*val
= allocate_value (type
);
1552 int len
= TYPE_LENGTH (type
);
1553 gdb_byte decbytes
[16]; /* a decfloat is at most 128 bits long */
1555 memcpy (decbytes
, value_contents (arg1
), len
);
1557 if (gdbarch_byte_order (get_type_arch (type
)) == BFD_ENDIAN_LITTLE
)
1558 decbytes
[len
-1] = decbytes
[len
- 1] | 0x80;
1560 decbytes
[0] = decbytes
[0] | 0x80;
1562 memcpy (value_contents_raw (val
), decbytes
, len
);
1565 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1566 return value_from_double (type
, -value_as_double (arg1
));
1567 else if (is_integral_type (type
))
1569 return value_from_longest (type
, -value_as_long (arg1
));
1573 error (_("Argument to negate operation not a number."));
1574 return 0; /* For lint -- never reached */
1579 value_complement (struct value
*arg1
)
1583 arg1
= coerce_ref (arg1
);
1584 type
= check_typedef (value_type (arg1
));
1586 if (!is_integral_type (type
))
1587 error (_("Argument to complement operation not an integer or boolean."));
1589 return value_from_longest (type
, ~value_as_long (arg1
));
1592 /* The INDEX'th bit of SET value whose value_type is TYPE,
1593 and whose value_contents is valaddr.
1594 Return -1 if out of range, -2 other error. */
1597 value_bit_index (struct type
*type
, const gdb_byte
*valaddr
, int index
)
1599 struct gdbarch
*gdbarch
= get_type_arch (type
);
1600 LONGEST low_bound
, high_bound
;
1603 struct type
*range
= TYPE_INDEX_TYPE (type
);
1604 if (get_discrete_bounds (range
, &low_bound
, &high_bound
) < 0)
1606 if (index
< low_bound
|| index
> high_bound
)
1608 rel_index
= index
- low_bound
;
1609 word
= extract_unsigned_integer (valaddr
+ (rel_index
/ TARGET_CHAR_BIT
), 1,
1610 gdbarch_byte_order (gdbarch
));
1611 rel_index
%= TARGET_CHAR_BIT
;
1612 if (gdbarch_bits_big_endian (gdbarch
))
1613 rel_index
= TARGET_CHAR_BIT
- 1 - rel_index
;
1614 return (word
>> rel_index
) & 1;
1618 value_in (struct value
*element
, struct value
*set
)
1621 struct type
*settype
= check_typedef (value_type (set
));
1622 struct type
*eltype
= check_typedef (value_type (element
));
1623 if (TYPE_CODE (eltype
) == TYPE_CODE_RANGE
)
1624 eltype
= TYPE_TARGET_TYPE (eltype
);
1625 if (TYPE_CODE (settype
) != TYPE_CODE_SET
)
1626 error (_("Second argument of 'IN' has wrong type"));
1627 if (TYPE_CODE (eltype
) != TYPE_CODE_INT
1628 && TYPE_CODE (eltype
) != TYPE_CODE_CHAR
1629 && TYPE_CODE (eltype
) != TYPE_CODE_ENUM
1630 && TYPE_CODE (eltype
) != TYPE_CODE_BOOL
)
1631 error (_("First argument of 'IN' has wrong type"));
1632 member
= value_bit_index (settype
, value_contents (set
),
1633 value_as_long (element
));
1635 error (_("First argument of 'IN' not in range"));
1640 _initialize_valarith (void)
This page took 0.065059 seconds and 4 git commands to generate.