1 /* Perform arithmetic and other operations on values, for GDB.
2 Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
27 #include "expression.h"
30 #include "gdb_string.h"
34 /* Define whether or not the C operator '/' truncates towards zero for
35 differently signed operands (truncation direction is undefined in C). */
37 #ifndef TRUNCATION_TOWARDS_ZERO
38 #define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
41 static value_ptr
value_subscripted_rvalue (value_ptr
, value_ptr
, int);
43 void _initialize_valarith (void);
47 value_add (value_ptr arg1
, value_ptr arg2
)
49 register value_ptr valint
, valptr
;
51 struct type
*type1
, *type2
, *valptrtype
;
55 type1
= check_typedef (VALUE_TYPE (arg1
));
56 type2
= check_typedef (VALUE_TYPE (arg2
));
58 if ((TYPE_CODE (type1
) == TYPE_CODE_PTR
59 || TYPE_CODE (type2
) == TYPE_CODE_PTR
)
61 (TYPE_CODE (type1
) == TYPE_CODE_INT
62 || TYPE_CODE (type2
) == TYPE_CODE_INT
))
63 /* Exactly one argument is a pointer, and one is an integer. */
67 if (TYPE_CODE (type1
) == TYPE_CODE_PTR
)
79 len
= TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (valptrtype
)));
81 len
= 1; /* For (void *) */
82 retval
= value_from_pointer (valptrtype
,
83 value_as_pointer (valptr
)
84 + (len
* value_as_long (valint
)));
85 VALUE_BFD_SECTION (retval
) = VALUE_BFD_SECTION (valptr
);
89 return value_binop (arg1
, arg2
, BINOP_ADD
);
93 value_sub (value_ptr arg1
, value_ptr arg2
)
95 struct type
*type1
, *type2
;
98 type1
= check_typedef (VALUE_TYPE (arg1
));
99 type2
= check_typedef (VALUE_TYPE (arg2
));
101 if (TYPE_CODE (type1
) == TYPE_CODE_PTR
)
103 if (TYPE_CODE (type2
) == TYPE_CODE_INT
)
105 /* pointer - integer. */
106 LONGEST sz
= TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)));
107 return value_from_pointer (VALUE_TYPE (arg1
),
108 (value_as_pointer (arg1
)
109 - (sz
* value_as_long (arg2
))));
111 else if (TYPE_CODE (type2
) == TYPE_CODE_PTR
112 && TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)))
113 == TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2
))))
115 /* pointer to <type x> - pointer to <type x>. */
116 LONGEST sz
= TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)));
117 return value_from_longest
118 (builtin_type_long
, /* FIXME -- should be ptrdiff_t */
119 (value_as_long (arg1
) - value_as_long (arg2
)) / sz
);
124 First argument of `-' is a pointer and second argument is neither\n\
125 an integer nor a pointer of the same type.");
129 return value_binop (arg1
, arg2
, BINOP_SUB
);
132 /* Return the value of ARRAY[IDX].
133 See comments in value_coerce_array() for rationale for reason for
134 doing lower bounds adjustment here rather than there.
135 FIXME: Perhaps we should validate that the index is valid and if
136 verbosity is set, warn about invalid indices (but still use them). */
139 value_subscript (value_ptr array
, value_ptr idx
)
142 int c_style
= current_language
->c_style_arrays
;
146 tarray
= check_typedef (VALUE_TYPE (array
));
147 COERCE_VARYING_ARRAY (array
, tarray
);
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
, idx
, lowerbound
);
161 LONGEST index
= value_as_long (idx
);
162 if (index
>= lowerbound
&& index
<= upperbound
)
163 return value_subscripted_rvalue (array
, idx
, lowerbound
);
164 warning ("array or string index out of range");
165 /* fall doing C stuff */
171 bound
= value_from_longest (builtin_type_int
, (LONGEST
) lowerbound
);
172 idx
= value_sub (idx
, bound
);
175 array
= value_coerce_array (array
);
178 if (TYPE_CODE (tarray
) == TYPE_CODE_BITSTRING
)
180 struct type
*range_type
= TYPE_INDEX_TYPE (tarray
);
181 LONGEST index
= value_as_long (idx
);
183 int offset
, byte
, bit_index
;
184 LONGEST lowerbound
, upperbound
;
185 get_discrete_bounds (range_type
, &lowerbound
, &upperbound
);
186 if (index
< lowerbound
|| index
> upperbound
)
187 error ("bitstring index out of range");
189 offset
= index
/ TARGET_CHAR_BIT
;
190 byte
= *((char *) VALUE_CONTENTS (array
) + offset
);
191 bit_index
= index
% TARGET_CHAR_BIT
;
192 byte
>>= (BITS_BIG_ENDIAN
? TARGET_CHAR_BIT
- 1 - bit_index
: bit_index
);
193 v
= value_from_longest (LA_BOOL_TYPE
, byte
& 1);
194 VALUE_BITPOS (v
) = bit_index
;
195 VALUE_BITSIZE (v
) = 1;
196 VALUE_LVAL (v
) = VALUE_LVAL (array
);
197 if (VALUE_LVAL (array
) == lval_internalvar
)
198 VALUE_LVAL (v
) = lval_internalvar_component
;
199 VALUE_ADDRESS (v
) = VALUE_ADDRESS (array
);
200 VALUE_OFFSET (v
) = offset
+ VALUE_OFFSET (array
);
205 return value_ind (value_add (array
, idx
));
207 error ("not an array or string");
210 /* Return the value of EXPR[IDX], expr an aggregate rvalue
211 (eg, a vector register). This routine used to promote floats
212 to doubles, but no longer does. */
215 value_subscripted_rvalue (value_ptr array
, value_ptr idx
, int lowerbound
)
217 struct type
*array_type
= check_typedef (VALUE_TYPE (array
));
218 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (array_type
));
219 unsigned int elt_size
= TYPE_LENGTH (elt_type
);
220 LONGEST index
= value_as_long (idx
);
221 unsigned int elt_offs
= elt_size
* longest_to_int (index
- lowerbound
);
224 if (index
< lowerbound
|| elt_offs
>= TYPE_LENGTH (array_type
))
225 error ("no such vector element");
227 v
= allocate_value (elt_type
);
228 if (VALUE_LAZY (array
))
231 memcpy (VALUE_CONTENTS (v
), VALUE_CONTENTS (array
) + elt_offs
, elt_size
);
233 if (VALUE_LVAL (array
) == lval_internalvar
)
234 VALUE_LVAL (v
) = lval_internalvar_component
;
236 VALUE_LVAL (v
) = VALUE_LVAL (array
);
237 VALUE_ADDRESS (v
) = VALUE_ADDRESS (array
);
238 VALUE_OFFSET (v
) = VALUE_OFFSET (array
) + elt_offs
;
242 /* Check to see if either argument is a structure. This is called so
243 we know whether to go ahead with the normal binop or look for a
244 user defined function instead.
246 For now, we do not overload the `=' operator. */
249 binop_user_defined_p (enum exp_opcode op
, value_ptr arg1
, value_ptr arg2
)
251 struct type
*type1
, *type2
;
252 if (op
== BINOP_ASSIGN
|| op
== BINOP_CONCAT
)
254 type1
= check_typedef (VALUE_TYPE (arg1
));
255 type2
= check_typedef (VALUE_TYPE (arg2
));
256 return (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
257 || TYPE_CODE (type2
) == TYPE_CODE_STRUCT
258 || (TYPE_CODE (type1
) == TYPE_CODE_REF
259 && TYPE_CODE (TYPE_TARGET_TYPE (type1
)) == TYPE_CODE_STRUCT
)
260 || (TYPE_CODE (type2
) == TYPE_CODE_REF
261 && TYPE_CODE (TYPE_TARGET_TYPE (type2
)) == TYPE_CODE_STRUCT
));
264 /* Check to see if argument is a structure. This is called so
265 we know whether to go ahead with the normal unop or look for a
266 user defined function instead.
268 For now, we do not overload the `&' operator. */
271 unop_user_defined_p (enum exp_opcode op
, value_ptr arg1
)
276 type1
= check_typedef (VALUE_TYPE (arg1
));
279 if (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
)
281 else if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
282 type1
= TYPE_TARGET_TYPE (type1
);
288 /* We know either arg1 or arg2 is a structure, so try to find the right
289 user defined function. Create an argument vector that calls
290 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
291 binary operator which is legal for GNU C++).
293 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
294 is the opcode saying how to modify it. Otherwise, OTHEROP is
298 value_x_binop (value_ptr arg1
, value_ptr arg2
, enum exp_opcode op
,
299 enum exp_opcode otherop
, enum noside noside
)
311 /* now we know that what we have to do is construct our
312 arg vector and find the right function to call it with. */
314 if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1
))) != TYPE_CODE_STRUCT
)
315 error ("Can't do that binary op on that type"); /* FIXME be explicit */
317 argvec
= (value_ptr
*) alloca (sizeof (value_ptr
) * 4);
318 argvec
[1] = value_addr (arg1
);
322 /* make the right function name up */
323 strcpy (tstr
, "operator__");
348 case BINOP_BITWISE_AND
:
351 case BINOP_BITWISE_IOR
:
354 case BINOP_BITWISE_XOR
:
357 case BINOP_LOGICAL_AND
:
360 case BINOP_LOGICAL_OR
:
372 case BINOP_ASSIGN_MODIFY
:
390 case BINOP_BITWISE_AND
:
393 case BINOP_BITWISE_IOR
:
396 case BINOP_BITWISE_XOR
:
399 case BINOP_MOD
: /* invalid */
401 error ("Invalid binary operation specified.");
404 case BINOP_SUBSCRIPT
:
425 case BINOP_MOD
: /* invalid */
427 error ("Invalid binary operation specified.");
430 argvec
[0] = value_struct_elt (&arg1
, argvec
+ 1, tstr
, &static_memfuncp
, "structure");
436 argvec
[1] = argvec
[0];
439 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
441 struct type
*return_type
;
443 = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (argvec
[0])));
444 return value_zero (return_type
, VALUE_LVAL (arg1
));
446 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
448 error ("member function %s not found", tstr
);
450 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
454 /* We know that arg1 is a structure, so try to find a unary user
455 defined operator that matches the operator in question.
456 Create an argument vector that calls arg1.operator @ (arg1)
457 and return that value (where '@' is (almost) any unary operator which
458 is legal for GNU C++). */
461 value_x_unop (value_ptr arg1
, enum exp_opcode op
, enum noside noside
)
464 char *ptr
, *mangle_ptr
;
465 char tstr
[13], mangle_tstr
[13];
471 /* now we know that what we have to do is construct our
472 arg vector and find the right function to call it with. */
474 if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1
))) != TYPE_CODE_STRUCT
)
475 error ("Can't do that unary op on that type"); /* FIXME be explicit */
477 argvec
= (value_ptr
*) alloca (sizeof (value_ptr
) * 3);
478 argvec
[1] = value_addr (arg1
);
481 /* make the right function name up */
482 strcpy (tstr
, "operator__");
484 strcpy (mangle_tstr
, "__");
485 mangle_ptr
= mangle_tstr
+ 2;
488 case UNOP_PREINCREMENT
:
491 case UNOP_PREDECREMENT
:
494 case UNOP_POSTINCREMENT
:
497 case UNOP_POSTDECREMENT
:
500 case UNOP_LOGICAL_NOT
:
503 case UNOP_COMPLEMENT
:
513 error ("Invalid unary operation specified.");
516 argvec
[0] = value_struct_elt (&arg1
, argvec
+ 1, tstr
, &static_memfuncp
, "structure");
522 argvec
[1] = argvec
[0];
525 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
527 struct type
*return_type
;
529 = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (argvec
[0])));
530 return value_zero (return_type
, VALUE_LVAL (arg1
));
532 return call_function_by_hand (argvec
[0], 1 - static_memfuncp
, argvec
+ 1);
534 error ("member function %s not found", tstr
);
535 return 0; /* For lint -- never reached */
539 /* Concatenate two values with the following conditions:
541 (1) Both values must be either bitstring values or character string
542 values and the resulting value consists of the concatenation of
543 ARG1 followed by ARG2.
547 One value must be an integer value and the other value must be
548 either a bitstring value or character string value, which is
549 to be repeated by the number of times specified by the integer
553 (2) Boolean values are also allowed and are treated as bit string
556 (3) Character values are also allowed and are treated as character
557 string values of length 1.
561 value_concat (value_ptr arg1
, value_ptr arg2
)
563 register value_ptr inval1
, inval2
, outval
= NULL
;
564 int inval1len
, inval2len
;
568 struct type
*type1
= check_typedef (VALUE_TYPE (arg1
));
569 struct type
*type2
= check_typedef (VALUE_TYPE (arg2
));
571 COERCE_VARYING_ARRAY (arg1
, type1
);
572 COERCE_VARYING_ARRAY (arg2
, type2
);
574 /* First figure out if we are dealing with two values to be concatenated
575 or a repeat count and a value to be repeated. INVAL1 is set to the
576 first of two concatenated values, or the repeat count. INVAL2 is set
577 to the second of the two concatenated values or the value to be
580 if (TYPE_CODE (type2
) == TYPE_CODE_INT
)
582 struct type
*tmp
= type1
;
594 /* Now process the input values. */
596 if (TYPE_CODE (type1
) == TYPE_CODE_INT
)
598 /* We have a repeat count. Validate the second value and then
599 construct a value repeated that many times. */
600 if (TYPE_CODE (type2
) == TYPE_CODE_STRING
601 || TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
603 count
= longest_to_int (value_as_long (inval1
));
604 inval2len
= TYPE_LENGTH (type2
);
605 ptr
= (char *) alloca (count
* inval2len
);
606 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
608 inchar
= (char) unpack_long (type2
,
609 VALUE_CONTENTS (inval2
));
610 for (idx
= 0; idx
< count
; idx
++)
612 *(ptr
+ idx
) = inchar
;
617 for (idx
= 0; idx
< count
; idx
++)
619 memcpy (ptr
+ (idx
* inval2len
), VALUE_CONTENTS (inval2
),
623 outval
= value_string (ptr
, count
* inval2len
);
625 else if (TYPE_CODE (type2
) == TYPE_CODE_BITSTRING
626 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
628 error ("unimplemented support for bitstring/boolean repeats");
632 error ("can't repeat values of that type");
635 else if (TYPE_CODE (type1
) == TYPE_CODE_STRING
636 || TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
638 /* We have two character strings to concatenate. */
639 if (TYPE_CODE (type2
) != TYPE_CODE_STRING
640 && TYPE_CODE (type2
) != TYPE_CODE_CHAR
)
642 error ("Strings can only be concatenated with other strings.");
644 inval1len
= TYPE_LENGTH (type1
);
645 inval2len
= TYPE_LENGTH (type2
);
646 ptr
= (char *) alloca (inval1len
+ inval2len
);
647 if (TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
649 *ptr
= (char) unpack_long (type1
, VALUE_CONTENTS (inval1
));
653 memcpy (ptr
, VALUE_CONTENTS (inval1
), inval1len
);
655 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
658 (char) unpack_long (type2
, VALUE_CONTENTS (inval2
));
662 memcpy (ptr
+ inval1len
, VALUE_CONTENTS (inval2
), inval2len
);
664 outval
= value_string (ptr
, inval1len
+ inval2len
);
666 else if (TYPE_CODE (type1
) == TYPE_CODE_BITSTRING
667 || TYPE_CODE (type1
) == TYPE_CODE_BOOL
)
669 /* We have two bitstrings to concatenate. */
670 if (TYPE_CODE (type2
) != TYPE_CODE_BITSTRING
671 && TYPE_CODE (type2
) != TYPE_CODE_BOOL
)
673 error ("Bitstrings or booleans can only be concatenated with other bitstrings or booleans.");
675 error ("unimplemented support for bitstring/boolean concatenation.");
679 /* We don't know how to concatenate these operands. */
680 error ("illegal operands for concatenation.");
687 /* Perform a binary operation on two operands which have reasonable
688 representations as integers or floats. This includes booleans,
689 characters, integers, or floats.
690 Does not support addition and subtraction on pointers;
691 use value_add or value_sub if you want to handle those possibilities. */
694 value_binop (value_ptr arg1
, value_ptr arg2
, enum exp_opcode op
)
696 register value_ptr val
;
697 struct type
*type1
, *type2
;
703 type1
= check_typedef (VALUE_TYPE (arg1
));
704 type2
= check_typedef (VALUE_TYPE (arg2
));
706 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
707 && TYPE_CODE (type1
) != TYPE_CODE_CHAR
708 && TYPE_CODE (type1
) != TYPE_CODE_INT
709 && TYPE_CODE (type1
) != TYPE_CODE_BOOL
710 && TYPE_CODE (type1
) != TYPE_CODE_RANGE
)
712 (TYPE_CODE (type2
) != TYPE_CODE_FLT
713 && TYPE_CODE (type2
) != TYPE_CODE_CHAR
714 && TYPE_CODE (type2
) != TYPE_CODE_INT
715 && TYPE_CODE (type2
) != TYPE_CODE_BOOL
716 && TYPE_CODE (type2
) != TYPE_CODE_RANGE
))
717 error ("Argument to arithmetic operation not a number or boolean.");
719 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
721 TYPE_CODE (type2
) == TYPE_CODE_FLT
)
723 /* FIXME-if-picky-about-floating-accuracy: Should be doing this
724 in target format. real.c in GCC probably has the necessary
726 DOUBLEST v1
, v2
, v
= 0;
727 v1
= value_as_double (arg1
);
728 v2
= value_as_double (arg2
);
750 error ("Cannot perform exponentiation: %s", strerror (errno
));
754 error ("Integer-only operation on floating point number.");
757 /* If either arg was long double, make sure that value is also long
760 if (TYPE_LENGTH (type1
) * 8 > TARGET_DOUBLE_BIT
761 || TYPE_LENGTH (type2
) * 8 > TARGET_DOUBLE_BIT
)
762 val
= allocate_value (builtin_type_long_double
);
764 val
= allocate_value (builtin_type_double
);
766 store_floating (VALUE_CONTENTS_RAW (val
), TYPE_LENGTH (VALUE_TYPE (val
)),
769 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
771 TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
773 LONGEST v1
, v2
, v
= 0;
774 v1
= value_as_long (arg1
);
775 v2
= value_as_long (arg2
);
779 case BINOP_BITWISE_AND
:
783 case BINOP_BITWISE_IOR
:
787 case BINOP_BITWISE_XOR
:
800 error ("Invalid operation on booleans.");
803 val
= allocate_value (type1
);
804 store_signed_integer (VALUE_CONTENTS_RAW (val
),
809 /* Integral operations here. */
810 /* FIXME: Also mixed integral/booleans, with result an integer. */
811 /* FIXME: This implements ANSI C rules (also correct for C++).
812 What about FORTRAN and chill? */
814 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
815 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
816 int is_unsigned1
= TYPE_UNSIGNED (type1
);
817 int is_unsigned2
= TYPE_UNSIGNED (type2
);
818 unsigned int result_len
;
819 int unsigned_operation
;
821 /* Determine type length and signedness after promotion for
823 if (promoted_len1
< TYPE_LENGTH (builtin_type_int
))
826 promoted_len1
= TYPE_LENGTH (builtin_type_int
);
828 if (promoted_len2
< TYPE_LENGTH (builtin_type_int
))
831 promoted_len2
= TYPE_LENGTH (builtin_type_int
);
834 /* Determine type length of the result, and if the operation should
836 Use the signedness of the operand with the greater length.
837 If both operands are of equal length, use unsigned operation
838 if one of the operands is unsigned. */
839 if (promoted_len1
> promoted_len2
)
841 unsigned_operation
= is_unsigned1
;
842 result_len
= promoted_len1
;
844 else if (promoted_len2
> promoted_len1
)
846 unsigned_operation
= is_unsigned2
;
847 result_len
= promoted_len2
;
851 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
852 result_len
= promoted_len1
;
855 if (unsigned_operation
)
857 ULONGEST v1
, v2
, v
= 0;
858 v1
= (ULONGEST
) value_as_long (arg1
);
859 v2
= (ULONGEST
) value_as_long (arg2
);
861 /* Truncate values to the type length of the result. */
862 if (result_len
< sizeof (ULONGEST
))
864 v1
&= ((LONGEST
) 1 << HOST_CHAR_BIT
* result_len
) - 1;
865 v2
&= ((LONGEST
) 1 << HOST_CHAR_BIT
* result_len
) - 1;
889 error ("Cannot perform exponentiation: %s", strerror (errno
));
897 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
898 v1 mod 0 has a defined value, v1. */
899 /* Chill specifies that v2 must be > 0, so check for that. */
900 if (current_language
->la_language
== language_chill
901 && value_as_long (arg2
) <= 0)
903 error ("Second operand of MOD must be greater than zero.");
912 /* Note floor(v1/v2) == v1/v2 for unsigned. */
925 case BINOP_BITWISE_AND
:
929 case BINOP_BITWISE_IOR
:
933 case BINOP_BITWISE_XOR
:
937 case BINOP_LOGICAL_AND
:
941 case BINOP_LOGICAL_OR
:
946 v
= v1
< v2
? v1
: v2
;
950 v
= v1
> v2
? v1
: v2
;
966 error ("Invalid binary operation on numbers.");
969 /* This is a kludge to get around the fact that we don't
970 know how to determine the result type from the types of
971 the operands. (I'm not really sure how much we feel the
972 need to duplicate the exact rules of the current
973 language. They can get really hairy. But not to do so
974 makes it hard to document just what we *do* do). */
976 /* Can't just call init_type because we wouldn't know what
977 name to give the type. */
979 (result_len
> TARGET_LONG_BIT
/ HOST_CHAR_BIT
980 ? builtin_type_unsigned_long_long
981 : builtin_type_unsigned_long
);
982 store_unsigned_integer (VALUE_CONTENTS_RAW (val
),
983 TYPE_LENGTH (VALUE_TYPE (val
)),
988 LONGEST v1
, v2
, v
= 0;
989 v1
= value_as_long (arg1
);
990 v2
= value_as_long (arg2
);
1013 error ("Cannot perform exponentiation: %s", strerror (errno
));
1021 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1022 X mod 0 has a defined value, X. */
1023 /* Chill specifies that v2 must be > 0, so check for that. */
1024 if (current_language
->la_language
== language_chill
1027 error ("Second operand of MOD must be greater than zero.");
1036 /* Compute floor. */
1037 if (TRUNCATION_TOWARDS_ZERO
&& (v
< 0) && ((v1
% v2
) != 0))
1053 case BINOP_BITWISE_AND
:
1057 case BINOP_BITWISE_IOR
:
1061 case BINOP_BITWISE_XOR
:
1065 case BINOP_LOGICAL_AND
:
1069 case BINOP_LOGICAL_OR
:
1074 v
= v1
< v2
? v1
: v2
;
1078 v
= v1
> v2
? v1
: v2
;
1090 error ("Invalid binary operation on numbers.");
1093 /* This is a kludge to get around the fact that we don't
1094 know how to determine the result type from the types of
1095 the operands. (I'm not really sure how much we feel the
1096 need to duplicate the exact rules of the current
1097 language. They can get really hairy. But not to do so
1098 makes it hard to document just what we *do* do). */
1100 /* Can't just call init_type because we wouldn't know what
1101 name to give the type. */
1102 val
= allocate_value
1103 (result_len
> TARGET_LONG_BIT
/ HOST_CHAR_BIT
1104 ? builtin_type_long_long
1105 : builtin_type_long
);
1106 store_signed_integer (VALUE_CONTENTS_RAW (val
),
1107 TYPE_LENGTH (VALUE_TYPE (val
)),
1115 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1118 value_logical_not (value_ptr arg1
)
1124 COERCE_NUMBER (arg1
);
1125 type1
= check_typedef (VALUE_TYPE (arg1
));
1127 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
)
1128 return 0 == value_as_double (arg1
);
1130 len
= TYPE_LENGTH (type1
);
1131 p
= VALUE_CONTENTS (arg1
);
1142 /* Perform a comparison on two string values (whose content are not
1143 necessarily null terminated) based on their length */
1146 value_strcmp (register value_ptr arg1
, register value_ptr arg2
)
1148 int len1
= TYPE_LENGTH (VALUE_TYPE (arg1
));
1149 int len2
= TYPE_LENGTH (VALUE_TYPE (arg2
));
1150 char *s1
= VALUE_CONTENTS (arg1
);
1151 char *s2
= VALUE_CONTENTS (arg2
);
1152 int i
, len
= len1
< len2
? len1
: len2
;
1154 for (i
= 0; i
< len
; i
++)
1158 else if (s1
[i
] > s2
[i
])
1166 else if (len1
> len2
)
1172 /* Simulate the C operator == by returning a 1
1173 iff ARG1 and ARG2 have equal contents. */
1176 value_equal (register value_ptr arg1
, register value_ptr arg2
)
1179 register char *p1
, *p2
;
1180 struct type
*type1
, *type2
;
1181 enum type_code code1
;
1182 enum type_code code2
;
1184 COERCE_NUMBER (arg1
);
1185 COERCE_NUMBER (arg2
);
1187 type1
= check_typedef (VALUE_TYPE (arg1
));
1188 type2
= check_typedef (VALUE_TYPE (arg2
));
1189 code1
= TYPE_CODE (type1
);
1190 code2
= TYPE_CODE (type2
);
1192 if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_BOOL
) &&
1193 (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_BOOL
))
1194 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1196 else if ((code1
== TYPE_CODE_FLT
|| code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_BOOL
)
1197 && (code2
== TYPE_CODE_FLT
|| code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_BOOL
))
1198 return value_as_double (arg1
) == value_as_double (arg2
);
1200 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1202 else if (code1
== TYPE_CODE_PTR
&& (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_BOOL
))
1203 return value_as_pointer (arg1
) == (CORE_ADDR
) value_as_long (arg2
);
1204 else if (code2
== TYPE_CODE_PTR
&& (code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_BOOL
))
1205 return (CORE_ADDR
) value_as_long (arg1
) == value_as_pointer (arg2
);
1207 else if (code1
== code2
1208 && ((len
= (int) TYPE_LENGTH (type1
))
1209 == (int) TYPE_LENGTH (type2
)))
1211 p1
= VALUE_CONTENTS (arg1
);
1212 p2
= VALUE_CONTENTS (arg2
);
1220 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1222 return value_strcmp (arg1
, arg2
) == 0;
1226 error ("Invalid type combination in equality test.");
1227 return 0; /* For lint -- never reached */
1231 /* Simulate the C operator < by returning 1
1232 iff ARG1's contents are less than ARG2's. */
1235 value_less (register value_ptr arg1
, register value_ptr arg2
)
1237 register enum type_code code1
;
1238 register enum type_code code2
;
1239 struct type
*type1
, *type2
;
1241 COERCE_NUMBER (arg1
);
1242 COERCE_NUMBER (arg2
);
1244 type1
= check_typedef (VALUE_TYPE (arg1
));
1245 type2
= check_typedef (VALUE_TYPE (arg2
));
1246 code1
= TYPE_CODE (type1
);
1247 code2
= TYPE_CODE (type2
);
1249 if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_BOOL
) &&
1250 (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_BOOL
))
1251 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1253 else if ((code1
== TYPE_CODE_FLT
|| code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_BOOL
)
1254 && (code2
== TYPE_CODE_FLT
|| code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_BOOL
))
1255 return value_as_double (arg1
) < value_as_double (arg2
);
1256 else if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
1257 return value_as_pointer (arg1
) < value_as_pointer (arg2
);
1259 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1261 else if (code1
== TYPE_CODE_PTR
&& (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_BOOL
))
1262 return value_as_pointer (arg1
) < (CORE_ADDR
) value_as_long (arg2
);
1263 else if (code2
== TYPE_CODE_PTR
&& (code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_BOOL
))
1264 return (CORE_ADDR
) value_as_long (arg1
) < value_as_pointer (arg2
);
1265 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1266 return value_strcmp (arg1
, arg2
) < 0;
1269 error ("Invalid type combination in ordering comparison.");
1274 /* The unary operators - and ~. Both free the argument ARG1. */
1277 value_neg (register value_ptr arg1
)
1279 register struct type
*type
;
1280 register struct type
*result_type
= VALUE_TYPE (arg1
);
1285 type
= check_typedef (VALUE_TYPE (arg1
));
1287 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1288 return value_from_double (result_type
, -value_as_double (arg1
));
1289 else if (TYPE_CODE (type
) == TYPE_CODE_INT
|| TYPE_CODE (type
) == TYPE_CODE_BOOL
)
1291 /* Perform integral promotion for ANSI C/C++.
1292 FIXME: What about FORTRAN and chill ? */
1293 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
1294 result_type
= builtin_type_int
;
1296 return value_from_longest (result_type
, -value_as_long (arg1
));
1300 error ("Argument to negate operation not a number.");
1301 return 0; /* For lint -- never reached */
1306 value_complement (register value_ptr arg1
)
1308 register struct type
*type
;
1309 register struct type
*result_type
= VALUE_TYPE (arg1
);
1315 type
= check_typedef (VALUE_TYPE (arg1
));
1317 typecode
= TYPE_CODE (type
);
1318 if ((typecode
!= TYPE_CODE_INT
) && (typecode
!= TYPE_CODE_BOOL
))
1319 error ("Argument to complement operation not an integer or boolean.");
1321 /* Perform integral promotion for ANSI C/C++.
1322 FIXME: What about FORTRAN ? */
1323 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
1324 result_type
= builtin_type_int
;
1326 return value_from_longest (result_type
, ~value_as_long (arg1
));
1329 /* The INDEX'th bit of SET value whose VALUE_TYPE is TYPE,
1330 and whose VALUE_CONTENTS is valaddr.
1331 Return -1 if out of range, -2 other error. */
1334 value_bit_index (struct type
*type
, char *valaddr
, int index
)
1336 LONGEST low_bound
, high_bound
;
1339 struct type
*range
= TYPE_FIELD_TYPE (type
, 0);
1340 if (get_discrete_bounds (range
, &low_bound
, &high_bound
) < 0)
1342 if (index
< low_bound
|| index
> high_bound
)
1344 rel_index
= index
- low_bound
;
1345 word
= unpack_long (builtin_type_unsigned_char
,
1346 valaddr
+ (rel_index
/ TARGET_CHAR_BIT
));
1347 rel_index
%= TARGET_CHAR_BIT
;
1348 if (BITS_BIG_ENDIAN
)
1349 rel_index
= TARGET_CHAR_BIT
- 1 - rel_index
;
1350 return (word
>> rel_index
) & 1;
1354 value_in (value_ptr element
, value_ptr set
)
1357 struct type
*settype
= check_typedef (VALUE_TYPE (set
));
1358 struct type
*eltype
= check_typedef (VALUE_TYPE (element
));
1359 if (TYPE_CODE (eltype
) == TYPE_CODE_RANGE
)
1360 eltype
= TYPE_TARGET_TYPE (eltype
);
1361 if (TYPE_CODE (settype
) != TYPE_CODE_SET
)
1362 error ("Second argument of 'IN' has wrong type");
1363 if (TYPE_CODE (eltype
) != TYPE_CODE_INT
1364 && TYPE_CODE (eltype
) != TYPE_CODE_CHAR
1365 && TYPE_CODE (eltype
) != TYPE_CODE_ENUM
1366 && TYPE_CODE (eltype
) != TYPE_CODE_BOOL
)
1367 error ("First argument of 'IN' has wrong type");
1368 member
= value_bit_index (settype
, VALUE_CONTENTS (set
),
1369 value_as_long (element
));
1371 error ("First argument of 'IN' not in range");
1372 return value_from_longest (LA_BOOL_TYPE
, member
);
1376 _initialize_valarith (void)