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"
31 #include "exceptions.h"
33 /* Define whether or not the C operator '/' truncates towards zero for
34 differently signed operands (truncation direction is undefined in C). */
36 #ifndef TRUNCATION_TOWARDS_ZERO
37 #define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
40 void _initialize_valarith (void);
43 /* Given a pointer, return the size of its target.
44 If the pointer type is void *, then return 1.
45 If the target type is incomplete, then error out.
46 This isn't a general purpose function, but just a
47 helper for value_ptradd. */
50 find_size_for_pointer_math (struct type
*ptr_type
)
53 struct type
*ptr_target
;
55 gdb_assert (TYPE_CODE (ptr_type
) == TYPE_CODE_PTR
);
56 ptr_target
= check_typedef (TYPE_TARGET_TYPE (ptr_type
));
58 sz
= TYPE_LENGTH (ptr_target
);
61 if (TYPE_CODE (ptr_type
) == TYPE_CODE_VOID
)
67 name
= TYPE_NAME (ptr_target
);
69 name
= TYPE_TAG_NAME (ptr_target
);
71 error (_("Cannot perform pointer math on incomplete types, "
72 "try casting to a known type, or void *."));
74 error (_("Cannot perform pointer math on incomplete type \"%s\", "
75 "try casting to a known type, or void *."), name
);
81 /* Given a pointer ARG1 and an integral value ARG2, return the
82 result of C-style pointer arithmetic ARG1 + ARG2. */
85 value_ptradd (struct value
*arg1
, LONGEST arg2
)
87 struct type
*valptrtype
;
91 arg1
= coerce_array (arg1
);
92 valptrtype
= check_typedef (value_type (arg1
));
93 sz
= find_size_for_pointer_math (valptrtype
);
95 result
= value_from_pointer (valptrtype
,
96 value_as_address (arg1
) + sz
* arg2
);
97 if (VALUE_LVAL (result
) != lval_internalvar
)
98 set_value_component_location (result
, arg1
);
102 /* Given two compatible pointer values ARG1 and ARG2, return the
103 result of C-style pointer arithmetic ARG1 - ARG2. */
106 value_ptrdiff (struct value
*arg1
, struct value
*arg2
)
108 struct type
*type1
, *type2
;
111 arg1
= coerce_array (arg1
);
112 arg2
= coerce_array (arg2
);
113 type1
= check_typedef (value_type (arg1
));
114 type2
= check_typedef (value_type (arg2
));
116 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_PTR
);
117 gdb_assert (TYPE_CODE (type2
) == TYPE_CODE_PTR
);
119 if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)))
120 != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2
))))
121 error (_("First argument of `-' is a pointer and "
122 "second argument is neither\n"
123 "an integer nor a pointer of the same type."));
125 sz
= TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1
)));
128 warning (_("Type size unknown, assuming 1. "
129 "Try casting to a known type, or void *."));
133 return (value_as_long (arg1
) - value_as_long (arg2
)) / sz
;
136 /* Return the value of ARRAY[IDX].
138 ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING. If the
139 current language supports C-style arrays, it may also be TYPE_CODE_PTR.
141 See comments in value_coerce_array() for rationale for reason for
142 doing lower bounds adjustment here rather than there.
143 FIXME: Perhaps we should validate that the index is valid and if
144 verbosity is set, warn about invalid indices (but still use them). */
147 value_subscript (struct value
*array
, LONGEST index
)
149 int c_style
= current_language
->c_style_arrays
;
152 array
= coerce_ref (array
);
153 tarray
= check_typedef (value_type (array
));
155 if (TYPE_CODE (tarray
) == TYPE_CODE_ARRAY
156 || TYPE_CODE (tarray
) == TYPE_CODE_STRING
)
158 struct type
*range_type
= TYPE_INDEX_TYPE (tarray
);
159 LONGEST lowerbound
, upperbound
;
161 get_discrete_bounds (range_type
, &lowerbound
, &upperbound
);
162 if (VALUE_LVAL (array
) != lval_memory
)
163 return value_subscripted_rvalue (array
, index
, lowerbound
);
167 if (index
>= lowerbound
&& index
<= upperbound
)
168 return value_subscripted_rvalue (array
, index
, lowerbound
);
169 /* Emit warning unless we have an array of unknown size.
170 An array of unknown size has lowerbound 0 and upperbound -1. */
172 warning (_("array or string index out of range"));
173 /* fall doing C stuff */
178 array
= value_coerce_array (array
);
182 return value_ind (value_ptradd (array
, index
));
184 error (_("not an array or string"));
187 /* Return the value of EXPR[IDX], expr an aggregate rvalue
188 (eg, a vector register). This routine used to promote floats
189 to doubles, but no longer does. */
192 value_subscripted_rvalue (struct value
*array
, LONGEST index
, int lowerbound
)
194 struct type
*array_type
= check_typedef (value_type (array
));
195 struct type
*elt_type
= check_typedef (TYPE_TARGET_TYPE (array_type
));
196 unsigned int elt_size
= TYPE_LENGTH (elt_type
);
197 unsigned int elt_offs
= elt_size
* longest_to_int (index
- lowerbound
);
200 if (index
< lowerbound
|| (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type
)
201 && elt_offs
>= TYPE_LENGTH (array_type
)))
202 error (_("no such vector element"));
204 if (VALUE_LVAL (array
) == lval_memory
&& value_lazy (array
))
205 v
= allocate_value_lazy (elt_type
);
208 v
= allocate_value (elt_type
);
209 value_contents_copy (v
, value_embedded_offset (v
),
210 array
, value_embedded_offset (array
) + elt_offs
,
214 set_value_component_location (v
, array
);
215 VALUE_REGNUM (v
) = VALUE_REGNUM (array
);
216 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (array
);
217 set_value_offset (v
, value_offset (array
) + elt_offs
);
222 /* Check to see if either argument is a structure, or a reference to
223 one. This is called so we know whether to go ahead with the normal
224 binop or look for a user defined function instead.
226 For now, we do not overload the `=' operator. */
229 binop_types_user_defined_p (enum exp_opcode op
,
230 struct type
*type1
, struct type
*type2
)
232 if (op
== BINOP_ASSIGN
|| op
== BINOP_CONCAT
)
235 type1
= check_typedef (type1
);
236 if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
237 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
239 type2
= check_typedef (type2
);
240 if (TYPE_CODE (type2
) == TYPE_CODE_REF
)
241 type2
= check_typedef (TYPE_TARGET_TYPE (type2
));
243 return (TYPE_CODE (type1
) == TYPE_CODE_STRUCT
244 || TYPE_CODE (type2
) == TYPE_CODE_STRUCT
);
247 /* Check to see if either argument is a structure, or a reference to
248 one. This is called so we know whether to go ahead with the normal
249 binop or look for a user defined function instead.
251 For now, we do not overload the `=' operator. */
254 binop_user_defined_p (enum exp_opcode op
,
255 struct value
*arg1
, struct value
*arg2
)
257 return binop_types_user_defined_p (op
, value_type (arg1
), value_type (arg2
));
260 /* Check to see if argument is a structure. This is called so
261 we know whether to go ahead with the normal unop or look for a
262 user defined function instead.
264 For now, we do not overload the `&' operator. */
267 unop_user_defined_p (enum exp_opcode op
, struct value
*arg1
)
273 type1
= check_typedef (value_type (arg1
));
274 if (TYPE_CODE (type1
) == TYPE_CODE_REF
)
275 type1
= check_typedef (TYPE_TARGET_TYPE (type1
));
276 return TYPE_CODE (type1
) == TYPE_CODE_STRUCT
;
279 /* Try to find an operator named OPERATOR which takes NARGS arguments
280 specified in ARGS. If the operator found is a static member operator
281 *STATIC_MEMFUNP will be set to 1, and otherwise 0.
282 The search if performed through find_overload_match which will handle
283 member operators, non member operators, operators imported implicitly or
284 explicitly, and perform correct overload resolution in all of the above
285 situations or combinations thereof. */
287 static struct value
*
288 value_user_defined_cpp_op (struct value
**args
, int nargs
, char *operator,
289 int *static_memfuncp
, enum noside noside
)
292 struct symbol
*symp
= NULL
;
293 struct value
*valp
= NULL
;
295 find_overload_match (args
, nargs
, operator, BOTH
/* could be method */,
297 NULL
/* pass NULL symbol since symbol is unknown */,
298 &valp
, &symp
, static_memfuncp
, 0, noside
);
305 /* This is a non member function and does not
306 expect a reference as its first argument
307 rather the explicit structure. */
308 args
[0] = value_ind (args
[0]);
309 return value_of_variable (symp
, 0);
312 error (_("Could not find %s."), operator);
315 /* Lookup user defined operator NAME. Return a value representing the
316 function, otherwise return NULL. */
318 static struct value
*
319 value_user_defined_op (struct value
**argp
, struct value
**args
, char *name
,
320 int *static_memfuncp
, int nargs
, enum noside noside
)
322 struct value
*result
= NULL
;
324 if (current_language
->la_language
== language_cplus
)
326 result
= value_user_defined_cpp_op (args
, nargs
, name
, static_memfuncp
,
330 result
= value_struct_elt (argp
, args
, name
, static_memfuncp
,
336 /* We know either arg1 or arg2 is a structure, so try to find the right
337 user defined function. Create an argument vector that calls
338 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
339 binary operator which is legal for GNU C++).
341 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
342 is the opcode saying how to modify it. Otherwise, OTHEROP is
346 value_x_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
,
347 enum exp_opcode otherop
, enum noside noside
)
349 struct value
**argvec
;
354 arg1
= coerce_ref (arg1
);
355 arg2
= coerce_ref (arg2
);
357 /* now we know that what we have to do is construct our
358 arg vector and find the right function to call it with. */
360 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
361 error (_("Can't do that binary op on that type")); /* FIXME be explicit */
363 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
364 argvec
[1] = value_addr (arg1
);
368 /* Make the right function name up. */
369 strcpy (tstr
, "operator__");
394 case BINOP_BITWISE_AND
:
397 case BINOP_BITWISE_IOR
:
400 case BINOP_BITWISE_XOR
:
403 case BINOP_LOGICAL_AND
:
406 case BINOP_LOGICAL_OR
:
418 case BINOP_ASSIGN_MODIFY
:
436 case BINOP_BITWISE_AND
:
439 case BINOP_BITWISE_IOR
:
442 case BINOP_BITWISE_XOR
:
445 case BINOP_MOD
: /* invalid */
447 error (_("Invalid binary operation specified."));
450 case BINOP_SUBSCRIPT
:
471 case BINOP_MOD
: /* invalid */
473 error (_("Invalid binary operation specified."));
476 argvec
[0] = value_user_defined_op (&arg1
, argvec
+ 1, tstr
,
477 &static_memfuncp
, 2, noside
);
483 argvec
[1] = argvec
[0];
486 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
488 struct type
*return_type
;
491 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
492 return value_zero (return_type
, VALUE_LVAL (arg1
));
495 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_XMETHOD
)
497 /* Static xmethods are not supported yet. */
498 gdb_assert (static_memfuncp
== 0);
499 return call_xmethod (argvec
[0], 2, argvec
+ 1);
502 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
,
505 throw_error (NOT_FOUND_ERROR
,
506 _("member function %s not found"), tstr
);
508 return call_function_by_hand (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
512 /* We know that arg1 is a structure, so try to find a unary user
513 defined operator that matches the operator in question.
514 Create an argument vector that calls arg1.operator @ (arg1)
515 and return that value (where '@' is (almost) any unary operator which
516 is legal for GNU C++). */
519 value_x_unop (struct value
*arg1
, enum exp_opcode op
, enum noside noside
)
521 struct gdbarch
*gdbarch
= get_type_arch (value_type (arg1
));
522 struct value
**argvec
;
524 char tstr
[13], mangle_tstr
[13];
525 int static_memfuncp
, nargs
;
527 arg1
= coerce_ref (arg1
);
529 /* now we know that what we have to do is construct our
530 arg vector and find the right function to call it with. */
532 if (TYPE_CODE (check_typedef (value_type (arg1
))) != TYPE_CODE_STRUCT
)
533 error (_("Can't do that unary op on that type")); /* FIXME be explicit */
535 argvec
= (struct value
**) alloca (sizeof (struct value
*) * 4);
536 argvec
[1] = value_addr (arg1
);
541 /* Make the right function name up. */
542 strcpy (tstr
, "operator__");
544 strcpy (mangle_tstr
, "__");
547 case UNOP_PREINCREMENT
:
550 case UNOP_PREDECREMENT
:
553 case UNOP_POSTINCREMENT
:
555 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
559 case UNOP_POSTDECREMENT
:
561 argvec
[2] = value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
565 case UNOP_LOGICAL_NOT
:
568 case UNOP_COMPLEMENT
:
584 error (_("Invalid unary operation specified."));
587 argvec
[0] = value_user_defined_op (&arg1
, argvec
+ 1, tstr
,
588 &static_memfuncp
, nargs
, noside
);
594 argvec
[1] = argvec
[0];
598 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
600 struct type
*return_type
;
603 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec
[0])));
604 return value_zero (return_type
, VALUE_LVAL (arg1
));
606 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_XMETHOD
)
608 /* Static xmethods are not supported yet. */
609 gdb_assert (static_memfuncp
== 0);
610 return call_xmethod (argvec
[0], 1, argvec
+ 1);
613 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
615 throw_error (NOT_FOUND_ERROR
,
616 _("member function %s not found"), tstr
);
618 return 0; /* For lint -- never reached */
622 /* Concatenate two values with the following conditions:
624 (1) Both values must be either bitstring values or character string
625 values and the resulting value consists of the concatenation of
626 ARG1 followed by ARG2.
630 One value must be an integer value and the other value must be
631 either a bitstring value or character string value, which is
632 to be repeated by the number of times specified by the integer
636 (2) Boolean values are also allowed and are treated as bit string
639 (3) Character values are also allowed and are treated as character
640 string values of length 1. */
643 value_concat (struct value
*arg1
, struct value
*arg2
)
645 struct value
*inval1
;
646 struct value
*inval2
;
647 struct value
*outval
= NULL
;
648 int inval1len
, inval2len
;
652 struct type
*type1
= check_typedef (value_type (arg1
));
653 struct type
*type2
= check_typedef (value_type (arg2
));
654 struct type
*char_type
;
656 /* First figure out if we are dealing with two values to be concatenated
657 or a repeat count and a value to be repeated. INVAL1 is set to the
658 first of two concatenated values, or the repeat count. INVAL2 is set
659 to the second of the two concatenated values or the value to be
662 if (TYPE_CODE (type2
) == TYPE_CODE_INT
)
664 struct type
*tmp
= type1
;
677 /* Now process the input values. */
679 if (TYPE_CODE (type1
) == TYPE_CODE_INT
)
681 /* We have a repeat count. Validate the second value and then
682 construct a value repeated that many times. */
683 if (TYPE_CODE (type2
) == TYPE_CODE_STRING
684 || TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
686 struct cleanup
*back_to
;
688 count
= longest_to_int (value_as_long (inval1
));
689 inval2len
= TYPE_LENGTH (type2
);
690 ptr
= (char *) xmalloc (count
* inval2len
);
691 back_to
= make_cleanup (xfree
, ptr
);
692 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
696 inchar
= (char) unpack_long (type2
,
697 value_contents (inval2
));
698 for (idx
= 0; idx
< count
; idx
++)
700 *(ptr
+ idx
) = inchar
;
705 char_type
= TYPE_TARGET_TYPE (type2
);
707 for (idx
= 0; idx
< count
; idx
++)
709 memcpy (ptr
+ (idx
* inval2len
), value_contents (inval2
),
713 outval
= value_string (ptr
, count
* inval2len
, char_type
);
714 do_cleanups (back_to
);
716 else if (TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
718 error (_("unimplemented support for boolean repeats"));
722 error (_("can't repeat values of that type"));
725 else if (TYPE_CODE (type1
) == TYPE_CODE_STRING
726 || TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
728 struct cleanup
*back_to
;
730 /* We have two character strings to concatenate. */
731 if (TYPE_CODE (type2
) != TYPE_CODE_STRING
732 && TYPE_CODE (type2
) != TYPE_CODE_CHAR
)
734 error (_("Strings can only be concatenated with other strings."));
736 inval1len
= TYPE_LENGTH (type1
);
737 inval2len
= TYPE_LENGTH (type2
);
738 ptr
= (char *) xmalloc (inval1len
+ inval2len
);
739 back_to
= make_cleanup (xfree
, ptr
);
740 if (TYPE_CODE (type1
) == TYPE_CODE_CHAR
)
744 *ptr
= (char) unpack_long (type1
, value_contents (inval1
));
748 char_type
= TYPE_TARGET_TYPE (type1
);
750 memcpy (ptr
, value_contents (inval1
), inval1len
);
752 if (TYPE_CODE (type2
) == TYPE_CODE_CHAR
)
755 (char) unpack_long (type2
, value_contents (inval2
));
759 memcpy (ptr
+ inval1len
, value_contents (inval2
), inval2len
);
761 outval
= value_string (ptr
, inval1len
+ inval2len
, char_type
);
762 do_cleanups (back_to
);
764 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
)
766 /* We have two bitstrings to concatenate. */
767 if (TYPE_CODE (type2
) != TYPE_CODE_BOOL
)
769 error (_("Booleans can only be concatenated "
770 "with other bitstrings or booleans."));
772 error (_("unimplemented support for boolean concatenation."));
776 /* We don't know how to concatenate these operands. */
777 error (_("illegal operands for concatenation."));
782 /* Integer exponentiation: V1**V2, where both arguments are
783 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
786 integer_pow (LONGEST v1
, LONGEST v2
)
791 error (_("Attempt to raise 0 to negative power."));
797 /* The Russian Peasant's Algorithm. */
813 /* Integer exponentiation: V1**V2, where both arguments are
814 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
817 uinteger_pow (ULONGEST v1
, LONGEST v2
)
822 error (_("Attempt to raise 0 to negative power."));
828 /* The Russian Peasant's Algorithm. */
844 /* Obtain decimal value of arguments for binary operation, converting from
845 other types if one of them is not decimal floating point. */
847 value_args_as_decimal (struct value
*arg1
, struct value
*arg2
,
848 gdb_byte
*x
, int *len_x
, enum bfd_endian
*byte_order_x
,
849 gdb_byte
*y
, int *len_y
, enum bfd_endian
*byte_order_y
)
851 struct type
*type1
, *type2
;
853 type1
= check_typedef (value_type (arg1
));
854 type2
= check_typedef (value_type (arg2
));
856 /* At least one of the arguments must be of decimal float type. */
857 gdb_assert (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
858 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
);
860 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
861 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
862 /* The DFP extension to the C language does not allow mixing of
863 * decimal float types with other float types in expressions
864 * (see WDTR 24732, page 12). */
865 error (_("Mixing decimal floating types with "
866 "other floating types is not allowed."));
868 /* Obtain decimal value of arg1, converting from other types
871 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
873 *byte_order_x
= gdbarch_byte_order (get_type_arch (type1
));
874 *len_x
= TYPE_LENGTH (type1
);
875 memcpy (x
, value_contents (arg1
), *len_x
);
877 else if (is_integral_type (type1
))
879 *byte_order_x
= gdbarch_byte_order (get_type_arch (type2
));
880 *len_x
= TYPE_LENGTH (type2
);
881 decimal_from_integral (arg1
, x
, *len_x
, *byte_order_x
);
884 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
887 /* Obtain decimal value of arg2, converting from other types
890 if (TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
892 *byte_order_y
= gdbarch_byte_order (get_type_arch (type2
));
893 *len_y
= TYPE_LENGTH (type2
);
894 memcpy (y
, value_contents (arg2
), *len_y
);
896 else if (is_integral_type (type2
))
898 *byte_order_y
= gdbarch_byte_order (get_type_arch (type1
));
899 *len_y
= TYPE_LENGTH (type1
);
900 decimal_from_integral (arg2
, y
, *len_y
, *byte_order_y
);
903 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1
),
907 /* Perform a binary operation on two operands which have reasonable
908 representations as integers or floats. This includes booleans,
909 characters, integers, or floats.
910 Does not support addition and subtraction on pointers;
911 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
913 static struct value
*
914 scalar_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
917 struct type
*type1
, *type2
, *result_type
;
919 arg1
= coerce_ref (arg1
);
920 arg2
= coerce_ref (arg2
);
922 type1
= check_typedef (value_type (arg1
));
923 type2
= check_typedef (value_type (arg2
));
925 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
926 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
927 && !is_integral_type (type1
))
928 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
929 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
930 && !is_integral_type (type2
)))
931 error (_("Argument to arithmetic operation not a number or boolean."));
933 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
934 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
936 int len_v1
, len_v2
, len_v
;
937 enum bfd_endian byte_order_v1
, byte_order_v2
, byte_order_v
;
938 gdb_byte v1
[16], v2
[16];
941 /* If only one type is decimal float, use its type.
942 Otherwise use the bigger type. */
943 if (TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
)
945 else if (TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
)
947 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
952 len_v
= TYPE_LENGTH (result_type
);
953 byte_order_v
= gdbarch_byte_order (get_type_arch (result_type
));
955 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
956 v2
, &len_v2
, &byte_order_v2
);
965 decimal_binop (op
, v1
, len_v1
, byte_order_v1
,
966 v2
, len_v2
, byte_order_v2
,
967 v
, len_v
, byte_order_v
);
971 error (_("Operation not valid for decimal floating point number."));
974 val
= value_from_decfloat (result_type
, v
);
976 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
977 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
979 /* FIXME-if-picky-about-floating-accuracy: Should be doing this
980 in target format. real.c in GCC probably has the necessary
982 DOUBLEST v1
, v2
, v
= 0;
984 v1
= value_as_double (arg1
);
985 v2
= value_as_double (arg2
);
1009 error (_("Cannot perform exponentiation: %s"),
1010 safe_strerror (errno
));
1014 v
= v1
< v2
? v1
: v2
;
1018 v
= v1
> v2
? v1
: v2
;
1022 error (_("Integer-only operation on floating point number."));
1025 /* If only one type is float, use its type.
1026 Otherwise use the bigger type. */
1027 if (TYPE_CODE (type1
) != TYPE_CODE_FLT
)
1028 result_type
= type2
;
1029 else if (TYPE_CODE (type2
) != TYPE_CODE_FLT
)
1030 result_type
= type1
;
1031 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1032 result_type
= type2
;
1034 result_type
= type1
;
1036 val
= allocate_value (result_type
);
1037 store_typed_floating (value_contents_raw (val
), value_type (val
), v
);
1039 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
1040 || TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
1042 LONGEST v1
, v2
, v
= 0;
1044 v1
= value_as_long (arg1
);
1045 v2
= value_as_long (arg2
);
1049 case BINOP_BITWISE_AND
:
1053 case BINOP_BITWISE_IOR
:
1057 case BINOP_BITWISE_XOR
:
1065 case BINOP_NOTEQUAL
:
1070 error (_("Invalid operation on booleans."));
1073 result_type
= type1
;
1075 val
= allocate_value (result_type
);
1076 store_signed_integer (value_contents_raw (val
),
1077 TYPE_LENGTH (result_type
),
1078 gdbarch_byte_order (get_type_arch (result_type
)),
1082 /* Integral operations here. */
1084 /* Determine type length of the result, and if the operation should
1085 be done unsigned. For exponentiation and shift operators,
1086 use the length and type of the left operand. Otherwise,
1087 use the signedness of the operand with the greater length.
1088 If both operands are of equal length, use unsigned operation
1089 if one of the operands is unsigned. */
1090 if (op
== BINOP_RSH
|| op
== BINOP_LSH
|| op
== BINOP_EXP
)
1091 result_type
= type1
;
1092 else if (TYPE_LENGTH (type1
) > TYPE_LENGTH (type2
))
1093 result_type
= type1
;
1094 else if (TYPE_LENGTH (type2
) > TYPE_LENGTH (type1
))
1095 result_type
= type2
;
1096 else if (TYPE_UNSIGNED (type1
))
1097 result_type
= type1
;
1098 else if (TYPE_UNSIGNED (type2
))
1099 result_type
= type2
;
1101 result_type
= type1
;
1103 if (TYPE_UNSIGNED (result_type
))
1105 LONGEST v2_signed
= value_as_long (arg2
);
1106 ULONGEST v1
, v2
, v
= 0;
1108 v1
= (ULONGEST
) value_as_long (arg1
);
1109 v2
= (ULONGEST
) v2_signed
;
1130 error (_("Division by zero"));
1134 v
= uinteger_pow (v1
, v2_signed
);
1141 error (_("Division by zero"));
1145 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1146 v1 mod 0 has a defined value, v1. */
1154 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1167 case BINOP_BITWISE_AND
:
1171 case BINOP_BITWISE_IOR
:
1175 case BINOP_BITWISE_XOR
:
1179 case BINOP_LOGICAL_AND
:
1183 case BINOP_LOGICAL_OR
:
1188 v
= v1
< v2
? v1
: v2
;
1192 v
= v1
> v2
? v1
: v2
;
1199 case BINOP_NOTEQUAL
:
1220 error (_("Invalid binary operation on numbers."));
1223 val
= allocate_value (result_type
);
1224 store_unsigned_integer (value_contents_raw (val
),
1225 TYPE_LENGTH (value_type (val
)),
1227 (get_type_arch (result_type
)),
1232 LONGEST v1
, v2
, v
= 0;
1234 v1
= value_as_long (arg1
);
1235 v2
= value_as_long (arg2
);
1256 error (_("Division by zero"));
1260 v
= integer_pow (v1
, v2
);
1267 error (_("Division by zero"));
1271 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1272 X mod 0 has a defined value, X. */
1280 /* Compute floor. */
1281 if (TRUNCATION_TOWARDS_ZERO
&& (v
< 0) && ((v1
% v2
) != 0))
1297 case BINOP_BITWISE_AND
:
1301 case BINOP_BITWISE_IOR
:
1305 case BINOP_BITWISE_XOR
:
1309 case BINOP_LOGICAL_AND
:
1313 case BINOP_LOGICAL_OR
:
1318 v
= v1
< v2
? v1
: v2
;
1322 v
= v1
> v2
? v1
: v2
;
1329 case BINOP_NOTEQUAL
:
1350 error (_("Invalid binary operation on numbers."));
1353 val
= allocate_value (result_type
);
1354 store_signed_integer (value_contents_raw (val
),
1355 TYPE_LENGTH (value_type (val
)),
1357 (get_type_arch (result_type
)),
1365 /* Widen a scalar value SCALAR_VALUE to vector type VECTOR_TYPE by
1366 replicating SCALAR_VALUE for each element of the vector. Only scalar
1367 types that can be cast to the type of one element of the vector are
1368 acceptable. The newly created vector value is returned upon success,
1369 otherwise an error is thrown. */
1372 value_vector_widen (struct value
*scalar_value
, struct type
*vector_type
)
1374 /* Widen the scalar to a vector. */
1375 struct type
*eltype
, *scalar_type
;
1376 struct value
*val
, *elval
;
1377 LONGEST low_bound
, high_bound
;
1380 CHECK_TYPEDEF (vector_type
);
1382 gdb_assert (TYPE_CODE (vector_type
) == TYPE_CODE_ARRAY
1383 && TYPE_VECTOR (vector_type
));
1385 if (!get_array_bounds (vector_type
, &low_bound
, &high_bound
))
1386 error (_("Could not determine the vector bounds"));
1388 eltype
= check_typedef (TYPE_TARGET_TYPE (vector_type
));
1389 elval
= value_cast (eltype
, scalar_value
);
1391 scalar_type
= check_typedef (value_type (scalar_value
));
1393 /* If we reduced the length of the scalar then check we didn't loose any
1395 if (TYPE_LENGTH (eltype
) < TYPE_LENGTH (scalar_type
)
1396 && !value_equal (elval
, scalar_value
))
1397 error (_("conversion of scalar to vector involves truncation"));
1399 val
= allocate_value (vector_type
);
1400 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1401 /* Duplicate the contents of elval into the destination vector. */
1402 memcpy (value_contents_writeable (val
) + (i
* TYPE_LENGTH (eltype
)),
1403 value_contents_all (elval
), TYPE_LENGTH (eltype
));
1408 /* Performs a binary operation on two vector operands by calling scalar_binop
1409 for each pair of vector components. */
1411 static struct value
*
1412 vector_binop (struct value
*val1
, struct value
*val2
, enum exp_opcode op
)
1414 struct value
*val
, *tmp
, *mark
;
1415 struct type
*type1
, *type2
, *eltype1
, *eltype2
;
1416 int t1_is_vec
, t2_is_vec
, elsize
, i
;
1417 LONGEST low_bound1
, high_bound1
, low_bound2
, high_bound2
;
1419 type1
= check_typedef (value_type (val1
));
1420 type2
= check_typedef (value_type (val2
));
1422 t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
1423 && TYPE_VECTOR (type1
)) ? 1 : 0;
1424 t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
1425 && TYPE_VECTOR (type2
)) ? 1 : 0;
1427 if (!t1_is_vec
|| !t2_is_vec
)
1428 error (_("Vector operations are only supported among vectors"));
1430 if (!get_array_bounds (type1
, &low_bound1
, &high_bound1
)
1431 || !get_array_bounds (type2
, &low_bound2
, &high_bound2
))
1432 error (_("Could not determine the vector bounds"));
1434 eltype1
= check_typedef (TYPE_TARGET_TYPE (type1
));
1435 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
));
1436 elsize
= TYPE_LENGTH (eltype1
);
1438 if (TYPE_CODE (eltype1
) != TYPE_CODE (eltype2
)
1439 || elsize
!= TYPE_LENGTH (eltype2
)
1440 || TYPE_UNSIGNED (eltype1
) != TYPE_UNSIGNED (eltype2
)
1441 || low_bound1
!= low_bound2
|| high_bound1
!= high_bound2
)
1442 error (_("Cannot perform operation on vectors with different types"));
1444 val
= allocate_value (type1
);
1445 mark
= value_mark ();
1446 for (i
= 0; i
< high_bound1
- low_bound1
+ 1; i
++)
1448 tmp
= value_binop (value_subscript (val1
, i
),
1449 value_subscript (val2
, i
), op
);
1450 memcpy (value_contents_writeable (val
) + i
* elsize
,
1451 value_contents_all (tmp
),
1454 value_free_to_mark (mark
);
1459 /* Perform a binary operation on two operands. */
1462 value_binop (struct value
*arg1
, struct value
*arg2
, enum exp_opcode op
)
1465 struct type
*type1
= check_typedef (value_type (arg1
));
1466 struct type
*type2
= check_typedef (value_type (arg2
));
1467 int t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
1468 && TYPE_VECTOR (type1
));
1469 int t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
1470 && TYPE_VECTOR (type2
));
1472 if (!t1_is_vec
&& !t2_is_vec
)
1473 val
= scalar_binop (arg1
, arg2
, op
);
1474 else if (t1_is_vec
&& t2_is_vec
)
1475 val
= vector_binop (arg1
, arg2
, op
);
1478 /* Widen the scalar operand to a vector. */
1479 struct value
**v
= t1_is_vec
? &arg2
: &arg1
;
1480 struct type
*t
= t1_is_vec
? type2
: type1
;
1482 if (TYPE_CODE (t
) != TYPE_CODE_FLT
1483 && TYPE_CODE (t
) != TYPE_CODE_DECFLOAT
1484 && !is_integral_type (t
))
1485 error (_("Argument to operation not a number or boolean."));
1487 /* Replicate the scalar value to make a vector value. */
1488 *v
= value_vector_widen (*v
, t1_is_vec
? type1
: type2
);
1490 val
= vector_binop (arg1
, arg2
, op
);
1496 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1499 value_logical_not (struct value
*arg1
)
1505 arg1
= coerce_array (arg1
);
1506 type1
= check_typedef (value_type (arg1
));
1508 if (TYPE_CODE (type1
) == TYPE_CODE_FLT
)
1509 return 0 == value_as_double (arg1
);
1510 else if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
1511 return decimal_is_zero (value_contents (arg1
), TYPE_LENGTH (type1
),
1512 gdbarch_byte_order (get_type_arch (type1
)));
1514 len
= TYPE_LENGTH (type1
);
1515 p
= value_contents (arg1
);
1526 /* Perform a comparison on two string values (whose content are not
1527 necessarily null terminated) based on their length. */
1530 value_strcmp (struct value
*arg1
, struct value
*arg2
)
1532 int len1
= TYPE_LENGTH (value_type (arg1
));
1533 int len2
= TYPE_LENGTH (value_type (arg2
));
1534 const gdb_byte
*s1
= value_contents (arg1
);
1535 const gdb_byte
*s2
= value_contents (arg2
);
1536 int i
, len
= len1
< len2
? len1
: len2
;
1538 for (i
= 0; i
< len
; i
++)
1542 else if (s1
[i
] > s2
[i
])
1550 else if (len1
> len2
)
1556 /* Simulate the C operator == by returning a 1
1557 iff ARG1 and ARG2 have equal contents. */
1560 value_equal (struct value
*arg1
, struct value
*arg2
)
1565 struct type
*type1
, *type2
;
1566 enum type_code code1
;
1567 enum type_code code2
;
1568 int is_int1
, is_int2
;
1570 arg1
= coerce_array (arg1
);
1571 arg2
= coerce_array (arg2
);
1573 type1
= check_typedef (value_type (arg1
));
1574 type2
= check_typedef (value_type (arg2
));
1575 code1
= TYPE_CODE (type1
);
1576 code2
= TYPE_CODE (type2
);
1577 is_int1
= is_integral_type (type1
);
1578 is_int2
= is_integral_type (type2
);
1580 if (is_int1
&& is_int2
)
1581 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1583 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1584 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1586 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1587 `long double' values are returned in static storage (m68k). */
1588 DOUBLEST d
= value_as_double (arg1
);
1590 return d
== value_as_double (arg2
);
1592 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1593 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1595 gdb_byte v1
[16], v2
[16];
1597 enum bfd_endian byte_order_v1
, byte_order_v2
;
1599 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
1600 v2
, &len_v2
, &byte_order_v2
);
1602 return decimal_compare (v1
, len_v1
, byte_order_v1
,
1603 v2
, len_v2
, byte_order_v2
) == 0;
1606 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1608 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1609 return value_as_address (arg1
) == (CORE_ADDR
) value_as_long (arg2
);
1610 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1611 return (CORE_ADDR
) value_as_long (arg1
) == value_as_address (arg2
);
1613 else if (code1
== code2
1614 && ((len
= (int) TYPE_LENGTH (type1
))
1615 == (int) TYPE_LENGTH (type2
)))
1617 p1
= value_contents (arg1
);
1618 p2
= value_contents (arg2
);
1626 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1628 return value_strcmp (arg1
, arg2
) == 0;
1632 error (_("Invalid type combination in equality test."));
1633 return 0; /* For lint -- never reached. */
1637 /* Compare values based on their raw contents. Useful for arrays since
1638 value_equal coerces them to pointers, thus comparing just the address
1639 of the array instead of its contents. */
1642 value_equal_contents (struct value
*arg1
, struct value
*arg2
)
1644 struct type
*type1
, *type2
;
1646 type1
= check_typedef (value_type (arg1
));
1647 type2
= check_typedef (value_type (arg2
));
1649 return (TYPE_CODE (type1
) == TYPE_CODE (type2
)
1650 && TYPE_LENGTH (type1
) == TYPE_LENGTH (type2
)
1651 && memcmp (value_contents (arg1
), value_contents (arg2
),
1652 TYPE_LENGTH (type1
)) == 0);
1655 /* Simulate the C operator < by returning 1
1656 iff ARG1's contents are less than ARG2's. */
1659 value_less (struct value
*arg1
, struct value
*arg2
)
1661 enum type_code code1
;
1662 enum type_code code2
;
1663 struct type
*type1
, *type2
;
1664 int is_int1
, is_int2
;
1666 arg1
= coerce_array (arg1
);
1667 arg2
= coerce_array (arg2
);
1669 type1
= check_typedef (value_type (arg1
));
1670 type2
= check_typedef (value_type (arg2
));
1671 code1
= TYPE_CODE (type1
);
1672 code2
= TYPE_CODE (type2
);
1673 is_int1
= is_integral_type (type1
);
1674 is_int2
= is_integral_type (type2
);
1676 if (is_int1
&& is_int2
)
1677 return longest_to_int (value_as_long (value_binop (arg1
, arg2
,
1679 else if ((code1
== TYPE_CODE_FLT
|| is_int1
)
1680 && (code2
== TYPE_CODE_FLT
|| is_int2
))
1682 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1683 `long double' values are returned in static storage (m68k). */
1684 DOUBLEST d
= value_as_double (arg1
);
1686 return d
< value_as_double (arg2
);
1688 else if ((code1
== TYPE_CODE_DECFLOAT
|| is_int1
)
1689 && (code2
== TYPE_CODE_DECFLOAT
|| is_int2
))
1691 gdb_byte v1
[16], v2
[16];
1693 enum bfd_endian byte_order_v1
, byte_order_v2
;
1695 value_args_as_decimal (arg1
, arg2
, v1
, &len_v1
, &byte_order_v1
,
1696 v2
, &len_v2
, &byte_order_v2
);
1698 return decimal_compare (v1
, len_v1
, byte_order_v1
,
1699 v2
, len_v2
, byte_order_v2
) == -1;
1701 else if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
1702 return value_as_address (arg1
) < value_as_address (arg2
);
1704 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1706 else if (code1
== TYPE_CODE_PTR
&& is_int2
)
1707 return value_as_address (arg1
) < (CORE_ADDR
) value_as_long (arg2
);
1708 else if (code2
== TYPE_CODE_PTR
&& is_int1
)
1709 return (CORE_ADDR
) value_as_long (arg1
) < value_as_address (arg2
);
1710 else if (code1
== TYPE_CODE_STRING
&& code2
== TYPE_CODE_STRING
)
1711 return value_strcmp (arg1
, arg2
) < 0;
1714 error (_("Invalid type combination in ordering comparison."));
1719 /* The unary operators +, - and ~. They free the argument ARG1. */
1722 value_pos (struct value
*arg1
)
1726 arg1
= coerce_ref (arg1
);
1727 type
= check_typedef (value_type (arg1
));
1729 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1730 return value_from_double (type
, value_as_double (arg1
));
1731 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1732 return value_from_decfloat (type
, value_contents (arg1
));
1733 else if (is_integral_type (type
))
1735 return value_from_longest (type
, value_as_long (arg1
));
1737 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1739 struct value
*val
= allocate_value (type
);
1741 memcpy (value_contents_raw (val
), value_contents (arg1
),
1742 TYPE_LENGTH (type
));
1747 error (_("Argument to positive operation not a number."));
1748 return 0; /* For lint -- never reached. */
1753 value_neg (struct value
*arg1
)
1757 arg1
= coerce_ref (arg1
);
1758 type
= check_typedef (value_type (arg1
));
1760 if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1762 struct value
*val
= allocate_value (type
);
1763 int len
= TYPE_LENGTH (type
);
1764 gdb_byte decbytes
[16]; /* a decfloat is at most 128 bits long. */
1766 memcpy (decbytes
, value_contents (arg1
), len
);
1768 if (gdbarch_byte_order (get_type_arch (type
)) == BFD_ENDIAN_LITTLE
)
1769 decbytes
[len
-1] = decbytes
[len
- 1] | 0x80;
1771 decbytes
[0] = decbytes
[0] | 0x80;
1773 memcpy (value_contents_raw (val
), decbytes
, len
);
1776 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1777 return value_from_double (type
, -value_as_double (arg1
));
1778 else if (is_integral_type (type
))
1780 return value_from_longest (type
, -value_as_long (arg1
));
1782 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1784 struct value
*tmp
, *val
= allocate_value (type
);
1785 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1787 LONGEST low_bound
, high_bound
;
1789 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1790 error (_("Could not determine the vector bounds"));
1792 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1794 tmp
= value_neg (value_subscript (arg1
, i
));
1795 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
1796 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
1802 error (_("Argument to negate operation not a number."));
1803 return 0; /* For lint -- never reached. */
1808 value_complement (struct value
*arg1
)
1813 arg1
= coerce_ref (arg1
);
1814 type
= check_typedef (value_type (arg1
));
1816 if (is_integral_type (type
))
1817 val
= value_from_longest (type
, ~value_as_long (arg1
));
1818 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
1821 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
1823 LONGEST low_bound
, high_bound
;
1825 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1826 error (_("Could not determine the vector bounds"));
1828 val
= allocate_value (type
);
1829 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
1831 tmp
= value_complement (value_subscript (arg1
, i
));
1832 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
1833 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
1837 error (_("Argument to complement operation not an integer, boolean."));
1842 /* The INDEX'th bit of SET value whose value_type is TYPE,
1843 and whose value_contents is valaddr.
1844 Return -1 if out of range, -2 other error. */
1847 value_bit_index (struct type
*type
, const gdb_byte
*valaddr
, int index
)
1849 struct gdbarch
*gdbarch
= get_type_arch (type
);
1850 LONGEST low_bound
, high_bound
;
1853 struct type
*range
= TYPE_INDEX_TYPE (type
);
1855 if (get_discrete_bounds (range
, &low_bound
, &high_bound
) < 0)
1857 if (index
< low_bound
|| index
> high_bound
)
1859 rel_index
= index
- low_bound
;
1860 word
= extract_unsigned_integer (valaddr
+ (rel_index
/ TARGET_CHAR_BIT
), 1,
1861 gdbarch_byte_order (gdbarch
));
1862 rel_index
%= TARGET_CHAR_BIT
;
1863 if (gdbarch_bits_big_endian (gdbarch
))
1864 rel_index
= TARGET_CHAR_BIT
- 1 - rel_index
;
1865 return (word
>> rel_index
) & 1;
1869 value_in (struct value
*element
, struct value
*set
)
1872 struct type
*settype
= check_typedef (value_type (set
));
1873 struct type
*eltype
= check_typedef (value_type (element
));
1875 if (TYPE_CODE (eltype
) == TYPE_CODE_RANGE
)
1876 eltype
= TYPE_TARGET_TYPE (eltype
);
1877 if (TYPE_CODE (settype
) != TYPE_CODE_SET
)
1878 error (_("Second argument of 'IN' has wrong type"));
1879 if (TYPE_CODE (eltype
) != TYPE_CODE_INT
1880 && TYPE_CODE (eltype
) != TYPE_CODE_CHAR
1881 && TYPE_CODE (eltype
) != TYPE_CODE_ENUM
1882 && TYPE_CODE (eltype
) != TYPE_CODE_BOOL
)
1883 error (_("First argument of 'IN' has wrong type"));
1884 member
= value_bit_index (settype
, value_contents (set
),
1885 value_as_long (element
));
1887 error (_("First argument of 'IN' not in range"));
1892 _initialize_valarith (void)
This page took 0.073063 seconds and 4 git commands to generate.