1 /* Perform arithmetic and other operations on values, for GDB.
3 Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
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 2 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, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
28 #include "expression.h"
31 #include "gdb_string.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 static struct value
*value_subscripted_rvalue (struct value
*, struct value
*, int);
45 void _initialize_valarith (void);
48 /* Given a pointer, return the size of its target.
49 If the pointer type is void *, then return 1.
50 If the target type is incomplete, then error out.
51 This isn't a general purpose function, but just a
52 helper for value_sub & value_add.
56 find_size_for_pointer_math (struct type
*ptr_type
)
59 struct type
*ptr_target
;
61 ptr_target
= check_typedef (TYPE_TARGET_TYPE (ptr_type
));
63 sz
= TYPE_LENGTH (ptr_target
);
66 if (TYPE_CODE (ptr_type
) == TYPE_CODE_VOID
)
72 name
= TYPE_NAME (ptr_target
);
74 name
= TYPE_TAG_NAME (ptr_target
);
76 error ("Cannot perform pointer math on incomplete types, "
77 "try casting to a known type, or void *.");
79 error ("Cannot perform pointer math on incomplete type \"%s\", "
80 "try casting to a known type, or void *.", name
);
87 value_add (struct value
*arg1
, struct value
*arg2
)
92 struct type
*type1
, *type2
, *valptrtype
;
96 type1
= check_typedef (VALUE_TYPE (arg1
));
97 type2
= check_typedef (VALUE_TYPE (arg2
));
99 if ((TYPE_CODE (type1
) == TYPE_CODE_PTR
100 || TYPE_CODE (type2
) == TYPE_CODE_PTR
)
102 (is_integral_type (type1
) || is_integral_type (type2
)))
103 /* Exactly one argument is a pointer, and one is an integer. */
105 struct value
*retval
;
107 if (TYPE_CODE (type1
) == TYPE_CODE_PTR
)
120 sz
= find_size_for_pointer_math (valptrtype
);
122 retval
= value_from_pointer (valptrtype
,
123 value_as_address (valptr
)
124 + (sz
* value_as_long (valint
)));
125 VALUE_BFD_SECTION (retval
) = VALUE_BFD_SECTION (valptr
);
129 return value_binop (arg1
, arg2
, BINOP_ADD
);
133 value_sub (struct value
*arg1
, struct value
*arg2
)
135 struct type
*type1
, *type2
;
138 type1
= check_typedef (VALUE_TYPE (arg1
));
139 type2
= check_typedef (VALUE_TYPE (arg2
));
141 if (TYPE_CODE (type1
) == TYPE_CODE_PTR
)
143 if (is_integral_type (type2
))
145 /* pointer - integer. */
146 LONGEST sz
= find_size_for_pointer_math (type1
);
148 return value_from_pointer (type1
,
149 (value_as_address (arg1
)
150 - (sz
* value_as_long (arg2
))));
152 else if (TYPE_CODE (type2
) == TYPE_CODE_PTR
153 && TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)))
154 == TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2
))))
156 /* pointer to <type x> - pointer to <type x>. */
157 LONGEST sz
= TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)));
158 return value_from_longest
159 (builtin_type_long
, /* FIXME -- should be ptrdiff_t */
160 (value_as_long (arg1
) - value_as_long (arg2
)) / sz
);
165 First argument of `-' is a pointer and second argument is neither\n\
166 an integer nor a pointer of the same type.");
170 return value_binop (arg1
, arg2
, BINOP_SUB
);
173 /* Return the value of ARRAY[IDX].
174 See comments in value_coerce_array() for rationale for reason for
175 doing lower bounds adjustment here rather than there.
176 FIXME: Perhaps we should validate that the index is valid and if
177 verbosity is set, warn about invalid indices (but still use them). */
180 value_subscript (struct value
*array
, struct value
*idx
)
183 int c_style
= current_language
->c_style_arrays
;
187 tarray
= check_typedef (VALUE_TYPE (array
));
188 COERCE_VARYING_ARRAY (array
, tarray
);
190 if (TYPE_CODE (tarray
) == TYPE_CODE_ARRAY
191 || TYPE_CODE (tarray
) == TYPE_CODE_STRING
)
193 struct type
*range_type
= TYPE_INDEX_TYPE (tarray
);
194 LONGEST lowerbound
, upperbound
;
195 get_discrete_bounds (range_type
, &lowerbound
, &upperbound
);
197 if (VALUE_LVAL (array
) != lval_memory
)
198 return value_subscripted_rvalue (array
, idx
, lowerbound
);
202 LONGEST index
= value_as_long (idx
);
203 if (index
>= lowerbound
&& index
<= upperbound
)
204 return value_subscripted_rvalue (array
, idx
, lowerbound
);
205 /* Emit warning unless we have an array of unknown size.
206 An array of unknown size has lowerbound 0 and upperbound -1. */
208 warning ("array or string index out of range");
209 /* fall doing C stuff */
215 bound
= value_from_longest (builtin_type_int
, (LONGEST
) lowerbound
);
216 idx
= value_sub (idx
, bound
);
219 array
= value_coerce_array (array
);
222 if (TYPE_CODE (tarray
) == TYPE_CODE_BITSTRING
)
224 struct type
*range_type
= TYPE_INDEX_TYPE (tarray
);
225 LONGEST index
= value_as_long (idx
);
227 int offset
, byte
, bit_index
;
228 LONGEST lowerbound
, upperbound
;
229 get_discrete_bounds (range_type
, &lowerbound
, &upperbound
);
230 if (index
< lowerbound
|| index
> upperbound
)
231 error ("bitstring index out of range");
233 offset
= index
/ TARGET_CHAR_BIT
;
234 byte
= *((char *) VALUE_CONTENTS (array
) + offset
);
235 bit_index
= index
% TARGET_CHAR_BIT
;
236 byte
>>= (BITS_BIG_ENDIAN
? TARGET_CHAR_BIT
- 1 - bit_index
: bit_index
);
237 v
= value_from_longest (LA_BOOL_TYPE
, byte
& 1);
238 VALUE_BITPOS (v
) = bit_index
;
239 VALUE_BITSIZE (v
) = 1;
240 VALUE_LVAL (v
) = VALUE_LVAL (array
);
241 if (VALUE_LVAL (array
) == lval_internalvar
)
242 VALUE_LVAL (v
) = lval_internalvar_component
;
243 VALUE_ADDRESS (v
) = VALUE_ADDRESS (array
);
244 VALUE_OFFSET (v
) = offset
+ VALUE_OFFSET (array
);
249 return value_ind (value_add (array
, idx
));
251 error ("not an array or string");
254 /* Return the value of EXPR[IDX], expr an aggregate rvalue
255 (eg, a vector register). This routine used to promote floats
256 to doubles, but no longer does. */
258 static struct value
*
259 value_subscripted_rvalue (struct value
*array
, struct value
*idx
, int lowerbound
)
261 struct type
*array_type
= check_typedef (VALUE_TYPE (array
));
262 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (array_type
));
263 unsigned int elt_size
= TYPE_LENGTH (elt_type
);
264 LONGEST index
= value_as_long (idx
);
265 unsigned int elt_offs
= elt_size
* longest_to_int (index
- lowerbound
);
268 if (index
< lowerbound
|| elt_offs
>= TYPE_LENGTH (array_type
))
269 error ("no such vector element");
271 v
= allocate_value (elt_type
);
272 if (VALUE_LAZY (array
))
275 memcpy (VALUE_CONTENTS (v
), VALUE_CONTENTS (array
) + elt_offs
, elt_size
);
277 if (VALUE_LVAL (array
) == lval_internalvar
)
278 VALUE_LVAL (v
) = lval_internalvar_component
;
280 VALUE_LVAL (v
) = VALUE_LVAL (array
);
281 VALUE_ADDRESS (v
) = VALUE_ADDRESS (array
);
282 VALUE_REGNO (v
) = VALUE_REGNO (array
);
283 VALUE_OFFSET (v
) = VALUE_OFFSET (array
) + elt_offs
;
287 /* Check to see if either argument is a structure. This is called so
288 we know whether to go ahead with the normal binop or look for a
289 user defined function instead.
291 For now, we do not overload the `=' operator. */
294 binop_user_defined_p (enum exp_opcode op
, struct value
*arg1
, struct value
*arg2
)
296 struct type
*type1
, *type2
;
297 if (op
== BINOP_ASSIGN
|| op
== BINOP_CONCAT
)
299 type1
= check_typedef (VALUE_TYPE (arg1
));
300 type2
= check_typedef (VALUE_TYPE (arg2
));
301 return (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
302 || TYPE_CODE (type2
) == TYPE_CODE_STRUCT
303 || (TYPE_CODE (type1
) == TYPE_CODE_REF
304 && TYPE_CODE (TYPE_TARGET_TYPE (type1
)) == TYPE_CODE_STRUCT
)
305 || (TYPE_CODE (type2
) == TYPE_CODE_REF
306 && TYPE_CODE (TYPE_TARGET_TYPE (type2
)) == TYPE_CODE_STRUCT
));
309 /* Check to see if argument is a structure. This is called so
310 we know whether to go ahead with the normal unop or look for a
311 user defined function instead.
313 For now, we do not overload the `&' operator. */
316 unop_user_defined_p (enum exp_opcode op
, struct value
*arg1
)
321 type1
= check_typedef (VALUE_TYPE (arg1
));
324 if (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
)
326 else if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
327 type1
= TYPE_TARGET_TYPE (type1
);
333 /* We know either arg1 or arg2 is a structure, so try to find the right
334 user defined function. Create an argument vector that calls
335 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
336 binary operator which is legal for GNU C++).
338 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
339 is the opcode saying how to modify it. Otherwise, OTHEROP is
343 value_x_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
,
344 enum exp_opcode otherop
, enum noside noside
)
346 struct value
**argvec
;
356 /* now we know that what we have to do is construct our
357 arg vector and find the right function to call it with. */
359 if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1
))) != TYPE_CODE_STRUCT
)
360 error ("Can't do that binary op on that type"); /* FIXME be explicit */
362 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
363 argvec
[1] = value_addr (arg1
);
367 /* make the right function name up */
368 strcpy (tstr
, "operator__");
393 case BINOP_BITWISE_AND
:
396 case BINOP_BITWISE_IOR
:
399 case BINOP_BITWISE_XOR
:
402 case BINOP_LOGICAL_AND
:
405 case BINOP_LOGICAL_OR
:
417 case BINOP_ASSIGN_MODIFY
:
435 case BINOP_BITWISE_AND
:
438 case BINOP_BITWISE_IOR
:
441 case BINOP_BITWISE_XOR
:
444 case BINOP_MOD
: /* invalid */
446 error ("Invalid binary operation specified.");
449 case BINOP_SUBSCRIPT
:
470 case BINOP_MOD
: /* invalid */
472 error ("Invalid binary operation specified.");
475 argvec
[0] = value_struct_elt (&arg1
, argvec
+ 1, tstr
, &static_memfuncp
, "structure");
481 argvec
[1] = argvec
[0];
484 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
486 struct type
*return_type
;
488 = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (argvec
[0])));
489 return value_zero (return_type
, VALUE_LVAL (arg1
));
491 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
493 error ("member function %s not found", tstr
);
495 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
499 /* We know that arg1 is a structure, so try to find a unary user
500 defined operator that matches the operator in question.
501 Create an argument vector that calls arg1.operator @ (arg1)
502 and return that value (where '@' is (almost) any unary operator which
503 is legal for GNU C++). */
506 value_x_unop (struct value
*arg1
, enum exp_opcode op
, enum noside noside
)
508 struct value
**argvec
;
509 char *ptr
, *mangle_ptr
;
510 char tstr
[13], mangle_tstr
[13];
511 int static_memfuncp
, nargs
;
516 /* now we know that what we have to do is construct our
517 arg vector and find the right function to call it with. */
519 if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1
))) != TYPE_CODE_STRUCT
)
520 error ("Can't do that unary op on that type"); /* FIXME be explicit */
522 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
523 argvec
[1] = value_addr (arg1
);
528 /* make the right function name up */
529 strcpy (tstr
, "operator__");
531 strcpy (mangle_tstr
, "__");
532 mangle_ptr
= mangle_tstr
+ 2;
535 case UNOP_PREINCREMENT
:
538 case UNOP_PREDECREMENT
:
541 case UNOP_POSTINCREMENT
:
543 argvec
[2] = value_from_longest (builtin_type_int
, 0);
547 case UNOP_POSTDECREMENT
:
549 argvec
[2] = value_from_longest (builtin_type_int
, 0);
553 case UNOP_LOGICAL_NOT
:
556 case UNOP_COMPLEMENT
:
566 error ("Invalid unary operation specified.");
569 argvec
[0] = value_struct_elt (&arg1
, argvec
+ 1, tstr
, &static_memfuncp
, "structure");
575 argvec
[1] = argvec
[0];
579 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
581 struct type
*return_type
;
583 = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (argvec
[0])));
584 return value_zero (return_type
, VALUE_LVAL (arg1
));
586 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
588 error ("member function %s not found", tstr
);
589 return 0; /* For lint -- never reached */
593 /* Concatenate two values with the following conditions:
595 (1) Both values must be either bitstring values or character string
596 values and the resulting value consists of the concatenation of
597 ARG1 followed by ARG2.
601 One value must be an integer value and the other value must be
602 either a bitstring value or character string value, which is
603 to be repeated by the number of times specified by the integer
607 (2) Boolean values are also allowed and are treated as bit string
610 (3) Character values are also allowed and are treated as character
611 string values of length 1.
615 value_concat (struct value
*arg1
, struct value
*arg2
)
617 struct value
*inval1
;
618 struct value
*inval2
;
619 struct value
*outval
= NULL
;
620 int inval1len
, inval2len
;
624 struct type
*type1
= check_typedef (VALUE_TYPE (arg1
));
625 struct type
*type2
= check_typedef (VALUE_TYPE (arg2
));
627 COERCE_VARYING_ARRAY (arg1
, type1
);
628 COERCE_VARYING_ARRAY (arg2
, type2
);
630 /* First figure out if we are dealing with two values to be concatenated
631 or a repeat count and a value to be repeated. INVAL1 is set to the
632 first of two concatenated values, or the repeat count. INVAL2 is set
633 to the second of the two concatenated values or the value to be
636 if (TYPE_CODE (type2
) == TYPE_CODE_INT
)
638 struct type
*tmp
= type1
;
650 /* Now process the input values. */
652 if (TYPE_CODE (type1
) == TYPE_CODE_INT
)
654 /* We have a repeat count. Validate the second value and then
655 construct a value repeated that many times. */
656 if (TYPE_CODE (type2
) == TYPE_CODE_STRING
657 || TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
659 count
= longest_to_int (value_as_long (inval1
));
660 inval2len
= TYPE_LENGTH (type2
);
661 ptr
= (char *) alloca (count
* inval2len
);
662 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
664 inchar
= (char) unpack_long (type2
,
665 VALUE_CONTENTS (inval2
));
666 for (idx
= 0; idx
< count
; idx
++)
668 *(ptr
+ idx
) = inchar
;
673 for (idx
= 0; idx
< count
; idx
++)
675 memcpy (ptr
+ (idx
* inval2len
), VALUE_CONTENTS (inval2
),
679 outval
= value_string (ptr
, count
* inval2len
);
681 else if (TYPE_CODE (type2
) == TYPE_CODE_BITSTRING
682 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
684 error ("unimplemented support for bitstring/boolean repeats");
688 error ("can't repeat values of that type");
691 else if (TYPE_CODE (type1
) == TYPE_CODE_STRING
692 || TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
694 /* We have two character strings to concatenate. */
695 if (TYPE_CODE (type2
) != TYPE_CODE_STRING
696 && TYPE_CODE (type2
) != TYPE_CODE_CHAR
)
698 error ("Strings can only be concatenated with other strings.");
700 inval1len
= TYPE_LENGTH (type1
);
701 inval2len
= TYPE_LENGTH (type2
);
702 ptr
= (char *) alloca (inval1len
+ inval2len
);
703 if (TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
705 *ptr
= (char) unpack_long (type1
, VALUE_CONTENTS (inval1
));
709 memcpy (ptr
, VALUE_CONTENTS (inval1
), inval1len
);
711 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
714 (char) unpack_long (type2
, VALUE_CONTENTS (inval2
));
718 memcpy (ptr
+ inval1len
, VALUE_CONTENTS (inval2
), inval2len
);
720 outval
= value_string (ptr
, inval1len
+ inval2len
);
722 else if (TYPE_CODE (type1
) == TYPE_CODE_BITSTRING
723 || TYPE_CODE (type1
) == TYPE_CODE_BOOL
)
725 /* We have two bitstrings to concatenate. */
726 if (TYPE_CODE (type2
) != TYPE_CODE_BITSTRING
727 && TYPE_CODE (type2
) != TYPE_CODE_BOOL
)
729 error ("Bitstrings or booleans can only be concatenated with other bitstrings or booleans.");
731 error ("unimplemented support for bitstring/boolean concatenation.");
735 /* We don't know how to concatenate these operands. */
736 error ("illegal operands for concatenation.");
743 /* Perform a binary operation on two operands which have reasonable
744 representations as integers or floats. This includes booleans,
745 characters, integers, or floats.
746 Does not support addition and subtraction on pointers;
747 use value_add or value_sub if you want to handle those possibilities. */
750 value_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
753 struct type
*type1
, *type2
;
757 type1
= check_typedef (VALUE_TYPE (arg1
));
758 type2
= check_typedef (VALUE_TYPE (arg2
));
760 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
&& !is_integral_type (type1
))
762 (TYPE_CODE (type2
) != TYPE_CODE_FLT
&& !is_integral_type (type2
)))
763 error ("Argument to arithmetic operation not a number or boolean.");
765 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
767 TYPE_CODE (type2
) == TYPE_CODE_FLT
)
769 /* FIXME-if-picky-about-floating-accuracy: Should be doing this
770 in target format. real.c in GCC probably has the necessary
772 DOUBLEST v1
, v2
, v
= 0;
773 v1
= value_as_double (arg1
);
774 v2
= value_as_double (arg2
);
796 error ("Cannot perform exponentiation: %s", safe_strerror (errno
));
800 error ("Integer-only operation on floating point number.");
803 /* If either arg was long double, make sure that value is also long
806 if (TYPE_LENGTH (type1
) * 8 > TARGET_DOUBLE_BIT
807 || TYPE_LENGTH (type2
) * 8 > TARGET_DOUBLE_BIT
)
808 val
= allocate_value (builtin_type_long_double
);
810 val
= allocate_value (builtin_type_double
);
812 store_typed_floating (VALUE_CONTENTS_RAW (val
), VALUE_TYPE (val
), v
);
814 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
816 TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
818 LONGEST v1
, v2
, v
= 0;
819 v1
= value_as_long (arg1
);
820 v2
= value_as_long (arg2
);
824 case BINOP_BITWISE_AND
:
828 case BINOP_BITWISE_IOR
:
832 case BINOP_BITWISE_XOR
:
845 error ("Invalid operation on booleans.");
848 val
= allocate_value (type1
);
849 store_signed_integer (VALUE_CONTENTS_RAW (val
),
854 /* Integral operations here. */
855 /* FIXME: Also mixed integral/booleans, with result an integer. */
856 /* FIXME: This implements ANSI C rules (also correct for C++).
857 What about FORTRAN and (the deleted) chill ? */
859 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
860 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
861 int is_unsigned1
= TYPE_UNSIGNED (type1
);
862 int is_unsigned2
= TYPE_UNSIGNED (type2
);
863 unsigned int result_len
;
864 int unsigned_operation
;
866 /* Determine type length and signedness after promotion for
868 if (promoted_len1
< TYPE_LENGTH (builtin_type_int
))
871 promoted_len1
= TYPE_LENGTH (builtin_type_int
);
873 if (promoted_len2
< TYPE_LENGTH (builtin_type_int
))
876 promoted_len2
= TYPE_LENGTH (builtin_type_int
);
879 /* Determine type length of the result, and if the operation should
881 Use the signedness of the operand with the greater length.
882 If both operands are of equal length, use unsigned operation
883 if one of the operands is unsigned. */
884 if (promoted_len1
> promoted_len2
)
886 unsigned_operation
= is_unsigned1
;
887 result_len
= promoted_len1
;
889 else if (promoted_len2
> promoted_len1
)
891 unsigned_operation
= is_unsigned2
;
892 result_len
= promoted_len2
;
896 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
897 result_len
= promoted_len1
;
900 if (unsigned_operation
)
902 ULONGEST v1
, v2
, v
= 0;
903 v1
= (ULONGEST
) value_as_long (arg1
);
904 v2
= (ULONGEST
) value_as_long (arg2
);
906 /* Truncate values to the type length of the result. */
907 if (result_len
< sizeof (ULONGEST
))
909 v1
&= ((LONGEST
) 1 << HOST_CHAR_BIT
* result_len
) - 1;
910 v2
&= ((LONGEST
) 1 << HOST_CHAR_BIT
* result_len
) - 1;
934 error ("Cannot perform exponentiation: %s", safe_strerror (errno
));
942 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
943 v1 mod 0 has a defined value, v1. */
951 /* Note floor(v1/v2) == v1/v2 for unsigned. */
964 case BINOP_BITWISE_AND
:
968 case BINOP_BITWISE_IOR
:
972 case BINOP_BITWISE_XOR
:
976 case BINOP_LOGICAL_AND
:
980 case BINOP_LOGICAL_OR
:
985 v
= v1
< v2
? v1
: v2
;
989 v
= v1
> v2
? v1
: v2
;
1005 error ("Invalid binary operation on numbers.");
1008 /* This is a kludge to get around the fact that we don't
1009 know how to determine the result type from the types of
1010 the operands. (I'm not really sure how much we feel the
1011 need to duplicate the exact rules of the current
1012 language. They can get really hairy. But not to do so
1013 makes it hard to document just what we *do* do). */
1015 /* Can't just call init_type because we wouldn't know what
1016 name to give the type. */
1017 val
= allocate_value
1018 (result_len
> TARGET_LONG_BIT
/ HOST_CHAR_BIT
1019 ? builtin_type_unsigned_long_long
1020 : builtin_type_unsigned_long
);
1021 store_unsigned_integer (VALUE_CONTENTS_RAW (val
),
1022 TYPE_LENGTH (VALUE_TYPE (val
)),
1027 LONGEST v1
, v2
, v
= 0;
1028 v1
= value_as_long (arg1
);
1029 v2
= value_as_long (arg2
);
1049 error ("Division by zero");
1055 error ("Cannot perform exponentiation: %s", safe_strerror (errno
));
1062 error ("Division by zero");
1066 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1067 X mod 0 has a defined value, X. */
1075 /* Compute floor. */
1076 if (TRUNCATION_TOWARDS_ZERO
&& (v
< 0) && ((v1
% v2
) != 0))
1092 case BINOP_BITWISE_AND
:
1096 case BINOP_BITWISE_IOR
:
1100 case BINOP_BITWISE_XOR
:
1104 case BINOP_LOGICAL_AND
:
1108 case BINOP_LOGICAL_OR
:
1113 v
= v1
< v2
? v1
: v2
;
1117 v
= v1
> v2
? v1
: v2
;
1129 error ("Invalid binary operation on numbers.");
1132 /* This is a kludge to get around the fact that we don't
1133 know how to determine the result type from the types of
1134 the operands. (I'm not really sure how much we feel the
1135 need to duplicate the exact rules of the current
1136 language. They can get really hairy. But not to do so
1137 makes it hard to document just what we *do* do). */
1139 /* Can't just call init_type because we wouldn't know what
1140 name to give the type. */
1141 val
= allocate_value
1142 (result_len
> TARGET_LONG_BIT
/ HOST_CHAR_BIT
1143 ? builtin_type_long_long
1144 : builtin_type_long
);
1145 store_signed_integer (VALUE_CONTENTS_RAW (val
),
1146 TYPE_LENGTH (VALUE_TYPE (val
)),
1154 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1157 value_logical_not (struct value
*arg1
)
1163 COERCE_NUMBER (arg1
);
1164 type1
= check_typedef (VALUE_TYPE (arg1
));
1166 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
)
1167 return 0 == value_as_double (arg1
);
1169 len
= TYPE_LENGTH (type1
);
1170 p
= VALUE_CONTENTS (arg1
);
1181 /* Perform a comparison on two string values (whose content are not
1182 necessarily null terminated) based on their length */
1185 value_strcmp (struct value
*arg1
, struct value
*arg2
)
1187 int len1
= TYPE_LENGTH (VALUE_TYPE (arg1
));
1188 int len2
= TYPE_LENGTH (VALUE_TYPE (arg2
));
1189 char *s1
= VALUE_CONTENTS (arg1
);
1190 char *s2
= VALUE_CONTENTS (arg2
);
1191 int i
, len
= len1
< len2
? len1
: len2
;
1193 for (i
= 0; i
< len
; i
++)
1197 else if (s1
[i
] > s2
[i
])
1205 else if (len1
> len2
)
1211 /* Simulate the C operator == by returning a 1
1212 iff ARG1 and ARG2 have equal contents. */
1215 value_equal (struct value
*arg1
, struct value
*arg2
)
1219 struct type
*type1
, *type2
;
1220 enum type_code code1
;
1221 enum type_code code2
;
1222 int is_int1
, is_int2
;
1224 COERCE_ARRAY (arg1
);
1225 COERCE_ARRAY (arg2
);
1227 type1
= check_typedef (VALUE_TYPE (arg1
));
1228 type2
= check_typedef (VALUE_TYPE (arg2
));
1229 code1
= TYPE_CODE (type1
);
1230 code2
= TYPE_CODE (type2
);
1231 is_int1
= is_integral_type (type1
);
1232 is_int2
= is_integral_type (type2
);
1234 if (is_int1
&& is_int2
)
1235 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1237 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1238 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1239 return value_as_double (arg1
) == value_as_double (arg2
);
1241 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1243 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1244 return value_as_address (arg1
) == (CORE_ADDR
) value_as_long (arg2
);
1245 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1246 return (CORE_ADDR
) value_as_long (arg1
) == value_as_address (arg2
);
1248 else if (code1
== code2
1249 && ((len
= (int) TYPE_LENGTH (type1
))
1250 == (int) TYPE_LENGTH (type2
)))
1252 p1
= VALUE_CONTENTS (arg1
);
1253 p2
= VALUE_CONTENTS (arg2
);
1261 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1263 return value_strcmp (arg1
, arg2
) == 0;
1267 error ("Invalid type combination in equality test.");
1268 return 0; /* For lint -- never reached */
1272 /* Simulate the C operator < by returning 1
1273 iff ARG1's contents are less than ARG2's. */
1276 value_less (struct value
*arg1
, struct value
*arg2
)
1278 enum type_code code1
;
1279 enum type_code code2
;
1280 struct type
*type1
, *type2
;
1281 int is_int1
, is_int2
;
1283 COERCE_ARRAY (arg1
);
1284 COERCE_ARRAY (arg2
);
1286 type1
= check_typedef (VALUE_TYPE (arg1
));
1287 type2
= check_typedef (VALUE_TYPE (arg2
));
1288 code1
= TYPE_CODE (type1
);
1289 code2
= TYPE_CODE (type2
);
1290 is_int1
= is_integral_type (type1
);
1291 is_int2
= is_integral_type (type2
);
1293 if (is_int1
&& is_int2
)
1294 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1296 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1297 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1298 return value_as_double (arg1
) < value_as_double (arg2
);
1299 else if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
1300 return value_as_address (arg1
) < value_as_address (arg2
);
1302 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1304 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1305 return value_as_address (arg1
) < (CORE_ADDR
) value_as_long (arg2
);
1306 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1307 return (CORE_ADDR
) value_as_long (arg1
) < value_as_address (arg2
);
1308 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1309 return value_strcmp (arg1
, arg2
) < 0;
1312 error ("Invalid type combination in ordering comparison.");
1317 /* The unary operators - and ~. Both free the argument ARG1. */
1320 value_neg (struct value
*arg1
)
1323 struct type
*result_type
= VALUE_TYPE (arg1
);
1327 type
= check_typedef (VALUE_TYPE (arg1
));
1329 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1330 return value_from_double (result_type
, -value_as_double (arg1
));
1331 else if (is_integral_type (type
))
1333 /* Perform integral promotion for ANSI C/C++. FIXME: What about
1334 FORTRAN and (the deleted) chill ? */
1335 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
1336 result_type
= builtin_type_int
;
1338 return value_from_longest (result_type
, -value_as_long (arg1
));
1342 error ("Argument to negate operation not a number.");
1343 return 0; /* For lint -- never reached */
1348 value_complement (struct value
*arg1
)
1351 struct type
*result_type
= VALUE_TYPE (arg1
);
1355 type
= check_typedef (VALUE_TYPE (arg1
));
1357 if (!is_integral_type (type
))
1358 error ("Argument to complement operation not an integer or boolean.");
1360 /* Perform integral promotion for ANSI C/C++.
1361 FIXME: What about FORTRAN ? */
1362 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
1363 result_type
= builtin_type_int
;
1365 return value_from_longest (result_type
, ~value_as_long (arg1
));
1368 /* The INDEX'th bit of SET value whose VALUE_TYPE is TYPE,
1369 and whose VALUE_CONTENTS is valaddr.
1370 Return -1 if out of range, -2 other error. */
1373 value_bit_index (struct type
*type
, char *valaddr
, int index
)
1375 LONGEST low_bound
, high_bound
;
1378 struct type
*range
= TYPE_FIELD_TYPE (type
, 0);
1379 if (get_discrete_bounds (range
, &low_bound
, &high_bound
) < 0)
1381 if (index
< low_bound
|| index
> high_bound
)
1383 rel_index
= index
- low_bound
;
1384 word
= unpack_long (builtin_type_unsigned_char
,
1385 valaddr
+ (rel_index
/ TARGET_CHAR_BIT
));
1386 rel_index
%= TARGET_CHAR_BIT
;
1387 if (BITS_BIG_ENDIAN
)
1388 rel_index
= TARGET_CHAR_BIT
- 1 - rel_index
;
1389 return (word
>> rel_index
) & 1;
1393 value_in (struct value
*element
, struct value
*set
)
1396 struct type
*settype
= check_typedef (VALUE_TYPE (set
));
1397 struct type
*eltype
= check_typedef (VALUE_TYPE (element
));
1398 if (TYPE_CODE (eltype
) == TYPE_CODE_RANGE
)
1399 eltype
= TYPE_TARGET_TYPE (eltype
);
1400 if (TYPE_CODE (settype
) != TYPE_CODE_SET
)
1401 error ("Second argument of 'IN' has wrong type");
1402 if (TYPE_CODE (eltype
) != TYPE_CODE_INT
1403 && TYPE_CODE (eltype
) != TYPE_CODE_CHAR
1404 && TYPE_CODE (eltype
) != TYPE_CODE_ENUM
1405 && TYPE_CODE (eltype
) != TYPE_CODE_BOOL
)
1406 error ("First argument of 'IN' has wrong type");
1407 member
= value_bit_index (settype
, VALUE_CONTENTS (set
),
1408 value_as_long (element
));
1410 error ("First argument of 'IN' not in range");
1411 return value_from_longest (LA_BOOL_TYPE
, member
);
1415 _initialize_valarith (void)