1 /* Perform arithmetic and other operations on values, for GDB.
3 Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009,
5 2010, 2011 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
29 #include "gdb_string.h"
34 #include "exceptions.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 void _initialize_valarith (void);
46 /* Given a pointer, return the size of its target.
47 If the pointer type is void *, then return 1.
48 If the target type is incomplete, then error out.
49 This isn't a general purpose function, but just a
50 helper for value_ptradd. */
53 find_size_for_pointer_math (struct type
*ptr_type
)
56 struct type
*ptr_target
;
58 gdb_assert (TYPE_CODE (ptr_type
) == TYPE_CODE_PTR
);
59 ptr_target
= check_typedef (TYPE_TARGET_TYPE (ptr_type
));
61 sz
= TYPE_LENGTH (ptr_target
);
64 if (TYPE_CODE (ptr_type
) == TYPE_CODE_VOID
)
70 name
= TYPE_NAME (ptr_target
);
72 name
= TYPE_TAG_NAME (ptr_target
);
74 error (_("Cannot perform pointer math on incomplete types, "
75 "try casting to a known type, or void *."));
77 error (_("Cannot perform pointer math on incomplete type \"%s\", "
78 "try casting to a known type, or void *."), name
);
84 /* Given a pointer ARG1 and an integral value ARG2, return the
85 result of C-style pointer arithmetic ARG1 + ARG2. */
88 value_ptradd (struct value
*arg1
, LONGEST arg2
)
90 struct type
*valptrtype
;
94 arg1
= coerce_array (arg1
);
95 valptrtype
= check_typedef (value_type (arg1
));
96 sz
= find_size_for_pointer_math (valptrtype
);
98 result
= value_from_pointer (valptrtype
,
99 value_as_address (arg1
) + sz
* arg2
);
100 if (VALUE_LVAL (result
) != lval_internalvar
)
101 set_value_component_location (result
, arg1
);
105 /* Given two compatible pointer values ARG1 and ARG2, return the
106 result of C-style pointer arithmetic ARG1 - ARG2. */
109 value_ptrdiff (struct value
*arg1
, struct value
*arg2
)
111 struct type
*type1
, *type2
;
114 arg1
= coerce_array (arg1
);
115 arg2
= coerce_array (arg2
);
116 type1
= check_typedef (value_type (arg1
));
117 type2
= check_typedef (value_type (arg2
));
119 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_PTR
);
120 gdb_assert (TYPE_CODE (type2
) == TYPE_CODE_PTR
);
122 if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)))
123 != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2
))))
124 error (_("First argument of `-' is a pointer and "
125 "second argument is neither\n"
126 "an integer nor a pointer of the same type."));
128 sz
= TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)));
131 warning (_("Type size unknown, assuming 1. "
132 "Try casting to a known type, or void *."));
136 return (value_as_long (arg1
) - value_as_long (arg2
)) / sz
;
139 /* Return the value of ARRAY[IDX].
141 ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING. If the
142 current language supports C-style arrays, it may also be TYPE_CODE_PTR.
143 To access TYPE_CODE_BITSTRING values, use value_bitstring_subscript.
145 See comments in value_coerce_array() for rationale for reason for
146 doing lower bounds adjustment here rather than there.
147 FIXME: Perhaps we should validate that the index is valid and if
148 verbosity is set, warn about invalid indices (but still use them). */
151 value_subscript (struct value
*array
, LONGEST index
)
153 int c_style
= current_language
->c_style_arrays
;
156 array
= coerce_ref (array
);
157 tarray
= check_typedef (value_type (array
));
159 if (TYPE_CODE (tarray
) == TYPE_CODE_ARRAY
160 || TYPE_CODE (tarray
) == TYPE_CODE_STRING
)
162 struct type
*range_type
= TYPE_INDEX_TYPE (tarray
);
163 LONGEST lowerbound
, upperbound
;
165 get_discrete_bounds (range_type
, &lowerbound
, &upperbound
);
166 if (VALUE_LVAL (array
) != lval_memory
)
167 return value_subscripted_rvalue (array
, index
, lowerbound
);
171 if (index
>= lowerbound
&& index
<= upperbound
)
172 return value_subscripted_rvalue (array
, index
, lowerbound
);
173 /* Emit warning unless we have an array of unknown size.
174 An array of unknown size has lowerbound 0 and upperbound -1. */
176 warning (_("array or string index out of range"));
177 /* fall doing C stuff */
182 array
= value_coerce_array (array
);
186 return value_ind (value_ptradd (array
, index
));
188 error (_("not an array or string"));
191 /* Return the value of EXPR[IDX], expr an aggregate rvalue
192 (eg, a vector register). This routine used to promote floats
193 to doubles, but no longer does. */
196 value_subscripted_rvalue (struct value
*array
, LONGEST index
, int lowerbound
)
198 struct type
*array_type
= check_typedef (value_type (array
));
199 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (array_type
));
200 unsigned int elt_size
= TYPE_LENGTH (elt_type
);
201 unsigned int elt_offs
= elt_size
* longest_to_int (index
- lowerbound
);
204 if (index
< lowerbound
|| (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type
)
205 && elt_offs
>= TYPE_LENGTH (array_type
)))
206 error (_("no such vector element"));
208 v
= allocate_value (elt_type
);
209 if (VALUE_LVAL (array
) == lval_memory
&& value_lazy (array
))
210 set_value_lazy (v
, 1);
212 memcpy (value_contents_writeable (v
),
213 value_contents (array
) + elt_offs
, elt_size
);
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
);
222 /* Return the value of BITSTRING[IDX] as (boolean) type TYPE. */
225 value_bitstring_subscript (struct type
*type
,
226 struct value
*bitstring
, LONGEST index
)
229 struct type
*bitstring_type
, *range_type
;
231 int offset
, byte
, bit_index
;
232 LONGEST lowerbound
, upperbound
;
234 bitstring_type
= check_typedef (value_type (bitstring
));
235 gdb_assert (TYPE_CODE (bitstring_type
) == TYPE_CODE_BITSTRING
);
237 range_type
= TYPE_INDEX_TYPE (bitstring_type
);
238 get_discrete_bounds (range_type
, &lowerbound
, &upperbound
);
239 if (index
< lowerbound
|| index
> upperbound
)
240 error (_("bitstring index out of range"));
243 offset
= index
/ TARGET_CHAR_BIT
;
244 byte
= *((char *) value_contents (bitstring
) + offset
);
246 bit_index
= index
% TARGET_CHAR_BIT
;
247 byte
>>= (gdbarch_bits_big_endian (get_type_arch (bitstring_type
)) ?
248 TARGET_CHAR_BIT
- 1 - bit_index
: bit_index
);
250 v
= value_from_longest (type
, byte
& 1);
252 set_value_bitpos (v
, bit_index
);
253 set_value_bitsize (v
, 1);
254 set_value_component_location (v
, bitstring
);
255 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (bitstring
);
257 set_value_offset (v
, offset
+ value_offset (bitstring
));
263 /* Check to see if either argument is a structure, or a reference to
264 one. This is called so we know whether to go ahead with the normal
265 binop or look for a user defined function instead.
267 For now, we do not overload the `=' operator. */
270 binop_types_user_defined_p (enum exp_opcode op
,
271 struct type
*type1
, struct type
*type2
)
273 if (op
== BINOP_ASSIGN
|| op
== BINOP_CONCAT
)
276 type1
= check_typedef (type1
);
277 if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
278 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
280 type2
= check_typedef (type1
);
281 if (TYPE_CODE (type2
) == TYPE_CODE_REF
)
282 type2
= check_typedef (TYPE_TARGET_TYPE (type2
));
284 return (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
285 || TYPE_CODE (type2
) == TYPE_CODE_STRUCT
);
288 /* Check to see if either argument is a structure, or a reference to
289 one. This is called so we know whether to go ahead with the normal
290 binop or look for a user defined function instead.
292 For now, we do not overload the `=' operator. */
295 binop_user_defined_p (enum exp_opcode op
,
296 struct value
*arg1
, struct value
*arg2
)
298 return binop_types_user_defined_p (op
, value_type (arg1
), value_type (arg2
));
301 /* Check to see if argument is a structure. This is called so
302 we know whether to go ahead with the normal unop or look for a
303 user defined function instead.
305 For now, we do not overload the `&' operator. */
308 unop_user_defined_p (enum exp_opcode op
, struct value
*arg1
)
314 type1
= check_typedef (value_type (arg1
));
317 if (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
)
319 else if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
320 type1
= TYPE_TARGET_TYPE (type1
);
326 /* Try to find an operator named OPERATOR which takes NARGS arguments
327 specified in ARGS. If the operator found is a static member operator
328 *STATIC_MEMFUNP will be set to 1, and otherwise 0.
329 The search if performed through find_overload_match which will handle
330 member operators, non member operators, operators imported implicitly or
331 explicitly, and perform correct overload resolution in all of the above
332 situations or combinations thereof. */
334 static struct value
*
335 value_user_defined_cpp_op (struct value
**args
, int nargs
, char *operator,
336 int *static_memfuncp
)
339 struct symbol
*symp
= NULL
;
340 struct value
*valp
= NULL
;
341 struct type
**arg_types
;
344 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
345 /* Prepare list of argument types for overload resolution. */
346 for (i
= 0; i
< nargs
; i
++)
347 arg_types
[i
] = value_type (args
[i
]);
349 find_overload_match (arg_types
, nargs
, operator, BOTH
/* could be method */,
350 0 /* strict match */, &args
[0], /* objp */
351 NULL
/* pass NULL symbol since symbol is unknown */,
352 &valp
, &symp
, static_memfuncp
, 0);
359 /* This is a non member function and does not
360 expect a reference as its first argument
361 rather the explicit structure. */
362 args
[0] = value_ind (args
[0]);
363 return value_of_variable (symp
, 0);
366 error (_("Could not find %s."), operator);
369 /* Lookup user defined operator NAME. Return a value representing the
370 function, otherwise return NULL. */
372 static struct value
*
373 value_user_defined_op (struct value
**argp
, struct value
**args
, char *name
,
374 int *static_memfuncp
, int nargs
)
376 struct value
*result
= NULL
;
378 if (current_language
->la_language
== language_cplus
)
379 result
= value_user_defined_cpp_op (args
, nargs
, name
, static_memfuncp
);
381 result
= value_struct_elt (argp
, args
, name
, static_memfuncp
,
387 /* We know either arg1 or arg2 is a structure, so try to find the right
388 user defined function. Create an argument vector that calls
389 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
390 binary operator which is legal for GNU C++).
392 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
393 is the opcode saying how to modify it. Otherwise, OTHEROP is
397 value_x_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
,
398 enum exp_opcode otherop
, enum noside noside
)
400 struct value
**argvec
;
405 arg1
= coerce_ref (arg1
);
406 arg2
= coerce_ref (arg2
);
408 /* now we know that what we have to do is construct our
409 arg vector and find the right function to call it with. */
411 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
412 error (_("Can't do that binary op on that type")); /* FIXME be explicit */
414 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
415 argvec
[1] = value_addr (arg1
);
419 /* Make the right function name up. */
420 strcpy (tstr
, "operator__");
445 case BINOP_BITWISE_AND
:
448 case BINOP_BITWISE_IOR
:
451 case BINOP_BITWISE_XOR
:
454 case BINOP_LOGICAL_AND
:
457 case BINOP_LOGICAL_OR
:
469 case BINOP_ASSIGN_MODIFY
:
487 case BINOP_BITWISE_AND
:
490 case BINOP_BITWISE_IOR
:
493 case BINOP_BITWISE_XOR
:
496 case BINOP_MOD
: /* invalid */
498 error (_("Invalid binary operation specified."));
501 case BINOP_SUBSCRIPT
:
522 case BINOP_MOD
: /* invalid */
524 error (_("Invalid binary operation specified."));
527 argvec
[0] = value_user_defined_op (&arg1
, argvec
+ 1, tstr
,
528 &static_memfuncp
, 2);
534 argvec
[1] = argvec
[0];
537 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
539 struct type
*return_type
;
542 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
543 return value_zero (return_type
, VALUE_LVAL (arg1
));
545 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
,
548 throw_error (NOT_FOUND_ERROR
,
549 _("member function %s not found"), tstr
);
551 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
555 /* We know that arg1 is a structure, so try to find a unary user
556 defined operator that matches the operator in question.
557 Create an argument vector that calls arg1.operator @ (arg1)
558 and return that value (where '@' is (almost) any unary operator which
559 is legal for GNU C++). */
562 value_x_unop (struct value
*arg1
, enum exp_opcode op
, enum noside noside
)
564 struct gdbarch
*gdbarch
= get_type_arch (value_type (arg1
));
565 struct value
**argvec
;
566 char *ptr
, *mangle_ptr
;
567 char tstr
[13], mangle_tstr
[13];
568 int static_memfuncp
, nargs
;
570 arg1
= coerce_ref (arg1
);
572 /* now we know that what we have to do is construct our
573 arg vector and find the right function to call it with. */
575 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
576 error (_("Can't do that unary op on that type")); /* FIXME be explicit */
578 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
579 argvec
[1] = value_addr (arg1
);
584 /* Make the right function name up. */
585 strcpy (tstr
, "operator__");
587 strcpy (mangle_tstr
, "__");
588 mangle_ptr
= mangle_tstr
+ 2;
591 case UNOP_PREINCREMENT
:
594 case UNOP_PREDECREMENT
:
597 case UNOP_POSTINCREMENT
:
599 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
603 case UNOP_POSTDECREMENT
:
605 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
609 case UNOP_LOGICAL_NOT
:
612 case UNOP_COMPLEMENT
:
628 error (_("Invalid unary operation specified."));
631 argvec
[0] = value_user_defined_op (&arg1
, argvec
+ 1, tstr
,
632 &static_memfuncp
, nargs
);
638 argvec
[1] = argvec
[0];
642 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
644 struct type
*return_type
;
647 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
648 return value_zero (return_type
, VALUE_LVAL (arg1
));
650 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
652 throw_error (NOT_FOUND_ERROR
,
653 _("member function %s not found"), tstr
);
655 return 0; /* For lint -- never reached */
659 /* Concatenate two values with the following conditions:
661 (1) Both values must be either bitstring values or character string
662 values and the resulting value consists of the concatenation of
663 ARG1 followed by ARG2.
667 One value must be an integer value and the other value must be
668 either a bitstring value or character string value, which is
669 to be repeated by the number of times specified by the integer
673 (2) Boolean values are also allowed and are treated as bit string
676 (3) Character values are also allowed and are treated as character
677 string values of length 1. */
680 value_concat (struct value
*arg1
, struct value
*arg2
)
682 struct value
*inval1
;
683 struct value
*inval2
;
684 struct value
*outval
= NULL
;
685 int inval1len
, inval2len
;
689 struct type
*type1
= check_typedef (value_type (arg1
));
690 struct type
*type2
= check_typedef (value_type (arg2
));
691 struct type
*char_type
;
693 /* First figure out if we are dealing with two values to be concatenated
694 or a repeat count and a value to be repeated. INVAL1 is set to the
695 first of two concatenated values, or the repeat count. INVAL2 is set
696 to the second of the two concatenated values or the value to be
699 if (TYPE_CODE (type2
) == TYPE_CODE_INT
)
701 struct type
*tmp
= type1
;
714 /* Now process the input values. */
716 if (TYPE_CODE (type1
) == TYPE_CODE_INT
)
718 /* We have a repeat count. Validate the second value and then
719 construct a value repeated that many times. */
720 if (TYPE_CODE (type2
) == TYPE_CODE_STRING
721 || TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
723 count
= longest_to_int (value_as_long (inval1
));
724 inval2len
= TYPE_LENGTH (type2
);
725 ptr
= (char *) alloca (count
* inval2len
);
726 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
730 inchar
= (char) unpack_long (type2
,
731 value_contents (inval2
));
732 for (idx
= 0; idx
< count
; idx
++)
734 *(ptr
+ idx
) = inchar
;
739 char_type
= TYPE_TARGET_TYPE (type2
);
741 for (idx
= 0; idx
< count
; idx
++)
743 memcpy (ptr
+ (idx
* inval2len
), value_contents (inval2
),
747 outval
= value_string (ptr
, count
* inval2len
, char_type
);
749 else if (TYPE_CODE (type2
) == TYPE_CODE_BITSTRING
750 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
752 error (_("unimplemented support for bitstring/boolean repeats"));
756 error (_("can't repeat values of that type"));
759 else if (TYPE_CODE (type1
) == TYPE_CODE_STRING
760 || TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
762 /* We have two character strings to concatenate. */
763 if (TYPE_CODE (type2
) != TYPE_CODE_STRING
764 && TYPE_CODE (type2
) != TYPE_CODE_CHAR
)
766 error (_("Strings can only be concatenated with other strings."));
768 inval1len
= TYPE_LENGTH (type1
);
769 inval2len
= TYPE_LENGTH (type2
);
770 ptr
= (char *) alloca (inval1len
+ inval2len
);
771 if (TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
775 *ptr
= (char) unpack_long (type1
, value_contents (inval1
));
779 char_type
= TYPE_TARGET_TYPE (type1
);
781 memcpy (ptr
, value_contents (inval1
), inval1len
);
783 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
786 (char) unpack_long (type2
, value_contents (inval2
));
790 memcpy (ptr
+ inval1len
, value_contents (inval2
), inval2len
);
792 outval
= value_string (ptr
, inval1len
+ inval2len
, char_type
);
794 else if (TYPE_CODE (type1
) == TYPE_CODE_BITSTRING
795 || TYPE_CODE (type1
) == TYPE_CODE_BOOL
)
797 /* We have two bitstrings to concatenate. */
798 if (TYPE_CODE (type2
) != TYPE_CODE_BITSTRING
799 && TYPE_CODE (type2
) != TYPE_CODE_BOOL
)
801 error (_("Bitstrings or booleans can only be concatenated "
802 "with other bitstrings or booleans."));
804 error (_("unimplemented support for bitstring/boolean concatenation."));
808 /* We don't know how to concatenate these operands. */
809 error (_("illegal operands for concatenation."));
814 /* Integer exponentiation: V1**V2, where both arguments are
815 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
818 integer_pow (LONGEST v1
, LONGEST v2
)
823 error (_("Attempt to raise 0 to negative power."));
829 /* The Russian Peasant's Algorithm. */
845 /* Integer exponentiation: V1**V2, where both arguments are
846 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
849 uinteger_pow (ULONGEST v1
, LONGEST v2
)
854 error (_("Attempt to raise 0 to negative power."));
860 /* The Russian Peasant's Algorithm. */
876 /* Obtain decimal value of arguments for binary operation, converting from
877 other types if one of them is not decimal floating point. */
879 value_args_as_decimal (struct value
*arg1
, struct value
*arg2
,
880 gdb_byte
*x
, int *len_x
, enum bfd_endian
*byte_order_x
,
881 gdb_byte
*y
, int *len_y
, enum bfd_endian
*byte_order_y
)
883 struct type
*type1
, *type2
;
885 type1
= check_typedef (value_type (arg1
));
886 type2
= check_typedef (value_type (arg2
));
888 /* At least one of the arguments must be of decimal float type. */
889 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
890 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
);
892 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
893 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
894 /* The DFP extension to the C language does not allow mixing of
895 * decimal float types with other float types in expressions
896 * (see WDTR 24732, page 12). */
897 error (_("Mixing decimal floating types with "
898 "other floating types is not allowed."));
900 /* Obtain decimal value of arg1, converting from other types
903 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
905 *byte_order_x
= gdbarch_byte_order (get_type_arch (type1
));
906 *len_x
= TYPE_LENGTH (type1
);
907 memcpy (x
, value_contents (arg1
), *len_x
);
909 else if (is_integral_type (type1
))
911 *byte_order_x
= gdbarch_byte_order (get_type_arch (type2
));
912 *len_x
= TYPE_LENGTH (type2
);
913 decimal_from_integral (arg1
, x
, *len_x
, *byte_order_x
);
916 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
919 /* Obtain decimal value of arg2, converting from other types
922 if (TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
924 *byte_order_y
= gdbarch_byte_order (get_type_arch (type2
));
925 *len_y
= TYPE_LENGTH (type2
);
926 memcpy (y
, value_contents (arg2
), *len_y
);
928 else if (is_integral_type (type2
))
930 *byte_order_y
= gdbarch_byte_order (get_type_arch (type1
));
931 *len_y
= TYPE_LENGTH (type1
);
932 decimal_from_integral (arg2
, y
, *len_y
, *byte_order_y
);
935 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
939 /* Perform a binary operation on two operands which have reasonable
940 representations as integers or floats. This includes booleans,
941 characters, integers, or floats.
942 Does not support addition and subtraction on pointers;
943 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
945 static struct value
*
946 scalar_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
949 struct type
*type1
, *type2
, *result_type
;
951 arg1
= coerce_ref (arg1
);
952 arg2
= coerce_ref (arg2
);
954 type1
= check_typedef (value_type (arg1
));
955 type2
= check_typedef (value_type (arg2
));
957 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
958 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
959 && !is_integral_type (type1
))
960 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
961 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
962 && !is_integral_type (type2
)))
963 error (_("Argument to arithmetic operation not a number or boolean."));
965 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
966 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
968 int len_v1
, len_v2
, len_v
;
969 enum bfd_endian byte_order_v1
, byte_order_v2
, byte_order_v
;
970 gdb_byte v1
[16], v2
[16];
973 /* If only one type is decimal float, use its type.
974 Otherwise use the bigger type. */
975 if (TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
)
977 else if (TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
)
979 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
984 len_v
= TYPE_LENGTH (result_type
);
985 byte_order_v
= gdbarch_byte_order (get_type_arch (result_type
));
987 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
988 v2
, &len_v2
, &byte_order_v2
);
997 decimal_binop (op
, v1
, len_v1
, byte_order_v1
,
998 v2
, len_v2
, byte_order_v2
,
999 v
, len_v
, byte_order_v
);
1003 error (_("Operation not valid for decimal floating point number."));
1006 val
= value_from_decfloat (result_type
, v
);
1008 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
1009 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
1011 /* FIXME-if-picky-about-floating-accuracy: Should be doing this
1012 in target format. real.c in GCC probably has the necessary
1014 DOUBLEST v1
, v2
, v
= 0;
1016 v1
= value_as_double (arg1
);
1017 v2
= value_as_double (arg2
);
1041 error (_("Cannot perform exponentiation: %s"),
1042 safe_strerror (errno
));
1046 v
= v1
< v2
? v1
: v2
;
1050 v
= v1
> v2
? v1
: v2
;
1054 error (_("Integer-only operation on floating point number."));
1057 /* If only one type is float, use its type.
1058 Otherwise use the bigger type. */
1059 if (TYPE_CODE (type1
) != TYPE_CODE_FLT
)
1060 result_type
= type2
;
1061 else if (TYPE_CODE (type2
) != TYPE_CODE_FLT
)
1062 result_type
= type1
;
1063 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1064 result_type
= type2
;
1066 result_type
= type1
;
1068 val
= allocate_value (result_type
);
1069 store_typed_floating (value_contents_raw (val
), value_type (val
), v
);
1071 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
1072 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
1074 LONGEST v1
, v2
, v
= 0;
1076 v1
= value_as_long (arg1
);
1077 v2
= value_as_long (arg2
);
1081 case BINOP_BITWISE_AND
:
1085 case BINOP_BITWISE_IOR
:
1089 case BINOP_BITWISE_XOR
:
1097 case BINOP_NOTEQUAL
:
1102 error (_("Invalid operation on booleans."));
1105 result_type
= type1
;
1107 val
= allocate_value (result_type
);
1108 store_signed_integer (value_contents_raw (val
),
1109 TYPE_LENGTH (result_type
),
1110 gdbarch_byte_order (get_type_arch (result_type
)),
1114 /* Integral operations here. */
1116 /* Determine type length of the result, and if the operation should
1117 be done unsigned. For exponentiation and shift operators,
1118 use the length and type of the left operand. Otherwise,
1119 use the signedness of the operand with the greater length.
1120 If both operands are of equal length, use unsigned operation
1121 if one of the operands is unsigned. */
1122 if (op
== BINOP_RSH
|| op
== BINOP_LSH
|| op
== BINOP_EXP
)
1123 result_type
= type1
;
1124 else if (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
))
1125 result_type
= type1
;
1126 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1127 result_type
= type2
;
1128 else if (TYPE_UNSIGNED (type1
))
1129 result_type
= type1
;
1130 else if (TYPE_UNSIGNED (type2
))
1131 result_type
= type2
;
1133 result_type
= type1
;
1135 if (TYPE_UNSIGNED (result_type
))
1137 LONGEST v2_signed
= value_as_long (arg2
);
1138 ULONGEST v1
, v2
, v
= 0;
1140 v1
= (ULONGEST
) value_as_long (arg1
);
1141 v2
= (ULONGEST
) v2_signed
;
1162 error (_("Division by zero"));
1166 v
= uinteger_pow (v1
, v2_signed
);
1173 error (_("Division by zero"));
1177 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1178 v1 mod 0 has a defined value, v1. */
1186 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1199 case BINOP_BITWISE_AND
:
1203 case BINOP_BITWISE_IOR
:
1207 case BINOP_BITWISE_XOR
:
1211 case BINOP_LOGICAL_AND
:
1215 case BINOP_LOGICAL_OR
:
1220 v
= v1
< v2
? v1
: v2
;
1224 v
= v1
> v2
? v1
: v2
;
1231 case BINOP_NOTEQUAL
:
1252 error (_("Invalid binary operation on numbers."));
1255 val
= allocate_value (result_type
);
1256 store_unsigned_integer (value_contents_raw (val
),
1257 TYPE_LENGTH (value_type (val
)),
1259 (get_type_arch (result_type
)),
1264 LONGEST v1
, v2
, v
= 0;
1266 v1
= value_as_long (arg1
);
1267 v2
= value_as_long (arg2
);
1288 error (_("Division by zero"));
1292 v
= integer_pow (v1
, v2
);
1299 error (_("Division by zero"));
1303 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1304 X mod 0 has a defined value, X. */
1312 /* Compute floor. */
1313 if (TRUNCATION_TOWARDS_ZERO
&& (v
< 0) && ((v1
% v2
) != 0))
1329 case BINOP_BITWISE_AND
:
1333 case BINOP_BITWISE_IOR
:
1337 case BINOP_BITWISE_XOR
:
1341 case BINOP_LOGICAL_AND
:
1345 case BINOP_LOGICAL_OR
:
1350 v
= v1
< v2
? v1
: v2
;
1354 v
= v1
> v2
? v1
: v2
;
1361 case BINOP_NOTEQUAL
:
1382 error (_("Invalid binary operation on numbers."));
1385 val
= allocate_value (result_type
);
1386 store_signed_integer (value_contents_raw (val
),
1387 TYPE_LENGTH (value_type (val
)),
1389 (get_type_arch (result_type
)),
1397 /* Performs a binary operation on two vector operands by calling scalar_binop
1398 for each pair of vector components. */
1400 static struct value
*
1401 vector_binop (struct value
*val1
, struct value
*val2
, enum exp_opcode op
)
1403 struct value
*val
, *tmp
, *mark
;
1404 struct type
*type1
, *type2
, *eltype1
, *eltype2
, *result_type
;
1405 int t1_is_vec
, t2_is_vec
, elsize
, i
;
1406 LONGEST low_bound1
, high_bound1
, low_bound2
, high_bound2
;
1408 type1
= check_typedef (value_type (val1
));
1409 type2
= check_typedef (value_type (val2
));
1411 t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
1412 && TYPE_VECTOR (type1
)) ? 1 : 0;
1413 t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
1414 && TYPE_VECTOR (type2
)) ? 1 : 0;
1416 if (!t1_is_vec
|| !t2_is_vec
)
1417 error (_("Vector operations are only supported among vectors"));
1419 if (!get_array_bounds (type1
, &low_bound1
, &high_bound1
)
1420 || !get_array_bounds (type2
, &low_bound2
, &high_bound2
))
1421 error (_("Could not determine the vector bounds"));
1423 eltype1
= check_typedef (TYPE_TARGET_TYPE (type1
));
1424 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
));
1425 elsize
= TYPE_LENGTH (eltype1
);
1427 if (TYPE_CODE (eltype1
) != TYPE_CODE (eltype2
)
1428 || elsize
!= TYPE_LENGTH (eltype2
)
1429 || TYPE_UNSIGNED (eltype1
) != TYPE_UNSIGNED (eltype2
)
1430 || low_bound1
!= low_bound2
|| high_bound1
!= high_bound2
)
1431 error (_("Cannot perform operation on vectors with different types"));
1433 val
= allocate_value (type1
);
1434 mark
= value_mark ();
1435 for (i
= 0; i
< high_bound1
- low_bound1
+ 1; i
++)
1437 tmp
= value_binop (value_subscript (val1
, i
),
1438 value_subscript (val2
, i
), op
);
1439 memcpy (value_contents_writeable (val
) + i
* elsize
,
1440 value_contents_all (tmp
),
1443 value_free_to_mark (mark
);
1448 /* Perform a binary operation on two operands. */
1451 value_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
1454 struct type
*type1
= check_typedef (value_type (arg1
));
1455 struct type
*type2
= check_typedef (value_type (arg2
));
1456 int t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
1457 && TYPE_VECTOR (type1
));
1458 int t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
1459 && TYPE_VECTOR (type2
));
1461 if (!t1_is_vec
&& !t2_is_vec
)
1462 val
= scalar_binop (arg1
, arg2
, op
);
1463 else if (t1_is_vec
&& t2_is_vec
)
1464 val
= vector_binop (arg1
, arg2
, op
);
1467 /* Widen the scalar operand to a vector. */
1468 struct value
**v
= t1_is_vec
? &arg2
: &arg1
;
1469 struct type
*t
= t1_is_vec
? type2
: type1
;
1471 if (TYPE_CODE (t
) != TYPE_CODE_FLT
1472 && TYPE_CODE (t
) != TYPE_CODE_DECFLOAT
1473 && !is_integral_type (t
))
1474 error (_("Argument to operation not a number or boolean."));
1476 *v
= value_cast (t1_is_vec
? type1
: type2
, *v
);
1477 val
= vector_binop (arg1
, arg2
, op
);
1483 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1486 value_logical_not (struct value
*arg1
)
1492 arg1
= coerce_array (arg1
);
1493 type1
= check_typedef (value_type (arg1
));
1495 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
)
1496 return 0 == value_as_double (arg1
);
1497 else if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
1498 return decimal_is_zero (value_contents (arg1
), TYPE_LENGTH (type1
),
1499 gdbarch_byte_order (get_type_arch (type1
)));
1501 len
= TYPE_LENGTH (type1
);
1502 p
= value_contents (arg1
);
1513 /* Perform a comparison on two string values (whose content are not
1514 necessarily null terminated) based on their length. */
1517 value_strcmp (struct value
*arg1
, struct value
*arg2
)
1519 int len1
= TYPE_LENGTH (value_type (arg1
));
1520 int len2
= TYPE_LENGTH (value_type (arg2
));
1521 const gdb_byte
*s1
= value_contents (arg1
);
1522 const gdb_byte
*s2
= value_contents (arg2
);
1523 int i
, len
= len1
< len2
? len1
: len2
;
1525 for (i
= 0; i
< len
; i
++)
1529 else if (s1
[i
] > s2
[i
])
1537 else if (len1
> len2
)
1543 /* Simulate the C operator == by returning a 1
1544 iff ARG1 and ARG2 have equal contents. */
1547 value_equal (struct value
*arg1
, struct value
*arg2
)
1552 struct type
*type1
, *type2
;
1553 enum type_code code1
;
1554 enum type_code code2
;
1555 int is_int1
, is_int2
;
1557 arg1
= coerce_array (arg1
);
1558 arg2
= coerce_array (arg2
);
1560 type1
= check_typedef (value_type (arg1
));
1561 type2
= check_typedef (value_type (arg2
));
1562 code1
= TYPE_CODE (type1
);
1563 code2
= TYPE_CODE (type2
);
1564 is_int1
= is_integral_type (type1
);
1565 is_int2
= is_integral_type (type2
);
1567 if (is_int1
&& is_int2
)
1568 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1570 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1571 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1573 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1574 `long double' values are returned in static storage (m68k). */
1575 DOUBLEST d
= value_as_double (arg1
);
1577 return d
== value_as_double (arg2
);
1579 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1580 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1582 gdb_byte v1
[16], v2
[16];
1584 enum bfd_endian byte_order_v1
, byte_order_v2
;
1586 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
1587 v2
, &len_v2
, &byte_order_v2
);
1589 return decimal_compare (v1
, len_v1
, byte_order_v1
,
1590 v2
, len_v2
, byte_order_v2
) == 0;
1593 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1595 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1596 return value_as_address (arg1
) == (CORE_ADDR
) value_as_long (arg2
);
1597 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1598 return (CORE_ADDR
) value_as_long (arg1
) == value_as_address (arg2
);
1600 else if (code1
== code2
1601 && ((len
= (int) TYPE_LENGTH (type1
))
1602 == (int) TYPE_LENGTH (type2
)))
1604 p1
= value_contents (arg1
);
1605 p2
= value_contents (arg2
);
1613 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1615 return value_strcmp (arg1
, arg2
) == 0;
1619 error (_("Invalid type combination in equality test."));
1620 return 0; /* For lint -- never reached. */
1624 /* Compare values based on their raw contents. Useful for arrays since
1625 value_equal coerces them to pointers, thus comparing just the address
1626 of the array instead of its contents. */
1629 value_equal_contents (struct value
*arg1
, struct value
*arg2
)
1631 struct type
*type1
, *type2
;
1633 type1
= check_typedef (value_type (arg1
));
1634 type2
= check_typedef (value_type (arg2
));
1636 return (TYPE_CODE (type1
) == TYPE_CODE (type2
)
1637 && TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
1638 && memcmp (value_contents (arg1
), value_contents (arg2
),
1639 TYPE_LENGTH (type1
)) == 0);
1642 /* Simulate the C operator < by returning 1
1643 iff ARG1's contents are less than ARG2's. */
1646 value_less (struct value
*arg1
, struct value
*arg2
)
1648 enum type_code code1
;
1649 enum type_code code2
;
1650 struct type
*type1
, *type2
;
1651 int is_int1
, is_int2
;
1653 arg1
= coerce_array (arg1
);
1654 arg2
= coerce_array (arg2
);
1656 type1
= check_typedef (value_type (arg1
));
1657 type2
= check_typedef (value_type (arg2
));
1658 code1
= TYPE_CODE (type1
);
1659 code2
= TYPE_CODE (type2
);
1660 is_int1
= is_integral_type (type1
);
1661 is_int2
= is_integral_type (type2
);
1663 if (is_int1
&& is_int2
)
1664 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1666 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1667 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1669 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1670 `long double' values are returned in static storage (m68k). */
1671 DOUBLEST d
= value_as_double (arg1
);
1673 return d
< value_as_double (arg2
);
1675 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1676 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1678 gdb_byte v1
[16], v2
[16];
1680 enum bfd_endian byte_order_v1
, byte_order_v2
;
1682 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
1683 v2
, &len_v2
, &byte_order_v2
);
1685 return decimal_compare (v1
, len_v1
, byte_order_v1
,
1686 v2
, len_v2
, byte_order_v2
) == -1;
1688 else if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
1689 return value_as_address (arg1
) < value_as_address (arg2
);
1691 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1693 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1694 return value_as_address (arg1
) < (CORE_ADDR
) value_as_long (arg2
);
1695 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1696 return (CORE_ADDR
) value_as_long (arg1
) < value_as_address (arg2
);
1697 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1698 return value_strcmp (arg1
, arg2
) < 0;
1701 error (_("Invalid type combination in ordering comparison."));
1706 /* The unary operators +, - and ~. They free the argument ARG1. */
1709 value_pos (struct value
*arg1
)
1713 arg1
= coerce_ref (arg1
);
1714 type
= check_typedef (value_type (arg1
));
1716 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1717 return value_from_double (type
, value_as_double (arg1
));
1718 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1719 return value_from_decfloat (type
, value_contents (arg1
));
1720 else if (is_integral_type (type
))
1722 return value_from_longest (type
, value_as_long (arg1
));
1724 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1726 struct value
*val
= allocate_value (type
);
1728 memcpy (value_contents_raw (val
), value_contents (arg1
),
1729 TYPE_LENGTH (type
));
1734 error (_("Argument to positive operation not a number."));
1735 return 0; /* For lint -- never reached. */
1740 value_neg (struct value
*arg1
)
1744 arg1
= coerce_ref (arg1
);
1745 type
= check_typedef (value_type (arg1
));
1747 if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1749 struct value
*val
= allocate_value (type
);
1750 int len
= TYPE_LENGTH (type
);
1751 gdb_byte decbytes
[16]; /* a decfloat is at most 128 bits long. */
1753 memcpy (decbytes
, value_contents (arg1
), len
);
1755 if (gdbarch_byte_order (get_type_arch (type
)) == BFD_ENDIAN_LITTLE
)
1756 decbytes
[len
-1] = decbytes
[len
- 1] | 0x80;
1758 decbytes
[0] = decbytes
[0] | 0x80;
1760 memcpy (value_contents_raw (val
), decbytes
, len
);
1763 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1764 return value_from_double (type
, -value_as_double (arg1
));
1765 else if (is_integral_type (type
))
1767 return value_from_longest (type
, -value_as_long (arg1
));
1769 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1771 struct value
*tmp
, *val
= allocate_value (type
);
1772 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1774 LONGEST low_bound
, high_bound
;
1776 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1777 error (_("Could not determine the vector bounds"));
1779 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1781 tmp
= value_neg (value_subscript (arg1
, i
));
1782 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
1783 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
1789 error (_("Argument to negate operation not a number."));
1790 return 0; /* For lint -- never reached. */
1795 value_complement (struct value
*arg1
)
1800 arg1
= coerce_ref (arg1
);
1801 type
= check_typedef (value_type (arg1
));
1803 if (is_integral_type (type
))
1804 val
= value_from_longest (type
, ~value_as_long (arg1
));
1805 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1808 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1810 LONGEST low_bound
, high_bound
;
1812 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1813 error (_("Could not determine the vector bounds"));
1815 val
= allocate_value (type
);
1816 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1818 tmp
= value_complement (value_subscript (arg1
, i
));
1819 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
1820 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
1824 error (_("Argument to complement operation not an integer, boolean."));
1829 /* The INDEX'th bit of SET value whose value_type is TYPE,
1830 and whose value_contents is valaddr.
1831 Return -1 if out of range, -2 other error. */
1834 value_bit_index (struct type
*type
, const gdb_byte
*valaddr
, int index
)
1836 struct gdbarch
*gdbarch
= get_type_arch (type
);
1837 LONGEST low_bound
, high_bound
;
1840 struct type
*range
= TYPE_INDEX_TYPE (type
);
1842 if (get_discrete_bounds (range
, &low_bound
, &high_bound
) < 0)
1844 if (index
< low_bound
|| index
> high_bound
)
1846 rel_index
= index
- low_bound
;
1847 word
= extract_unsigned_integer (valaddr
+ (rel_index
/ TARGET_CHAR_BIT
), 1,
1848 gdbarch_byte_order (gdbarch
));
1849 rel_index
%= TARGET_CHAR_BIT
;
1850 if (gdbarch_bits_big_endian (gdbarch
))
1851 rel_index
= TARGET_CHAR_BIT
- 1 - rel_index
;
1852 return (word
>> rel_index
) & 1;
1856 value_in (struct value
*element
, struct value
*set
)
1859 struct type
*settype
= check_typedef (value_type (set
));
1860 struct type
*eltype
= check_typedef (value_type (element
));
1862 if (TYPE_CODE (eltype
) == TYPE_CODE_RANGE
)
1863 eltype
= TYPE_TARGET_TYPE (eltype
);
1864 if (TYPE_CODE (settype
) != TYPE_CODE_SET
)
1865 error (_("Second argument of 'IN' has wrong type"));
1866 if (TYPE_CODE (eltype
) != TYPE_CODE_INT
1867 && TYPE_CODE (eltype
) != TYPE_CODE_CHAR
1868 && TYPE_CODE (eltype
) != TYPE_CODE_ENUM
1869 && TYPE_CODE (eltype
) != TYPE_CODE_BOOL
)
1870 error (_("First argument of 'IN' has wrong type"));
1871 member
= value_bit_index (settype
, value_contents (set
),
1872 value_as_long (element
));
1874 error (_("First argument of 'IN' not in range"));
1879 _initialize_valarith (void)
This page took 0.069976 seconds and 5 git commands to generate.