1 /* Perform arithmetic and other operations on values, for GDB.
3 Copyright (C) 1986-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
32 #include "exceptions.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 void _initialize_valarith (void);
44 /* Given a pointer, return the size of its target.
45 If the pointer type is void *, then return 1.
46 If the target type is incomplete, then error out.
47 This isn't a general purpose function, but just a
48 helper for value_ptradd. */
51 find_size_for_pointer_math (struct type
*ptr_type
)
54 struct type
*ptr_target
;
56 gdb_assert (TYPE_CODE (ptr_type
) == TYPE_CODE_PTR
);
57 ptr_target
= check_typedef (TYPE_TARGET_TYPE (ptr_type
));
59 sz
= TYPE_LENGTH (ptr_target
);
62 if (TYPE_CODE (ptr_type
) == TYPE_CODE_VOID
)
68 name
= TYPE_NAME (ptr_target
);
70 name
= TYPE_TAG_NAME (ptr_target
);
72 error (_("Cannot perform pointer math on incomplete types, "
73 "try casting to a known type, or void *."));
75 error (_("Cannot perform pointer math on incomplete type \"%s\", "
76 "try casting to a known type, or void *."), name
);
82 /* Given a pointer ARG1 and an integral value ARG2, return the
83 result of C-style pointer arithmetic ARG1 + ARG2. */
86 value_ptradd (struct value
*arg1
, LONGEST arg2
)
88 struct type
*valptrtype
;
92 arg1
= coerce_array (arg1
);
93 valptrtype
= check_typedef (value_type (arg1
));
94 sz
= find_size_for_pointer_math (valptrtype
);
96 result
= value_from_pointer (valptrtype
,
97 value_as_address (arg1
) + sz
* arg2
);
98 if (VALUE_LVAL (result
) != lval_internalvar
)
99 set_value_component_location (result
, arg1
);
103 /* Given two compatible pointer values ARG1 and ARG2, return the
104 result of C-style pointer arithmetic ARG1 - ARG2. */
107 value_ptrdiff (struct value
*arg1
, struct value
*arg2
)
109 struct type
*type1
, *type2
;
112 arg1
= coerce_array (arg1
);
113 arg2
= coerce_array (arg2
);
114 type1
= check_typedef (value_type (arg1
));
115 type2
= check_typedef (value_type (arg2
));
117 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_PTR
);
118 gdb_assert (TYPE_CODE (type2
) == TYPE_CODE_PTR
);
120 if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)))
121 != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2
))))
122 error (_("First argument of `-' is a pointer and "
123 "second argument is neither\n"
124 "an integer nor a pointer of the same type."));
126 sz
= TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)));
129 warning (_("Type size unknown, assuming 1. "
130 "Try casting to a known type, or void *."));
134 return (value_as_long (arg1
) - value_as_long (arg2
)) / sz
;
137 /* Return the value of ARRAY[IDX].
139 ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING. If the
140 current language supports C-style arrays, it may also be TYPE_CODE_PTR.
142 See comments in value_coerce_array() for rationale for reason for
143 doing lower bounds adjustment here rather than there.
144 FIXME: Perhaps we should validate that the index is valid and if
145 verbosity is set, warn about invalid indices (but still use them). */
148 value_subscript (struct value
*array
, LONGEST index
)
150 int c_style
= current_language
->c_style_arrays
;
153 array
= coerce_ref (array
);
154 tarray
= check_typedef (value_type (array
));
156 if (TYPE_CODE (tarray
) == TYPE_CODE_ARRAY
157 || TYPE_CODE (tarray
) == TYPE_CODE_STRING
)
159 struct type
*range_type
= TYPE_INDEX_TYPE (tarray
);
160 LONGEST lowerbound
, upperbound
;
162 get_discrete_bounds (range_type
, &lowerbound
, &upperbound
);
163 if (VALUE_LVAL (array
) != lval_memory
)
164 return value_subscripted_rvalue (array
, index
, lowerbound
);
168 if (index
>= lowerbound
&& index
<= upperbound
)
169 return value_subscripted_rvalue (array
, index
, lowerbound
);
170 /* Emit warning unless we have an array of unknown size.
171 An array of unknown size has lowerbound 0 and upperbound -1. */
173 warning (_("array or string index out of range"));
174 /* fall doing C stuff */
179 array
= value_coerce_array (array
);
183 return value_ind (value_ptradd (array
, index
));
185 error (_("not an array or string"));
188 /* Return the value of EXPR[IDX], expr an aggregate rvalue
189 (eg, a vector register). This routine used to promote floats
190 to doubles, but no longer does. */
193 value_subscripted_rvalue (struct value
*array
, LONGEST index
, int lowerbound
)
195 struct type
*array_type
= check_typedef (value_type (array
));
196 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (array_type
));
197 unsigned int elt_size
= TYPE_LENGTH (elt_type
);
198 unsigned int elt_offs
= elt_size
* longest_to_int (index
- lowerbound
);
201 if (index
< lowerbound
|| (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type
)
202 && elt_offs
>= TYPE_LENGTH (array_type
)))
203 error (_("no such vector element"));
205 if (VALUE_LVAL (array
) == lval_memory
&& value_lazy (array
))
206 v
= allocate_value_lazy (elt_type
);
209 v
= allocate_value (elt_type
);
210 value_contents_copy (v
, value_embedded_offset (v
),
211 array
, value_embedded_offset (array
) + elt_offs
,
215 set_value_component_location (v
, array
);
216 VALUE_REGNUM (v
) = VALUE_REGNUM (array
);
217 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (array
);
218 set_value_offset (v
, value_offset (array
) + elt_offs
);
223 /* Check to see if either argument is a structure, or a reference to
224 one. This is called so we know whether to go ahead with the normal
225 binop or look for a user defined function instead.
227 For now, we do not overload the `=' operator. */
230 binop_types_user_defined_p (enum exp_opcode op
,
231 struct type
*type1
, struct type
*type2
)
233 if (op
== BINOP_ASSIGN
|| op
== BINOP_CONCAT
)
236 type1
= check_typedef (type1
);
237 if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
238 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
240 type2
= check_typedef (type2
);
241 if (TYPE_CODE (type2
) == TYPE_CODE_REF
)
242 type2
= check_typedef (TYPE_TARGET_TYPE (type2
));
244 return (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
245 || TYPE_CODE (type2
) == TYPE_CODE_STRUCT
);
248 /* Check to see if either argument is a structure, or a reference to
249 one. This is called so we know whether to go ahead with the normal
250 binop or look for a user defined function instead.
252 For now, we do not overload the `=' operator. */
255 binop_user_defined_p (enum exp_opcode op
,
256 struct value
*arg1
, struct value
*arg2
)
258 return binop_types_user_defined_p (op
, value_type (arg1
), value_type (arg2
));
261 /* Check to see if argument is a structure. This is called so
262 we know whether to go ahead with the normal unop or look for a
263 user defined function instead.
265 For now, we do not overload the `&' operator. */
268 unop_user_defined_p (enum exp_opcode op
, struct value
*arg1
)
274 type1
= check_typedef (value_type (arg1
));
275 if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
276 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
277 return TYPE_CODE (type1
) == TYPE_CODE_STRUCT
;
280 /* Try to find an operator named OPERATOR which takes NARGS arguments
281 specified in ARGS. If the operator found is a static member operator
282 *STATIC_MEMFUNP will be set to 1, and otherwise 0.
283 The search if performed through find_overload_match which will handle
284 member operators, non member operators, operators imported implicitly or
285 explicitly, and perform correct overload resolution in all of the above
286 situations or combinations thereof. */
288 static struct value
*
289 value_user_defined_cpp_op (struct value
**args
, int nargs
, char *operator,
290 int *static_memfuncp
)
293 struct symbol
*symp
= NULL
;
294 struct value
*valp
= NULL
;
296 find_overload_match (args
, nargs
, operator, BOTH
/* could be method */,
298 NULL
/* pass NULL symbol since symbol is unknown */,
299 &valp
, &symp
, static_memfuncp
, 0);
306 /* This is a non member function and does not
307 expect a reference as its first argument
308 rather the explicit structure. */
309 args
[0] = value_ind (args
[0]);
310 return value_of_variable (symp
, 0);
313 error (_("Could not find %s."), operator);
316 /* Lookup user defined operator NAME. Return a value representing the
317 function, otherwise return NULL. */
319 static struct value
*
320 value_user_defined_op (struct value
**argp
, struct value
**args
, char *name
,
321 int *static_memfuncp
, int nargs
)
323 struct value
*result
= NULL
;
325 if (current_language
->la_language
== language_cplus
)
326 result
= value_user_defined_cpp_op (args
, nargs
, name
, static_memfuncp
);
328 result
= value_struct_elt (argp
, args
, name
, static_memfuncp
,
334 /* We know either arg1 or arg2 is a structure, so try to find the right
335 user defined function. Create an argument vector that calls
336 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
337 binary operator which is legal for GNU C++).
339 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
340 is the opcode saying how to modify it. Otherwise, OTHEROP is
344 value_x_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
,
345 enum exp_opcode otherop
, enum noside noside
)
347 struct value
**argvec
;
352 arg1
= coerce_ref (arg1
);
353 arg2
= coerce_ref (arg2
);
355 /* now we know that what we have to do is construct our
356 arg vector and find the right function to call it with. */
358 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
359 error (_("Can't do that binary op on that type")); /* FIXME be explicit */
361 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
362 argvec
[1] = value_addr (arg1
);
366 /* Make the right function name up. */
367 strcpy (tstr
, "operator__");
392 case BINOP_BITWISE_AND
:
395 case BINOP_BITWISE_IOR
:
398 case BINOP_BITWISE_XOR
:
401 case BINOP_LOGICAL_AND
:
404 case BINOP_LOGICAL_OR
:
416 case BINOP_ASSIGN_MODIFY
:
434 case BINOP_BITWISE_AND
:
437 case BINOP_BITWISE_IOR
:
440 case BINOP_BITWISE_XOR
:
443 case BINOP_MOD
: /* invalid */
445 error (_("Invalid binary operation specified."));
448 case BINOP_SUBSCRIPT
:
469 case BINOP_MOD
: /* invalid */
471 error (_("Invalid binary operation specified."));
474 argvec
[0] = value_user_defined_op (&arg1
, argvec
+ 1, tstr
,
475 &static_memfuncp
, 2);
481 argvec
[1] = argvec
[0];
484 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
486 struct type
*return_type
;
489 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
490 return value_zero (return_type
, VALUE_LVAL (arg1
));
492 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
,
495 throw_error (NOT_FOUND_ERROR
,
496 _("member function %s not found"), tstr
);
498 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
502 /* We know that arg1 is a structure, so try to find a unary user
503 defined operator that matches the operator in question.
504 Create an argument vector that calls arg1.operator @ (arg1)
505 and return that value (where '@' is (almost) any unary operator which
506 is legal for GNU C++). */
509 value_x_unop (struct value
*arg1
, enum exp_opcode op
, enum noside noside
)
511 struct gdbarch
*gdbarch
= get_type_arch (value_type (arg1
));
512 struct value
**argvec
;
514 char tstr
[13], mangle_tstr
[13];
515 int static_memfuncp
, nargs
;
517 arg1
= coerce_ref (arg1
);
519 /* now we know that what we have to do is construct our
520 arg vector and find the right function to call it with. */
522 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
523 error (_("Can't do that unary op on that type")); /* FIXME be explicit */
525 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
526 argvec
[1] = value_addr (arg1
);
531 /* Make the right function name up. */
532 strcpy (tstr
, "operator__");
534 strcpy (mangle_tstr
, "__");
537 case UNOP_PREINCREMENT
:
540 case UNOP_PREDECREMENT
:
543 case UNOP_POSTINCREMENT
:
545 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
549 case UNOP_POSTDECREMENT
:
551 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
555 case UNOP_LOGICAL_NOT
:
558 case UNOP_COMPLEMENT
:
574 error (_("Invalid unary operation specified."));
577 argvec
[0] = value_user_defined_op (&arg1
, argvec
+ 1, tstr
,
578 &static_memfuncp
, nargs
);
584 argvec
[1] = argvec
[0];
588 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
590 struct type
*return_type
;
593 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
594 return value_zero (return_type
, VALUE_LVAL (arg1
));
596 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
598 throw_error (NOT_FOUND_ERROR
,
599 _("member function %s not found"), tstr
);
601 return 0; /* For lint -- never reached */
605 /* Concatenate two values with the following conditions:
607 (1) Both values must be either bitstring values or character string
608 values and the resulting value consists of the concatenation of
609 ARG1 followed by ARG2.
613 One value must be an integer value and the other value must be
614 either a bitstring value or character string value, which is
615 to be repeated by the number of times specified by the integer
619 (2) Boolean values are also allowed and are treated as bit string
622 (3) Character values are also allowed and are treated as character
623 string values of length 1. */
626 value_concat (struct value
*arg1
, struct value
*arg2
)
628 struct value
*inval1
;
629 struct value
*inval2
;
630 struct value
*outval
= NULL
;
631 int inval1len
, inval2len
;
635 struct type
*type1
= check_typedef (value_type (arg1
));
636 struct type
*type2
= check_typedef (value_type (arg2
));
637 struct type
*char_type
;
639 /* First figure out if we are dealing with two values to be concatenated
640 or a repeat count and a value to be repeated. INVAL1 is set to the
641 first of two concatenated values, or the repeat count. INVAL2 is set
642 to the second of the two concatenated values or the value to be
645 if (TYPE_CODE (type2
) == TYPE_CODE_INT
)
647 struct type
*tmp
= type1
;
660 /* Now process the input values. */
662 if (TYPE_CODE (type1
) == TYPE_CODE_INT
)
664 /* We have a repeat count. Validate the second value and then
665 construct a value repeated that many times. */
666 if (TYPE_CODE (type2
) == TYPE_CODE_STRING
667 || TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
669 struct cleanup
*back_to
;
671 count
= longest_to_int (value_as_long (inval1
));
672 inval2len
= TYPE_LENGTH (type2
);
673 ptr
= (char *) xmalloc (count
* inval2len
);
674 back_to
= make_cleanup (xfree
, ptr
);
675 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
679 inchar
= (char) unpack_long (type2
,
680 value_contents (inval2
));
681 for (idx
= 0; idx
< count
; idx
++)
683 *(ptr
+ idx
) = inchar
;
688 char_type
= TYPE_TARGET_TYPE (type2
);
690 for (idx
= 0; idx
< count
; idx
++)
692 memcpy (ptr
+ (idx
* inval2len
), value_contents (inval2
),
696 outval
= value_string (ptr
, count
* inval2len
, char_type
);
697 do_cleanups (back_to
);
699 else if (TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
701 error (_("unimplemented support for boolean repeats"));
705 error (_("can't repeat values of that type"));
708 else if (TYPE_CODE (type1
) == TYPE_CODE_STRING
709 || TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
711 struct cleanup
*back_to
;
713 /* We have two character strings to concatenate. */
714 if (TYPE_CODE (type2
) != TYPE_CODE_STRING
715 && TYPE_CODE (type2
) != TYPE_CODE_CHAR
)
717 error (_("Strings can only be concatenated with other strings."));
719 inval1len
= TYPE_LENGTH (type1
);
720 inval2len
= TYPE_LENGTH (type2
);
721 ptr
= (char *) xmalloc (inval1len
+ inval2len
);
722 back_to
= make_cleanup (xfree
, ptr
);
723 if (TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
727 *ptr
= (char) unpack_long (type1
, value_contents (inval1
));
731 char_type
= TYPE_TARGET_TYPE (type1
);
733 memcpy (ptr
, value_contents (inval1
), inval1len
);
735 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
738 (char) unpack_long (type2
, value_contents (inval2
));
742 memcpy (ptr
+ inval1len
, value_contents (inval2
), inval2len
);
744 outval
= value_string (ptr
, inval1len
+ inval2len
, char_type
);
745 do_cleanups (back_to
);
747 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
)
749 /* We have two bitstrings to concatenate. */
750 if (TYPE_CODE (type2
) != TYPE_CODE_BOOL
)
752 error (_("Booleans can only be concatenated "
753 "with other bitstrings or booleans."));
755 error (_("unimplemented support for boolean concatenation."));
759 /* We don't know how to concatenate these operands. */
760 error (_("illegal operands for concatenation."));
765 /* Integer exponentiation: V1**V2, where both arguments are
766 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
769 integer_pow (LONGEST v1
, LONGEST v2
)
774 error (_("Attempt to raise 0 to negative power."));
780 /* The Russian Peasant's Algorithm. */
796 /* Integer exponentiation: V1**V2, where both arguments are
797 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
800 uinteger_pow (ULONGEST v1
, LONGEST v2
)
805 error (_("Attempt to raise 0 to negative power."));
811 /* The Russian Peasant's Algorithm. */
827 /* Obtain decimal value of arguments for binary operation, converting from
828 other types if one of them is not decimal floating point. */
830 value_args_as_decimal (struct value
*arg1
, struct value
*arg2
,
831 gdb_byte
*x
, int *len_x
, enum bfd_endian
*byte_order_x
,
832 gdb_byte
*y
, int *len_y
, enum bfd_endian
*byte_order_y
)
834 struct type
*type1
, *type2
;
836 type1
= check_typedef (value_type (arg1
));
837 type2
= check_typedef (value_type (arg2
));
839 /* At least one of the arguments must be of decimal float type. */
840 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
841 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
);
843 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
844 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
845 /* The DFP extension to the C language does not allow mixing of
846 * decimal float types with other float types in expressions
847 * (see WDTR 24732, page 12). */
848 error (_("Mixing decimal floating types with "
849 "other floating types is not allowed."));
851 /* Obtain decimal value of arg1, converting from other types
854 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
856 *byte_order_x
= gdbarch_byte_order (get_type_arch (type1
));
857 *len_x
= TYPE_LENGTH (type1
);
858 memcpy (x
, value_contents (arg1
), *len_x
);
860 else if (is_integral_type (type1
))
862 *byte_order_x
= gdbarch_byte_order (get_type_arch (type2
));
863 *len_x
= TYPE_LENGTH (type2
);
864 decimal_from_integral (arg1
, x
, *len_x
, *byte_order_x
);
867 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
870 /* Obtain decimal value of arg2, converting from other types
873 if (TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
875 *byte_order_y
= gdbarch_byte_order (get_type_arch (type2
));
876 *len_y
= TYPE_LENGTH (type2
);
877 memcpy (y
, value_contents (arg2
), *len_y
);
879 else if (is_integral_type (type2
))
881 *byte_order_y
= gdbarch_byte_order (get_type_arch (type1
));
882 *len_y
= TYPE_LENGTH (type1
);
883 decimal_from_integral (arg2
, y
, *len_y
, *byte_order_y
);
886 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
890 /* Perform a binary operation on two operands which have reasonable
891 representations as integers or floats. This includes booleans,
892 characters, integers, or floats.
893 Does not support addition and subtraction on pointers;
894 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
896 static struct value
*
897 scalar_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
900 struct type
*type1
, *type2
, *result_type
;
902 arg1
= coerce_ref (arg1
);
903 arg2
= coerce_ref (arg2
);
905 type1
= check_typedef (value_type (arg1
));
906 type2
= check_typedef (value_type (arg2
));
908 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
909 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
910 && !is_integral_type (type1
))
911 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
912 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
913 && !is_integral_type (type2
)))
914 error (_("Argument to arithmetic operation not a number or boolean."));
916 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
917 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
919 int len_v1
, len_v2
, len_v
;
920 enum bfd_endian byte_order_v1
, byte_order_v2
, byte_order_v
;
921 gdb_byte v1
[16], v2
[16];
924 /* If only one type is decimal float, use its type.
925 Otherwise use the bigger type. */
926 if (TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
)
928 else if (TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
)
930 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
935 len_v
= TYPE_LENGTH (result_type
);
936 byte_order_v
= gdbarch_byte_order (get_type_arch (result_type
));
938 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
939 v2
, &len_v2
, &byte_order_v2
);
948 decimal_binop (op
, v1
, len_v1
, byte_order_v1
,
949 v2
, len_v2
, byte_order_v2
,
950 v
, len_v
, byte_order_v
);
954 error (_("Operation not valid for decimal floating point number."));
957 val
= value_from_decfloat (result_type
, v
);
959 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
960 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
962 /* FIXME-if-picky-about-floating-accuracy: Should be doing this
963 in target format. real.c in GCC probably has the necessary
965 DOUBLEST v1
, v2
, v
= 0;
967 v1
= value_as_double (arg1
);
968 v2
= value_as_double (arg2
);
992 error (_("Cannot perform exponentiation: %s"),
993 safe_strerror (errno
));
997 v
= v1
< v2
? v1
: v2
;
1001 v
= v1
> v2
? v1
: v2
;
1005 error (_("Integer-only operation on floating point number."));
1008 /* If only one type is float, use its type.
1009 Otherwise use the bigger type. */
1010 if (TYPE_CODE (type1
) != TYPE_CODE_FLT
)
1011 result_type
= type2
;
1012 else if (TYPE_CODE (type2
) != TYPE_CODE_FLT
)
1013 result_type
= type1
;
1014 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1015 result_type
= type2
;
1017 result_type
= type1
;
1019 val
= allocate_value (result_type
);
1020 store_typed_floating (value_contents_raw (val
), value_type (val
), v
);
1022 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
1023 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
1025 LONGEST v1
, v2
, v
= 0;
1027 v1
= value_as_long (arg1
);
1028 v2
= value_as_long (arg2
);
1032 case BINOP_BITWISE_AND
:
1036 case BINOP_BITWISE_IOR
:
1040 case BINOP_BITWISE_XOR
:
1048 case BINOP_NOTEQUAL
:
1053 error (_("Invalid operation on booleans."));
1056 result_type
= type1
;
1058 val
= allocate_value (result_type
);
1059 store_signed_integer (value_contents_raw (val
),
1060 TYPE_LENGTH (result_type
),
1061 gdbarch_byte_order (get_type_arch (result_type
)),
1065 /* Integral operations here. */
1067 /* Determine type length of the result, and if the operation should
1068 be done unsigned. For exponentiation and shift operators,
1069 use the length and type of the left operand. Otherwise,
1070 use the signedness of the operand with the greater length.
1071 If both operands are of equal length, use unsigned operation
1072 if one of the operands is unsigned. */
1073 if (op
== BINOP_RSH
|| op
== BINOP_LSH
|| op
== BINOP_EXP
)
1074 result_type
= type1
;
1075 else if (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
))
1076 result_type
= type1
;
1077 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1078 result_type
= type2
;
1079 else if (TYPE_UNSIGNED (type1
))
1080 result_type
= type1
;
1081 else if (TYPE_UNSIGNED (type2
))
1082 result_type
= type2
;
1084 result_type
= type1
;
1086 if (TYPE_UNSIGNED (result_type
))
1088 LONGEST v2_signed
= value_as_long (arg2
);
1089 ULONGEST v1
, v2
, v
= 0;
1091 v1
= (ULONGEST
) value_as_long (arg1
);
1092 v2
= (ULONGEST
) v2_signed
;
1113 error (_("Division by zero"));
1117 v
= uinteger_pow (v1
, v2_signed
);
1124 error (_("Division by zero"));
1128 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1129 v1 mod 0 has a defined value, v1. */
1137 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1150 case BINOP_BITWISE_AND
:
1154 case BINOP_BITWISE_IOR
:
1158 case BINOP_BITWISE_XOR
:
1162 case BINOP_LOGICAL_AND
:
1166 case BINOP_LOGICAL_OR
:
1171 v
= v1
< v2
? v1
: v2
;
1175 v
= v1
> v2
? v1
: v2
;
1182 case BINOP_NOTEQUAL
:
1203 error (_("Invalid binary operation on numbers."));
1206 val
= allocate_value (result_type
);
1207 store_unsigned_integer (value_contents_raw (val
),
1208 TYPE_LENGTH (value_type (val
)),
1210 (get_type_arch (result_type
)),
1215 LONGEST v1
, v2
, v
= 0;
1217 v1
= value_as_long (arg1
);
1218 v2
= value_as_long (arg2
);
1239 error (_("Division by zero"));
1243 v
= integer_pow (v1
, v2
);
1250 error (_("Division by zero"));
1254 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1255 X mod 0 has a defined value, X. */
1263 /* Compute floor. */
1264 if (TRUNCATION_TOWARDS_ZERO
&& (v
< 0) && ((v1
% v2
) != 0))
1280 case BINOP_BITWISE_AND
:
1284 case BINOP_BITWISE_IOR
:
1288 case BINOP_BITWISE_XOR
:
1292 case BINOP_LOGICAL_AND
:
1296 case BINOP_LOGICAL_OR
:
1301 v
= v1
< v2
? v1
: v2
;
1305 v
= v1
> v2
? v1
: v2
;
1312 case BINOP_NOTEQUAL
:
1333 error (_("Invalid binary operation on numbers."));
1336 val
= allocate_value (result_type
);
1337 store_signed_integer (value_contents_raw (val
),
1338 TYPE_LENGTH (value_type (val
)),
1340 (get_type_arch (result_type
)),
1348 /* Widen a scalar value SCALAR_VALUE to vector type VECTOR_TYPE by
1349 replicating SCALAR_VALUE for each element of the vector. Only scalar
1350 types that can be cast to the type of one element of the vector are
1351 acceptable. The newly created vector value is returned upon success,
1352 otherwise an error is thrown. */
1355 value_vector_widen (struct value
*scalar_value
, struct type
*vector_type
)
1357 /* Widen the scalar to a vector. */
1358 struct type
*eltype
, *scalar_type
;
1359 struct value
*val
, *elval
;
1360 LONGEST low_bound
, high_bound
;
1363 CHECK_TYPEDEF (vector_type
);
1365 gdb_assert (TYPE_CODE (vector_type
) == TYPE_CODE_ARRAY
1366 && TYPE_VECTOR (vector_type
));
1368 if (!get_array_bounds (vector_type
, &low_bound
, &high_bound
))
1369 error (_("Could not determine the vector bounds"));
1371 eltype
= check_typedef (TYPE_TARGET_TYPE (vector_type
));
1372 elval
= value_cast (eltype
, scalar_value
);
1374 scalar_type
= check_typedef (value_type (scalar_value
));
1376 /* If we reduced the length of the scalar then check we didn't loose any
1378 if (TYPE_LENGTH (eltype
) < TYPE_LENGTH (scalar_type
)
1379 && !value_equal (elval
, scalar_value
))
1380 error (_("conversion of scalar to vector involves truncation"));
1382 val
= allocate_value (vector_type
);
1383 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1384 /* Duplicate the contents of elval into the destination vector. */
1385 memcpy (value_contents_writeable (val
) + (i
* TYPE_LENGTH (eltype
)),
1386 value_contents_all (elval
), TYPE_LENGTH (eltype
));
1391 /* Performs a binary operation on two vector operands by calling scalar_binop
1392 for each pair of vector components. */
1394 static struct value
*
1395 vector_binop (struct value
*val1
, struct value
*val2
, enum exp_opcode op
)
1397 struct value
*val
, *tmp
, *mark
;
1398 struct type
*type1
, *type2
, *eltype1
, *eltype2
;
1399 int t1_is_vec
, t2_is_vec
, elsize
, i
;
1400 LONGEST low_bound1
, high_bound1
, low_bound2
, high_bound2
;
1402 type1
= check_typedef (value_type (val1
));
1403 type2
= check_typedef (value_type (val2
));
1405 t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
1406 && TYPE_VECTOR (type1
)) ? 1 : 0;
1407 t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
1408 && TYPE_VECTOR (type2
)) ? 1 : 0;
1410 if (!t1_is_vec
|| !t2_is_vec
)
1411 error (_("Vector operations are only supported among vectors"));
1413 if (!get_array_bounds (type1
, &low_bound1
, &high_bound1
)
1414 || !get_array_bounds (type2
, &low_bound2
, &high_bound2
))
1415 error (_("Could not determine the vector bounds"));
1417 eltype1
= check_typedef (TYPE_TARGET_TYPE (type1
));
1418 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
));
1419 elsize
= TYPE_LENGTH (eltype1
);
1421 if (TYPE_CODE (eltype1
) != TYPE_CODE (eltype2
)
1422 || elsize
!= TYPE_LENGTH (eltype2
)
1423 || TYPE_UNSIGNED (eltype1
) != TYPE_UNSIGNED (eltype2
)
1424 || low_bound1
!= low_bound2
|| high_bound1
!= high_bound2
)
1425 error (_("Cannot perform operation on vectors with different types"));
1427 val
= allocate_value (type1
);
1428 mark
= value_mark ();
1429 for (i
= 0; i
< high_bound1
- low_bound1
+ 1; i
++)
1431 tmp
= value_binop (value_subscript (val1
, i
),
1432 value_subscript (val2
, i
), op
);
1433 memcpy (value_contents_writeable (val
) + i
* elsize
,
1434 value_contents_all (tmp
),
1437 value_free_to_mark (mark
);
1442 /* Perform a binary operation on two operands. */
1445 value_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
1448 struct type
*type1
= check_typedef (value_type (arg1
));
1449 struct type
*type2
= check_typedef (value_type (arg2
));
1450 int t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
1451 && TYPE_VECTOR (type1
));
1452 int t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
1453 && TYPE_VECTOR (type2
));
1455 if (!t1_is_vec
&& !t2_is_vec
)
1456 val
= scalar_binop (arg1
, arg2
, op
);
1457 else if (t1_is_vec
&& t2_is_vec
)
1458 val
= vector_binop (arg1
, arg2
, op
);
1461 /* Widen the scalar operand to a vector. */
1462 struct value
**v
= t1_is_vec
? &arg2
: &arg1
;
1463 struct type
*t
= t1_is_vec
? type2
: type1
;
1465 if (TYPE_CODE (t
) != TYPE_CODE_FLT
1466 && TYPE_CODE (t
) != TYPE_CODE_DECFLOAT
1467 && !is_integral_type (t
))
1468 error (_("Argument to operation not a number or boolean."));
1470 /* Replicate the scalar value to make a vector value. */
1471 *v
= value_vector_widen (*v
, t1_is_vec
? type1
: type2
);
1473 val
= vector_binop (arg1
, arg2
, op
);
1479 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1482 value_logical_not (struct value
*arg1
)
1488 arg1
= coerce_array (arg1
);
1489 type1
= check_typedef (value_type (arg1
));
1491 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
)
1492 return 0 == value_as_double (arg1
);
1493 else if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
1494 return decimal_is_zero (value_contents (arg1
), TYPE_LENGTH (type1
),
1495 gdbarch_byte_order (get_type_arch (type1
)));
1497 len
= TYPE_LENGTH (type1
);
1498 p
= value_contents (arg1
);
1509 /* Perform a comparison on two string values (whose content are not
1510 necessarily null terminated) based on their length. */
1513 value_strcmp (struct value
*arg1
, struct value
*arg2
)
1515 int len1
= TYPE_LENGTH (value_type (arg1
));
1516 int len2
= TYPE_LENGTH (value_type (arg2
));
1517 const gdb_byte
*s1
= value_contents (arg1
);
1518 const gdb_byte
*s2
= value_contents (arg2
);
1519 int i
, len
= len1
< len2
? len1
: len2
;
1521 for (i
= 0; i
< len
; i
++)
1525 else if (s1
[i
] > s2
[i
])
1533 else if (len1
> len2
)
1539 /* Simulate the C operator == by returning a 1
1540 iff ARG1 and ARG2 have equal contents. */
1543 value_equal (struct value
*arg1
, struct value
*arg2
)
1548 struct type
*type1
, *type2
;
1549 enum type_code code1
;
1550 enum type_code code2
;
1551 int is_int1
, is_int2
;
1553 arg1
= coerce_array (arg1
);
1554 arg2
= coerce_array (arg2
);
1556 type1
= check_typedef (value_type (arg1
));
1557 type2
= check_typedef (value_type (arg2
));
1558 code1
= TYPE_CODE (type1
);
1559 code2
= TYPE_CODE (type2
);
1560 is_int1
= is_integral_type (type1
);
1561 is_int2
= is_integral_type (type2
);
1563 if (is_int1
&& is_int2
)
1564 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1566 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1567 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1569 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1570 `long double' values are returned in static storage (m68k). */
1571 DOUBLEST d
= value_as_double (arg1
);
1573 return d
== value_as_double (arg2
);
1575 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1576 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1578 gdb_byte v1
[16], v2
[16];
1580 enum bfd_endian byte_order_v1
, byte_order_v2
;
1582 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
1583 v2
, &len_v2
, &byte_order_v2
);
1585 return decimal_compare (v1
, len_v1
, byte_order_v1
,
1586 v2
, len_v2
, byte_order_v2
) == 0;
1589 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1591 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1592 return value_as_address (arg1
) == (CORE_ADDR
) value_as_long (arg2
);
1593 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1594 return (CORE_ADDR
) value_as_long (arg1
) == value_as_address (arg2
);
1596 else if (code1
== code2
1597 && ((len
= (int) TYPE_LENGTH (type1
))
1598 == (int) TYPE_LENGTH (type2
)))
1600 p1
= value_contents (arg1
);
1601 p2
= value_contents (arg2
);
1609 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1611 return value_strcmp (arg1
, arg2
) == 0;
1615 error (_("Invalid type combination in equality test."));
1616 return 0; /* For lint -- never reached. */
1620 /* Compare values based on their raw contents. Useful for arrays since
1621 value_equal coerces them to pointers, thus comparing just the address
1622 of the array instead of its contents. */
1625 value_equal_contents (struct value
*arg1
, struct value
*arg2
)
1627 struct type
*type1
, *type2
;
1629 type1
= check_typedef (value_type (arg1
));
1630 type2
= check_typedef (value_type (arg2
));
1632 return (TYPE_CODE (type1
) == TYPE_CODE (type2
)
1633 && TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
1634 && memcmp (value_contents (arg1
), value_contents (arg2
),
1635 TYPE_LENGTH (type1
)) == 0);
1638 /* Simulate the C operator < by returning 1
1639 iff ARG1's contents are less than ARG2's. */
1642 value_less (struct value
*arg1
, struct value
*arg2
)
1644 enum type_code code1
;
1645 enum type_code code2
;
1646 struct type
*type1
, *type2
;
1647 int is_int1
, is_int2
;
1649 arg1
= coerce_array (arg1
);
1650 arg2
= coerce_array (arg2
);
1652 type1
= check_typedef (value_type (arg1
));
1653 type2
= check_typedef (value_type (arg2
));
1654 code1
= TYPE_CODE (type1
);
1655 code2
= TYPE_CODE (type2
);
1656 is_int1
= is_integral_type (type1
);
1657 is_int2
= is_integral_type (type2
);
1659 if (is_int1
&& is_int2
)
1660 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1662 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1663 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1665 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1666 `long double' values are returned in static storage (m68k). */
1667 DOUBLEST d
= value_as_double (arg1
);
1669 return d
< value_as_double (arg2
);
1671 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1672 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1674 gdb_byte v1
[16], v2
[16];
1676 enum bfd_endian byte_order_v1
, byte_order_v2
;
1678 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
1679 v2
, &len_v2
, &byte_order_v2
);
1681 return decimal_compare (v1
, len_v1
, byte_order_v1
,
1682 v2
, len_v2
, byte_order_v2
) == -1;
1684 else if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
1685 return value_as_address (arg1
) < value_as_address (arg2
);
1687 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1689 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1690 return value_as_address (arg1
) < (CORE_ADDR
) value_as_long (arg2
);
1691 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1692 return (CORE_ADDR
) value_as_long (arg1
) < value_as_address (arg2
);
1693 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1694 return value_strcmp (arg1
, arg2
) < 0;
1697 error (_("Invalid type combination in ordering comparison."));
1702 /* The unary operators +, - and ~. They free the argument ARG1. */
1705 value_pos (struct value
*arg1
)
1709 arg1
= coerce_ref (arg1
);
1710 type
= check_typedef (value_type (arg1
));
1712 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1713 return value_from_double (type
, value_as_double (arg1
));
1714 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1715 return value_from_decfloat (type
, value_contents (arg1
));
1716 else if (is_integral_type (type
))
1718 return value_from_longest (type
, value_as_long (arg1
));
1720 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1722 struct value
*val
= allocate_value (type
);
1724 memcpy (value_contents_raw (val
), value_contents (arg1
),
1725 TYPE_LENGTH (type
));
1730 error (_("Argument to positive operation not a number."));
1731 return 0; /* For lint -- never reached. */
1736 value_neg (struct value
*arg1
)
1740 arg1
= coerce_ref (arg1
);
1741 type
= check_typedef (value_type (arg1
));
1743 if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1745 struct value
*val
= allocate_value (type
);
1746 int len
= TYPE_LENGTH (type
);
1747 gdb_byte decbytes
[16]; /* a decfloat is at most 128 bits long. */
1749 memcpy (decbytes
, value_contents (arg1
), len
);
1751 if (gdbarch_byte_order (get_type_arch (type
)) == BFD_ENDIAN_LITTLE
)
1752 decbytes
[len
-1] = decbytes
[len
- 1] | 0x80;
1754 decbytes
[0] = decbytes
[0] | 0x80;
1756 memcpy (value_contents_raw (val
), decbytes
, len
);
1759 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1760 return value_from_double (type
, -value_as_double (arg1
));
1761 else if (is_integral_type (type
))
1763 return value_from_longest (type
, -value_as_long (arg1
));
1765 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1767 struct value
*tmp
, *val
= allocate_value (type
);
1768 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1770 LONGEST low_bound
, high_bound
;
1772 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1773 error (_("Could not determine the vector bounds"));
1775 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1777 tmp
= value_neg (value_subscript (arg1
, i
));
1778 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
1779 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
1785 error (_("Argument to negate operation not a number."));
1786 return 0; /* For lint -- never reached. */
1791 value_complement (struct value
*arg1
)
1796 arg1
= coerce_ref (arg1
);
1797 type
= check_typedef (value_type (arg1
));
1799 if (is_integral_type (type
))
1800 val
= value_from_longest (type
, ~value_as_long (arg1
));
1801 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1804 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1806 LONGEST low_bound
, high_bound
;
1808 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1809 error (_("Could not determine the vector bounds"));
1811 val
= allocate_value (type
);
1812 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1814 tmp
= value_complement (value_subscript (arg1
, i
));
1815 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
1816 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
1820 error (_("Argument to complement operation not an integer, boolean."));
1825 /* The INDEX'th bit of SET value whose value_type is TYPE,
1826 and whose value_contents is valaddr.
1827 Return -1 if out of range, -2 other error. */
1830 value_bit_index (struct type
*type
, const gdb_byte
*valaddr
, int index
)
1832 struct gdbarch
*gdbarch
= get_type_arch (type
);
1833 LONGEST low_bound
, high_bound
;
1836 struct type
*range
= TYPE_INDEX_TYPE (type
);
1838 if (get_discrete_bounds (range
, &low_bound
, &high_bound
) < 0)
1840 if (index
< low_bound
|| index
> high_bound
)
1842 rel_index
= index
- low_bound
;
1843 word
= extract_unsigned_integer (valaddr
+ (rel_index
/ TARGET_CHAR_BIT
), 1,
1844 gdbarch_byte_order (gdbarch
));
1845 rel_index
%= TARGET_CHAR_BIT
;
1846 if (gdbarch_bits_big_endian (gdbarch
))
1847 rel_index
= TARGET_CHAR_BIT
- 1 - rel_index
;
1848 return (word
>> rel_index
) & 1;
1852 value_in (struct value
*element
, struct value
*set
)
1855 struct type
*settype
= check_typedef (value_type (set
));
1856 struct type
*eltype
= check_typedef (value_type (element
));
1858 if (TYPE_CODE (eltype
) == TYPE_CODE_RANGE
)
1859 eltype
= TYPE_TARGET_TYPE (eltype
);
1860 if (TYPE_CODE (settype
) != TYPE_CODE_SET
)
1861 error (_("Second argument of 'IN' has wrong type"));
1862 if (TYPE_CODE (eltype
) != TYPE_CODE_INT
1863 && TYPE_CODE (eltype
) != TYPE_CODE_CHAR
1864 && TYPE_CODE (eltype
) != TYPE_CODE_ENUM
1865 && TYPE_CODE (eltype
) != TYPE_CODE_BOOL
)
1866 error (_("First argument of 'IN' has wrong type"));
1867 member
= value_bit_index (settype
, value_contents (set
),
1868 value_as_long (element
));
1870 error (_("First argument of 'IN' not in range"));
1875 _initialize_valarith (void)
This page took 0.067111 seconds and 4 git commands to generate.