1 /* Perform arithmetic and other operations on values, for GDB.
3 Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
29 #include "gdb_string.h"
35 /* Define whether or not the C operator '/' truncates towards zero for
36 differently signed operands (truncation direction is undefined in C). */
38 #ifndef TRUNCATION_TOWARDS_ZERO
39 #define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
42 void _initialize_valarith (void);
45 /* Given a pointer, return the size of its target.
46 If the pointer type is void *, then return 1.
47 If the target type is incomplete, then error out.
48 This isn't a general purpose function, but just a
49 helper for value_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
)));
125 return (value_as_long (arg1
) - value_as_long (arg2
)) / sz
;
128 /* Return the value of ARRAY[IDX].
130 ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING. If the
131 current language supports C-style arrays, it may also be TYPE_CODE_PTR.
132 To access TYPE_CODE_BITSTRING values, use value_bitstring_subscript.
134 See comments in value_coerce_array() for rationale for reason for
135 doing lower bounds adjustment here rather than there.
136 FIXME: Perhaps we should validate that the index is valid and if
137 verbosity is set, warn about invalid indices (but still use them). */
140 value_subscript (struct value
*array
, LONGEST index
)
143 int c_style
= current_language
->c_style_arrays
;
146 array
= coerce_ref (array
);
147 tarray
= check_typedef (value_type (array
));
149 if (TYPE_CODE (tarray
) == TYPE_CODE_ARRAY
150 || TYPE_CODE (tarray
) == TYPE_CODE_STRING
)
152 struct type
*range_type
= TYPE_INDEX_TYPE (tarray
);
153 LONGEST lowerbound
, upperbound
;
154 get_discrete_bounds (range_type
, &lowerbound
, &upperbound
);
156 if (VALUE_LVAL (array
) != lval_memory
)
157 return value_subscripted_rvalue (array
, index
, lowerbound
);
161 if (index
>= lowerbound
&& index
<= upperbound
)
162 return value_subscripted_rvalue (array
, index
, lowerbound
);
163 /* Emit warning unless we have an array of unknown size.
164 An array of unknown size has lowerbound 0 and upperbound -1. */
166 warning (_("array or string index out of range"));
167 /* fall doing C stuff */
172 array
= value_coerce_array (array
);
176 return value_ind (value_ptradd (array
, index
));
178 error (_("not an array or string"));
181 /* Return the value of EXPR[IDX], expr an aggregate rvalue
182 (eg, a vector register). This routine used to promote floats
183 to doubles, but no longer does. */
186 value_subscripted_rvalue (struct value
*array
, LONGEST index
, int lowerbound
)
188 struct type
*array_type
= check_typedef (value_type (array
));
189 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (array_type
));
190 unsigned int elt_size
= TYPE_LENGTH (elt_type
);
191 unsigned int elt_offs
= elt_size
* longest_to_int (index
- lowerbound
);
194 if (index
< lowerbound
|| elt_offs
>= TYPE_LENGTH (array_type
))
195 error (_("no such vector element"));
197 v
= allocate_value (elt_type
);
198 if (VALUE_LVAL (array
) == lval_memory
&& value_lazy (array
))
199 set_value_lazy (v
, 1);
201 memcpy (value_contents_writeable (v
),
202 value_contents (array
) + elt_offs
, elt_size
);
204 set_value_component_location (v
, array
);
205 VALUE_REGNUM (v
) = VALUE_REGNUM (array
);
206 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (array
);
207 set_value_offset (v
, value_offset (array
) + elt_offs
);
211 /* Return the value of BITSTRING[IDX] as (boolean) type TYPE. */
214 value_bitstring_subscript (struct type
*type
,
215 struct value
*bitstring
, LONGEST index
)
218 struct type
*bitstring_type
, *range_type
;
220 int offset
, byte
, bit_index
;
221 LONGEST lowerbound
, upperbound
;
223 bitstring_type
= check_typedef (value_type (bitstring
));
224 gdb_assert (TYPE_CODE (bitstring_type
) == TYPE_CODE_BITSTRING
);
226 range_type
= TYPE_INDEX_TYPE (bitstring_type
);
227 get_discrete_bounds (range_type
, &lowerbound
, &upperbound
);
228 if (index
< lowerbound
|| index
> upperbound
)
229 error (_("bitstring index out of range"));
232 offset
= index
/ TARGET_CHAR_BIT
;
233 byte
= *((char *) value_contents (bitstring
) + offset
);
235 bit_index
= index
% TARGET_CHAR_BIT
;
236 byte
>>= (gdbarch_bits_big_endian (current_gdbarch
) ?
237 TARGET_CHAR_BIT
- 1 - bit_index
: bit_index
);
239 v
= value_from_longest (type
, byte
& 1);
241 set_value_bitpos (v
, bit_index
);
242 set_value_bitsize (v
, 1);
243 set_value_component_location (v
, bitstring
);
244 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (bitstring
);
246 set_value_offset (v
, offset
+ value_offset (bitstring
));
252 /* Check to see if either argument is a structure, or a reference to
253 one. This is called so we know whether to go ahead with the normal
254 binop or look for a user defined function instead.
256 For now, we do not overload the `=' operator. */
259 binop_user_defined_p (enum exp_opcode op
, struct value
*arg1
, struct value
*arg2
)
261 struct type
*type1
, *type2
;
262 if (op
== BINOP_ASSIGN
|| op
== BINOP_CONCAT
)
265 type1
= check_typedef (value_type (arg1
));
266 if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
267 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
269 type2
= check_typedef (value_type (arg2
));
270 if (TYPE_CODE (type2
) == TYPE_CODE_REF
)
271 type2
= check_typedef (TYPE_TARGET_TYPE (type2
));
273 return (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
274 || TYPE_CODE (type2
) == TYPE_CODE_STRUCT
);
277 /* Check to see if argument is a structure. This is called so
278 we know whether to go ahead with the normal unop or look for a
279 user defined function instead.
281 For now, we do not overload the `&' operator. */
284 unop_user_defined_p (enum exp_opcode op
, struct value
*arg1
)
289 type1
= check_typedef (value_type (arg1
));
292 if (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
)
294 else if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
295 type1
= TYPE_TARGET_TYPE (type1
);
301 /* We know either arg1 or arg2 is a structure, so try to find the right
302 user defined function. Create an argument vector that calls
303 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
304 binary operator which is legal for GNU C++).
306 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
307 is the opcode saying how to modify it. Otherwise, OTHEROP is
311 value_x_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
,
312 enum exp_opcode otherop
, enum noside noside
)
314 struct value
**argvec
;
319 arg1
= coerce_ref (arg1
);
320 arg2
= coerce_ref (arg2
);
322 /* now we know that what we have to do is construct our
323 arg vector and find the right function to call it with. */
325 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
326 error (_("Can't do that binary op on that type")); /* FIXME be explicit */
328 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
329 argvec
[1] = value_addr (arg1
);
333 /* make the right function name up */
334 strcpy (tstr
, "operator__");
359 case BINOP_BITWISE_AND
:
362 case BINOP_BITWISE_IOR
:
365 case BINOP_BITWISE_XOR
:
368 case BINOP_LOGICAL_AND
:
371 case BINOP_LOGICAL_OR
:
383 case BINOP_ASSIGN_MODIFY
:
401 case BINOP_BITWISE_AND
:
404 case BINOP_BITWISE_IOR
:
407 case BINOP_BITWISE_XOR
:
410 case BINOP_MOD
: /* invalid */
412 error (_("Invalid binary operation specified."));
415 case BINOP_SUBSCRIPT
:
436 case BINOP_MOD
: /* invalid */
438 error (_("Invalid binary operation specified."));
441 argvec
[0] = value_struct_elt (&arg1
, argvec
+ 1, tstr
, &static_memfuncp
, "structure");
447 argvec
[1] = argvec
[0];
450 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
452 struct type
*return_type
;
454 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
455 return value_zero (return_type
, VALUE_LVAL (arg1
));
457 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
459 error (_("member function %s not found"), tstr
);
461 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
465 /* We know that arg1 is a structure, so try to find a unary user
466 defined operator that matches the operator in question.
467 Create an argument vector that calls arg1.operator @ (arg1)
468 and return that value (where '@' is (almost) any unary operator which
469 is legal for GNU C++). */
472 value_x_unop (struct value
*arg1
, enum exp_opcode op
, enum noside noside
)
474 struct value
**argvec
;
475 char *ptr
, *mangle_ptr
;
476 char tstr
[13], mangle_tstr
[13];
477 int static_memfuncp
, nargs
;
479 arg1
= coerce_ref (arg1
);
481 /* now we know that what we have to do is construct our
482 arg vector and find the right function to call it with. */
484 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
485 error (_("Can't do that unary op on that type")); /* FIXME be explicit */
487 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
488 argvec
[1] = value_addr (arg1
);
493 /* make the right function name up */
494 strcpy (tstr
, "operator__");
496 strcpy (mangle_tstr
, "__");
497 mangle_ptr
= mangle_tstr
+ 2;
500 case UNOP_PREINCREMENT
:
503 case UNOP_PREDECREMENT
:
506 case UNOP_POSTINCREMENT
:
508 argvec
[2] = value_from_longest (builtin_type_int8
, 0);
512 case UNOP_POSTDECREMENT
:
514 argvec
[2] = value_from_longest (builtin_type_int8
, 0);
518 case UNOP_LOGICAL_NOT
:
521 case UNOP_COMPLEMENT
:
534 error (_("Invalid unary operation specified."));
537 argvec
[0] = value_struct_elt (&arg1
, argvec
+ 1, tstr
, &static_memfuncp
, "structure");
543 argvec
[1] = argvec
[0];
547 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
549 struct type
*return_type
;
551 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
552 return value_zero (return_type
, VALUE_LVAL (arg1
));
554 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
556 error (_("member function %s not found"), tstr
);
557 return 0; /* For lint -- never reached */
561 /* Concatenate two values with the following conditions:
563 (1) Both values must be either bitstring values or character string
564 values and the resulting value consists of the concatenation of
565 ARG1 followed by ARG2.
569 One value must be an integer value and the other value must be
570 either a bitstring value or character string value, which is
571 to be repeated by the number of times specified by the integer
575 (2) Boolean values are also allowed and are treated as bit string
578 (3) Character values are also allowed and are treated as character
579 string values of length 1.
583 value_concat (struct value
*arg1
, struct value
*arg2
)
585 struct value
*inval1
;
586 struct value
*inval2
;
587 struct value
*outval
= NULL
;
588 int inval1len
, inval2len
;
592 struct type
*type1
= check_typedef (value_type (arg1
));
593 struct type
*type2
= check_typedef (value_type (arg2
));
594 struct type
*char_type
;
596 /* First figure out if we are dealing with two values to be concatenated
597 or a repeat count and a value to be repeated. INVAL1 is set to the
598 first of two concatenated values, or the repeat count. INVAL2 is set
599 to the second of the two concatenated values or the value to be
602 if (TYPE_CODE (type2
) == TYPE_CODE_INT
)
604 struct type
*tmp
= type1
;
616 /* Now process the input values. */
618 if (TYPE_CODE (type1
) == TYPE_CODE_INT
)
620 /* We have a repeat count. Validate the second value and then
621 construct a value repeated that many times. */
622 if (TYPE_CODE (type2
) == TYPE_CODE_STRING
623 || TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
625 count
= longest_to_int (value_as_long (inval1
));
626 inval2len
= TYPE_LENGTH (type2
);
627 ptr
= (char *) alloca (count
* inval2len
);
628 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
631 inchar
= (char) unpack_long (type2
,
632 value_contents (inval2
));
633 for (idx
= 0; idx
< count
; idx
++)
635 *(ptr
+ idx
) = inchar
;
640 char_type
= TYPE_TARGET_TYPE (type2
);
641 for (idx
= 0; idx
< count
; idx
++)
643 memcpy (ptr
+ (idx
* inval2len
), value_contents (inval2
),
647 outval
= value_string (ptr
, count
* inval2len
, char_type
);
649 else if (TYPE_CODE (type2
) == TYPE_CODE_BITSTRING
650 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
652 error (_("unimplemented support for bitstring/boolean repeats"));
656 error (_("can't repeat values of that type"));
659 else if (TYPE_CODE (type1
) == TYPE_CODE_STRING
660 || TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
662 /* We have two character strings to concatenate. */
663 if (TYPE_CODE (type2
) != TYPE_CODE_STRING
664 && TYPE_CODE (type2
) != TYPE_CODE_CHAR
)
666 error (_("Strings can only be concatenated with other strings."));
668 inval1len
= TYPE_LENGTH (type1
);
669 inval2len
= TYPE_LENGTH (type2
);
670 ptr
= (char *) alloca (inval1len
+ inval2len
);
671 if (TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
674 *ptr
= (char) unpack_long (type1
, value_contents (inval1
));
678 char_type
= TYPE_TARGET_TYPE (type1
);
679 memcpy (ptr
, value_contents (inval1
), inval1len
);
681 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
684 (char) unpack_long (type2
, value_contents (inval2
));
688 memcpy (ptr
+ inval1len
, value_contents (inval2
), inval2len
);
690 outval
= value_string (ptr
, inval1len
+ inval2len
, char_type
);
692 else if (TYPE_CODE (type1
) == TYPE_CODE_BITSTRING
693 || TYPE_CODE (type1
) == TYPE_CODE_BOOL
)
695 /* We have two bitstrings to concatenate. */
696 if (TYPE_CODE (type2
) != TYPE_CODE_BITSTRING
697 && TYPE_CODE (type2
) != TYPE_CODE_BOOL
)
699 error (_("Bitstrings or booleans can only be concatenated with other bitstrings or booleans."));
701 error (_("unimplemented support for bitstring/boolean concatenation."));
705 /* We don't know how to concatenate these operands. */
706 error (_("illegal operands for concatenation."));
711 /* Integer exponentiation: V1**V2, where both arguments are
712 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
714 integer_pow (LONGEST v1
, LONGEST v2
)
719 error (_("Attempt to raise 0 to negative power."));
725 /* The Russian Peasant's Algorithm */
741 /* Integer exponentiation: V1**V2, where both arguments are
742 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
744 uinteger_pow (ULONGEST v1
, LONGEST v2
)
749 error (_("Attempt to raise 0 to negative power."));
755 /* The Russian Peasant's Algorithm */
771 /* Obtain decimal value of arguments for binary operation, converting from
772 other types if one of them is not decimal floating point. */
774 value_args_as_decimal (struct value
*arg1
, struct value
*arg2
,
775 gdb_byte
*x
, int *len_x
, gdb_byte
*y
, int *len_y
)
777 struct type
*type1
, *type2
;
779 type1
= check_typedef (value_type (arg1
));
780 type2
= check_typedef (value_type (arg2
));
782 /* At least one of the arguments must be of decimal float type. */
783 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
784 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
);
786 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
787 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
788 /* The DFP extension to the C language does not allow mixing of
789 * decimal float types with other float types in expressions
790 * (see WDTR 24732, page 12). */
791 error (_("Mixing decimal floating types with other floating types is not allowed."));
793 /* Obtain decimal value of arg1, converting from other types
796 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
798 *len_x
= TYPE_LENGTH (type1
);
799 memcpy (x
, value_contents (arg1
), *len_x
);
801 else if (is_integral_type (type1
))
803 *len_x
= TYPE_LENGTH (type2
);
804 decimal_from_integral (arg1
, x
, *len_x
);
807 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
810 /* Obtain decimal value of arg2, converting from other types
813 if (TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
815 *len_y
= TYPE_LENGTH (type2
);
816 memcpy (y
, value_contents (arg2
), *len_y
);
818 else if (is_integral_type (type2
))
820 *len_y
= TYPE_LENGTH (type1
);
821 decimal_from_integral (arg2
, y
, *len_y
);
824 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
828 /* Perform a binary operation on two operands which have reasonable
829 representations as integers or floats. This includes booleans,
830 characters, integers, or floats.
831 Does not support addition and subtraction on pointers;
832 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
835 value_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
838 struct type
*type1
, *type2
, *result_type
;
840 arg1
= coerce_ref (arg1
);
841 arg2
= coerce_ref (arg2
);
843 type1
= check_typedef (value_type (arg1
));
844 type2
= check_typedef (value_type (arg2
));
846 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
847 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
848 && !is_integral_type (type1
))
849 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
850 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
851 && !is_integral_type (type2
)))
852 error (_("Argument to arithmetic operation not a number or boolean."));
854 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
855 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
858 int len_v1
, len_v2
, len_v
;
859 gdb_byte v1
[16], v2
[16];
862 /* If only one type is decimal float, use its type.
863 Otherwise use the bigger type. */
864 if (TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
)
866 else if (TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
)
868 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
873 len_v
= TYPE_LENGTH (result_type
);
875 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, v2
, &len_v2
);
884 decimal_binop (op
, v1
, len_v1
, v2
, len_v2
, v
, len_v
);
888 error (_("Operation not valid for decimal floating point number."));
891 val
= value_from_decfloat (result_type
, v
);
893 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
894 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
896 /* FIXME-if-picky-about-floating-accuracy: Should be doing this
897 in target format. real.c in GCC probably has the necessary
899 DOUBLEST v1
, v2
, v
= 0;
900 v1
= value_as_double (arg1
);
901 v2
= value_as_double (arg2
);
925 error (_("Cannot perform exponentiation: %s"), safe_strerror (errno
));
929 v
= v1
< v2
? v1
: v2
;
933 v
= v1
> v2
? v1
: v2
;
937 error (_("Integer-only operation on floating point number."));
940 /* If only one type is float, use its type.
941 Otherwise use the bigger type. */
942 if (TYPE_CODE (type1
) != TYPE_CODE_FLT
)
944 else if (TYPE_CODE (type2
) != TYPE_CODE_FLT
)
946 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
951 val
= allocate_value (result_type
);
952 store_typed_floating (value_contents_raw (val
), value_type (val
), v
);
954 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
955 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
957 LONGEST v1
, v2
, v
= 0;
958 v1
= value_as_long (arg1
);
959 v2
= value_as_long (arg2
);
963 case BINOP_BITWISE_AND
:
967 case BINOP_BITWISE_IOR
:
971 case BINOP_BITWISE_XOR
:
984 error (_("Invalid operation on booleans."));
989 val
= allocate_value (result_type
);
990 store_signed_integer (value_contents_raw (val
),
991 TYPE_LENGTH (result_type
),
995 /* Integral operations here. */
997 /* Determine type length of the result, and if the operation should
998 be done unsigned. For exponentiation and shift operators,
999 use the length and type of the left operand. Otherwise,
1000 use the signedness of the operand with the greater length.
1001 If both operands are of equal length, use unsigned operation
1002 if one of the operands is unsigned. */
1003 if (op
== BINOP_RSH
|| op
== BINOP_LSH
|| op
== BINOP_EXP
)
1004 result_type
= type1
;
1005 else if (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
))
1006 result_type
= type1
;
1007 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1008 result_type
= type2
;
1009 else if (TYPE_UNSIGNED (type1
))
1010 result_type
= type1
;
1011 else if (TYPE_UNSIGNED (type2
))
1012 result_type
= type2
;
1014 result_type
= type1
;
1016 if (TYPE_UNSIGNED (result_type
))
1018 LONGEST v2_signed
= value_as_long (arg2
);
1019 ULONGEST v1
, v2
, v
= 0;
1020 v1
= (ULONGEST
) value_as_long (arg1
);
1021 v2
= (ULONGEST
) v2_signed
;
1042 error (_("Division by zero"));
1046 v
= uinteger_pow (v1
, v2_signed
);
1053 error (_("Division by zero"));
1057 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1058 v1 mod 0 has a defined value, v1. */
1066 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1079 case BINOP_BITWISE_AND
:
1083 case BINOP_BITWISE_IOR
:
1087 case BINOP_BITWISE_XOR
:
1091 case BINOP_LOGICAL_AND
:
1095 case BINOP_LOGICAL_OR
:
1100 v
= v1
< v2
? v1
: v2
;
1104 v
= v1
> v2
? v1
: v2
;
1111 case BINOP_NOTEQUAL
:
1120 error (_("Invalid binary operation on numbers."));
1123 val
= allocate_value (result_type
);
1124 store_unsigned_integer (value_contents_raw (val
),
1125 TYPE_LENGTH (value_type (val
)),
1130 LONGEST v1
, v2
, v
= 0;
1131 v1
= value_as_long (arg1
);
1132 v2
= value_as_long (arg2
);
1153 error (_("Division by zero"));
1157 v
= integer_pow (v1
, v2
);
1164 error (_("Division by zero"));
1168 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1169 X mod 0 has a defined value, X. */
1177 /* Compute floor. */
1178 if (TRUNCATION_TOWARDS_ZERO
&& (v
< 0) && ((v1
% v2
) != 0))
1194 case BINOP_BITWISE_AND
:
1198 case BINOP_BITWISE_IOR
:
1202 case BINOP_BITWISE_XOR
:
1206 case BINOP_LOGICAL_AND
:
1210 case BINOP_LOGICAL_OR
:
1215 v
= v1
< v2
? v1
: v2
;
1219 v
= v1
> v2
? v1
: v2
;
1231 error (_("Invalid binary operation on numbers."));
1234 val
= allocate_value (result_type
);
1235 store_signed_integer (value_contents_raw (val
),
1236 TYPE_LENGTH (value_type (val
)),
1244 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1247 value_logical_not (struct value
*arg1
)
1253 arg1
= coerce_array (arg1
);
1254 type1
= check_typedef (value_type (arg1
));
1256 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
)
1257 return 0 == value_as_double (arg1
);
1258 else if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
1259 return decimal_is_zero (value_contents (arg1
), TYPE_LENGTH (type1
));
1261 len
= TYPE_LENGTH (type1
);
1262 p
= value_contents (arg1
);
1273 /* Perform a comparison on two string values (whose content are not
1274 necessarily null terminated) based on their length */
1277 value_strcmp (struct value
*arg1
, struct value
*arg2
)
1279 int len1
= TYPE_LENGTH (value_type (arg1
));
1280 int len2
= TYPE_LENGTH (value_type (arg2
));
1281 const gdb_byte
*s1
= value_contents (arg1
);
1282 const gdb_byte
*s2
= value_contents (arg2
);
1283 int i
, len
= len1
< len2
? len1
: len2
;
1285 for (i
= 0; i
< len
; i
++)
1289 else if (s1
[i
] > s2
[i
])
1297 else if (len1
> len2
)
1303 /* Simulate the C operator == by returning a 1
1304 iff ARG1 and ARG2 have equal contents. */
1307 value_equal (struct value
*arg1
, struct value
*arg2
)
1312 struct type
*type1
, *type2
;
1313 enum type_code code1
;
1314 enum type_code code2
;
1315 int is_int1
, is_int2
;
1317 arg1
= coerce_array (arg1
);
1318 arg2
= coerce_array (arg2
);
1320 type1
= check_typedef (value_type (arg1
));
1321 type2
= check_typedef (value_type (arg2
));
1322 code1
= TYPE_CODE (type1
);
1323 code2
= TYPE_CODE (type2
);
1324 is_int1
= is_integral_type (type1
);
1325 is_int2
= is_integral_type (type2
);
1327 if (is_int1
&& is_int2
)
1328 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1330 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1331 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1333 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1334 `long double' values are returned in static storage (m68k). */
1335 DOUBLEST d
= value_as_double (arg1
);
1336 return d
== value_as_double (arg2
);
1338 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1339 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1341 gdb_byte v1
[16], v2
[16];
1344 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, v2
, &len_v2
);
1346 return decimal_compare (v1
, len_v1
, v2
, len_v2
) == 0;
1349 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1351 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1352 return value_as_address (arg1
) == (CORE_ADDR
) value_as_long (arg2
);
1353 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1354 return (CORE_ADDR
) value_as_long (arg1
) == value_as_address (arg2
);
1356 else if (code1
== code2
1357 && ((len
= (int) TYPE_LENGTH (type1
))
1358 == (int) TYPE_LENGTH (type2
)))
1360 p1
= value_contents (arg1
);
1361 p2
= value_contents (arg2
);
1369 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1371 return value_strcmp (arg1
, arg2
) == 0;
1375 error (_("Invalid type combination in equality test."));
1376 return 0; /* For lint -- never reached */
1380 /* Simulate the C operator < by returning 1
1381 iff ARG1's contents are less than ARG2's. */
1384 value_less (struct value
*arg1
, struct value
*arg2
)
1386 enum type_code code1
;
1387 enum type_code code2
;
1388 struct type
*type1
, *type2
;
1389 int is_int1
, is_int2
;
1391 arg1
= coerce_array (arg1
);
1392 arg2
= coerce_array (arg2
);
1394 type1
= check_typedef (value_type (arg1
));
1395 type2
= check_typedef (value_type (arg2
));
1396 code1
= TYPE_CODE (type1
);
1397 code2
= TYPE_CODE (type2
);
1398 is_int1
= is_integral_type (type1
);
1399 is_int2
= is_integral_type (type2
);
1401 if (is_int1
&& is_int2
)
1402 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1404 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1405 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1407 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1408 `long double' values are returned in static storage (m68k). */
1409 DOUBLEST d
= value_as_double (arg1
);
1410 return d
< value_as_double (arg2
);
1412 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1413 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1415 gdb_byte v1
[16], v2
[16];
1418 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, v2
, &len_v2
);
1420 return decimal_compare (v1
, len_v1
, v2
, len_v2
) == -1;
1422 else if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
1423 return value_as_address (arg1
) < value_as_address (arg2
);
1425 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1427 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1428 return value_as_address (arg1
) < (CORE_ADDR
) value_as_long (arg2
);
1429 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1430 return (CORE_ADDR
) value_as_long (arg1
) < value_as_address (arg2
);
1431 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1432 return value_strcmp (arg1
, arg2
) < 0;
1435 error (_("Invalid type combination in ordering comparison."));
1440 /* The unary operators +, - and ~. They free the argument ARG1. */
1443 value_pos (struct value
*arg1
)
1447 arg1
= coerce_ref (arg1
);
1448 type
= check_typedef (value_type (arg1
));
1450 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1451 return value_from_double (type
, value_as_double (arg1
));
1452 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1453 return value_from_decfloat (type
, value_contents (arg1
));
1454 else if (is_integral_type (type
))
1456 return value_from_longest (type
, value_as_long (arg1
));
1460 error ("Argument to positive operation not a number.");
1461 return 0; /* For lint -- never reached */
1466 value_neg (struct value
*arg1
)
1470 arg1
= coerce_ref (arg1
);
1471 type
= check_typedef (value_type (arg1
));
1473 if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1475 struct value
*val
= allocate_value (type
);
1476 int len
= TYPE_LENGTH (type
);
1477 gdb_byte decbytes
[16]; /* a decfloat is at most 128 bits long */
1479 memcpy (decbytes
, value_contents (arg1
), len
);
1481 if (gdbarch_byte_order (current_gdbarch
) == BFD_ENDIAN_LITTLE
)
1482 decbytes
[len
-1] = decbytes
[len
- 1] | 0x80;
1484 decbytes
[0] = decbytes
[0] | 0x80;
1486 memcpy (value_contents_raw (val
), decbytes
, len
);
1489 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1490 return value_from_double (type
, -value_as_double (arg1
));
1491 else if (is_integral_type (type
))
1493 return value_from_longest (type
, -value_as_long (arg1
));
1497 error (_("Argument to negate operation not a number."));
1498 return 0; /* For lint -- never reached */
1503 value_complement (struct value
*arg1
)
1507 arg1
= coerce_ref (arg1
);
1508 type
= check_typedef (value_type (arg1
));
1510 if (!is_integral_type (type
))
1511 error (_("Argument to complement operation not an integer or boolean."));
1513 return value_from_longest (type
, ~value_as_long (arg1
));
1516 /* The INDEX'th bit of SET value whose value_type is TYPE,
1517 and whose value_contents is valaddr.
1518 Return -1 if out of range, -2 other error. */
1521 value_bit_index (struct type
*type
, const gdb_byte
*valaddr
, int index
)
1523 LONGEST low_bound
, high_bound
;
1526 struct type
*range
= TYPE_INDEX_TYPE (type
);
1527 if (get_discrete_bounds (range
, &low_bound
, &high_bound
) < 0)
1529 if (index
< low_bound
|| index
> high_bound
)
1531 rel_index
= index
- low_bound
;
1532 word
= extract_unsigned_integer (valaddr
+ (rel_index
/ TARGET_CHAR_BIT
), 1);
1533 rel_index
%= TARGET_CHAR_BIT
;
1534 if (gdbarch_bits_big_endian (current_gdbarch
))
1535 rel_index
= TARGET_CHAR_BIT
- 1 - rel_index
;
1536 return (word
>> rel_index
) & 1;
1540 value_in (struct value
*element
, struct value
*set
)
1543 struct type
*settype
= check_typedef (value_type (set
));
1544 struct type
*eltype
= check_typedef (value_type (element
));
1545 if (TYPE_CODE (eltype
) == TYPE_CODE_RANGE
)
1546 eltype
= TYPE_TARGET_TYPE (eltype
);
1547 if (TYPE_CODE (settype
) != TYPE_CODE_SET
)
1548 error (_("Second argument of 'IN' has wrong type"));
1549 if (TYPE_CODE (eltype
) != TYPE_CODE_INT
1550 && TYPE_CODE (eltype
) != TYPE_CODE_CHAR
1551 && TYPE_CODE (eltype
) != TYPE_CODE_ENUM
1552 && TYPE_CODE (eltype
) != TYPE_CODE_BOOL
)
1553 error (_("First argument of 'IN' has wrong type"));
1554 member
= value_bit_index (settype
, value_contents (set
),
1555 value_as_long (element
));
1557 error (_("First argument of 'IN' not in range"));
1562 _initialize_valarith (void)
This page took 0.073751 seconds and 5 git commands to generate.