projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Updated gdb/Changelog:
[deliverable/binutils-gdb.git] / gdb / valarith.c
... / ...
CommitLineData
1/* Perform arithmetic and other operations on values, for GDB.
2
3 Copyright (C) 1986, 1988-2005, 2007-2012 Free Software Foundation,
4 Inc.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21#include "defs.h"
22#include "value.h"
23#include "symtab.h"
24#include "gdbtypes.h"
25#include "expression.h"
26#include "target.h"
27#include "language.h"
28#include "gdb_string.h"
29#include "doublest.h"
30#include "dfp.h"
31#include <math.h>
32#include "infcall.h"
33#include "exceptions.h"
34
35/* Define whether or not the C operator '/' truncates towards zero for
36 differently signed operands (truncation direction is undefined in C). */
37
38#ifndef TRUNCATION_TOWARDS_ZERO
39#define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
40#endif
41
42void _initialize_valarith (void);
43\f
44
45/* Given a pointer, return the size of its target.
46 If the pointer type is void *, then return 1.
47 If the target type is incomplete, then error out.
48 This isn't a general purpose function, but just a
49 helper for value_ptradd. */
50
51static LONGEST
52find_size_for_pointer_math (struct type *ptr_type)
53{
54 LONGEST sz = -1;
55 struct type *ptr_target;
56
57 gdb_assert (TYPE_CODE (ptr_type) == TYPE_CODE_PTR);
58 ptr_target = check_typedef (TYPE_TARGET_TYPE (ptr_type));
59
60 sz = TYPE_LENGTH (ptr_target);
61 if (sz == 0)
62 {
63 if (TYPE_CODE (ptr_type) == TYPE_CODE_VOID)
64 sz = 1;
65 else
66 {
67 const char *name;
68
69 name = TYPE_NAME (ptr_target);
70 if (name == NULL)
71 name = TYPE_TAG_NAME (ptr_target);
72 if (name == NULL)
73 error (_("Cannot perform pointer math on incomplete types, "
74 "try casting to a known type, or void *."));
75 else
76 error (_("Cannot perform pointer math on incomplete type \"%s\", "
77 "try casting to a known type, or void *."), name);
78 }
79 }
80 return sz;
81}
82
83/* Given a pointer ARG1 and an integral value ARG2, return the
84 result of C-style pointer arithmetic ARG1 + ARG2. */
85
86struct value *
87value_ptradd (struct value *arg1, LONGEST arg2)
88{
89 struct type *valptrtype;
90 LONGEST sz;
91 struct value *result;
92
93 arg1 = coerce_array (arg1);
94 valptrtype = check_typedef (value_type (arg1));
95 sz = find_size_for_pointer_math (valptrtype);
96
97 result = value_from_pointer (valptrtype,
98 value_as_address (arg1) + sz * arg2);
99 if (VALUE_LVAL (result) != lval_internalvar)
100 set_value_component_location (result, arg1);
101 return result;
102}
103
104/* Given two compatible pointer values ARG1 and ARG2, return the
105 result of C-style pointer arithmetic ARG1 - ARG2. */
106
107LONGEST
108value_ptrdiff (struct value *arg1, struct value *arg2)
109{
110 struct type *type1, *type2;
111 LONGEST sz;
112
113 arg1 = coerce_array (arg1);
114 arg2 = coerce_array (arg2);
115 type1 = check_typedef (value_type (arg1));
116 type2 = check_typedef (value_type (arg2));
117
118 gdb_assert (TYPE_CODE (type1) == TYPE_CODE_PTR);
119 gdb_assert (TYPE_CODE (type2) == TYPE_CODE_PTR);
120
121 if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)))
122 != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2))))
123 error (_("First argument of `-' is a pointer and "
124 "second argument is neither\n"
125 "an integer nor a pointer of the same type."));
126
127 sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
128 if (sz == 0)
129 {
130 warning (_("Type size unknown, assuming 1. "
131 "Try casting to a known type, or void *."));
132 sz = 1;
133 }
134
135 return (value_as_long (arg1) - value_as_long (arg2)) / sz;
136}
137
138/* Return the value of ARRAY[IDX].
139
140 ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING. If the
141 current language supports C-style arrays, it may also be TYPE_CODE_PTR.
142
143 See comments in value_coerce_array() for rationale for reason for
144 doing lower bounds adjustment here rather than there.
145 FIXME: Perhaps we should validate that the index is valid and if
146 verbosity is set, warn about invalid indices (but still use them). */
147
148struct value *
149value_subscript (struct value *array, LONGEST index)
150{
151 int c_style = current_language->c_style_arrays;
152 struct type *tarray;
153
154 array = coerce_ref (array);
155 tarray = check_typedef (value_type (array));
156
157 if (TYPE_CODE (tarray) == TYPE_CODE_ARRAY
158 || TYPE_CODE (tarray) == TYPE_CODE_STRING)
159 {
160 struct type *range_type = TYPE_INDEX_TYPE (tarray);
161 LONGEST lowerbound, upperbound;
162
163 get_discrete_bounds (range_type, &lowerbound, &upperbound);
164 if (VALUE_LVAL (array) != lval_memory)
165 return value_subscripted_rvalue (array, index, lowerbound);
166
167 if (c_style == 0)
168 {
169 if (index >= lowerbound && index <= upperbound)
170 return value_subscripted_rvalue (array, index, lowerbound);
171 /* Emit warning unless we have an array of unknown size.
172 An array of unknown size has lowerbound 0 and upperbound -1. */
173 if (upperbound > -1)
174 warning (_("array or string index out of range"));
175 /* fall doing C stuff */
176 c_style = 1;
177 }
178
179 index -= lowerbound;
180 array = value_coerce_array (array);
181 }
182
183 if (c_style)
184 return value_ind (value_ptradd (array, index));
185 else
186 error (_("not an array or string"));
187}
188
189/* Return the value of EXPR[IDX], expr an aggregate rvalue
190 (eg, a vector register). This routine used to promote floats
191 to doubles, but no longer does. */
192
193struct value *
194value_subscripted_rvalue (struct value *array, LONGEST index, int lowerbound)
195{
196 struct type *array_type = check_typedef (value_type (array));
197 struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
198 unsigned int elt_size = TYPE_LENGTH (elt_type);
199 unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
200 struct value *v;
201
202 if (index < lowerbound || (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type)
203 && elt_offs >= TYPE_LENGTH (array_type)))
204 error (_("no such vector element"));
205
206 if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
207 v = allocate_value_lazy (elt_type);
208 else
209 {
210 v = allocate_value (elt_type);
211 value_contents_copy (v, value_embedded_offset (v),
212 array, value_embedded_offset (array) + elt_offs,
213 elt_size);
214 }
215
216 set_value_component_location (v, array);
217 VALUE_REGNUM (v) = VALUE_REGNUM (array);
218 VALUE_FRAME_ID (v) = VALUE_FRAME_ID (array);
219 set_value_offset (v, value_offset (array) + elt_offs);
220 return v;
221}
222
223\f
224/* Check to see if either argument is a structure, or a reference to
225 one. This is called so we know whether to go ahead with the normal
226 binop or look for a user defined function instead.
227
228 For now, we do not overload the `=' operator. */
229
230int
231binop_types_user_defined_p (enum exp_opcode op,
232 struct type *type1, struct type *type2)
233{
234 if (op == BINOP_ASSIGN || op == BINOP_CONCAT)
235 return 0;
236
237 type1 = check_typedef (type1);
238 if (TYPE_CODE (type1) == TYPE_CODE_REF)
239 type1 = check_typedef (TYPE_TARGET_TYPE (type1));
240
241 type2 = check_typedef (type2);
242 if (TYPE_CODE (type2) == TYPE_CODE_REF)
243 type2 = check_typedef (TYPE_TARGET_TYPE (type2));
244
245 return (TYPE_CODE (type1) == TYPE_CODE_STRUCT
246 || TYPE_CODE (type2) == TYPE_CODE_STRUCT);
247}
248
249/* Check to see if either argument is a structure, or a reference to
250 one. This is called so we know whether to go ahead with the normal
251 binop or look for a user defined function instead.
252
253 For now, we do not overload the `=' operator. */
254
255int
256binop_user_defined_p (enum exp_opcode op,
257 struct value *arg1, struct value *arg2)
258{
259 return binop_types_user_defined_p (op, value_type (arg1), value_type (arg2));
260}
261
262/* Check to see if argument is a structure. This is called so
263 we know whether to go ahead with the normal unop or look for a
264 user defined function instead.
265
266 For now, we do not overload the `&' operator. */
267
268int
269unop_user_defined_p (enum exp_opcode op, struct value *arg1)
270{
271 struct type *type1;
272
273 if (op == UNOP_ADDR)
274 return 0;
275 type1 = check_typedef (value_type (arg1));
276 if (TYPE_CODE (type1) == TYPE_CODE_REF)
277 type1 = check_typedef (TYPE_TARGET_TYPE (type1));
278 return TYPE_CODE (type1) == TYPE_CODE_STRUCT;
279}
280
281/* Try to find an operator named OPERATOR which takes NARGS arguments
282 specified in ARGS. If the operator found is a static member operator
283 *STATIC_MEMFUNP will be set to 1, and otherwise 0.
284 The search if performed through find_overload_match which will handle
285 member operators, non member operators, operators imported implicitly or
286 explicitly, and perform correct overload resolution in all of the above
287 situations or combinations thereof. */
288
289static struct value *
290value_user_defined_cpp_op (struct value **args, int nargs, char *operator,
291 int *static_memfuncp)
292{
293
294 struct symbol *symp = NULL;
295 struct value *valp = NULL;
296
297 find_overload_match (args, nargs, operator, BOTH /* could be method */,
298 0 /* strict match */, &args[0], /* objp */
299 NULL /* pass NULL symbol since symbol is unknown */,
300 &valp, &symp, static_memfuncp, 0);
301
302 if (valp)
303 return valp;
304
305 if (symp)
306 {
307 /* This is a non member function and does not
308 expect a reference as its first argument
309 rather the explicit structure. */
310 args[0] = value_ind (args[0]);
311 return value_of_variable (symp, 0);
312 }
313
314 error (_("Could not find %s."), operator);
315}
316
317/* Lookup user defined operator NAME. Return a value representing the
318 function, otherwise return NULL. */
319
320static struct value *
321value_user_defined_op (struct value **argp, struct value **args, char *name,
322 int *static_memfuncp, int nargs)
323{
324 struct value *result = NULL;
325
326 if (current_language->la_language == language_cplus)
327 result = value_user_defined_cpp_op (args, nargs, name, static_memfuncp);
328 else
329 result = value_struct_elt (argp, args, name, static_memfuncp,
330 "structure");
331
332 return result;
333}
334
335/* We know either arg1 or arg2 is a structure, so try to find the right
336 user defined function. Create an argument vector that calls
337 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
338 binary operator which is legal for GNU C++).
339
340 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
341 is the opcode saying how to modify it. Otherwise, OTHEROP is
342 unused. */
343
344struct value *
345value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
346 enum exp_opcode otherop, enum noside noside)
347{
348 struct value **argvec;
349 char *ptr;
350 char tstr[13];
351 int static_memfuncp;
352
353 arg1 = coerce_ref (arg1);
354 arg2 = coerce_ref (arg2);
355
356 /* now we know that what we have to do is construct our
357 arg vector and find the right function to call it with. */
358
359 if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT)
360 error (_("Can't do that binary op on that type")); /* FIXME be explicit */
361
362 argvec = (struct value **) alloca (sizeof (struct value *) * 4);
363 argvec[1] = value_addr (arg1);
364 argvec[2] = arg2;
365 argvec[3] = 0;
366
367 /* Make the right function name up. */
368 strcpy (tstr, "operator__");
369 ptr = tstr + 8;
370 switch (op)
371 {
372 case BINOP_ADD:
373 strcpy (ptr, "+");
374 break;
375 case BINOP_SUB:
376 strcpy (ptr, "-");
377 break;
378 case BINOP_MUL:
379 strcpy (ptr, "*");
380 break;
381 case BINOP_DIV:
382 strcpy (ptr, "/");
383 break;
384 case BINOP_REM:
385 strcpy (ptr, "%");
386 break;
387 case BINOP_LSH:
388 strcpy (ptr, "<<");
389 break;
390 case BINOP_RSH:
391 strcpy (ptr, ">>");
392 break;
393 case BINOP_BITWISE_AND:
394 strcpy (ptr, "&");
395 break;
396 case BINOP_BITWISE_IOR:
397 strcpy (ptr, "|");
398 break;
399 case BINOP_BITWISE_XOR:
400 strcpy (ptr, "^");
401 break;
402 case BINOP_LOGICAL_AND:
403 strcpy (ptr, "&&");
404 break;
405 case BINOP_LOGICAL_OR:
406 strcpy (ptr, "||");
407 break;
408 case BINOP_MIN:
409 strcpy (ptr, "<?");
410 break;
411 case BINOP_MAX:
412 strcpy (ptr, ">?");
413 break;
414 case BINOP_ASSIGN:
415 strcpy (ptr, "=");
416 break;
417 case BINOP_ASSIGN_MODIFY:
418 switch (otherop)
419 {
420 case BINOP_ADD:
421 strcpy (ptr, "+=");
422 break;
423 case BINOP_SUB:
424 strcpy (ptr, "-=");
425 break;
426 case BINOP_MUL:
427 strcpy (ptr, "*=");
428 break;
429 case BINOP_DIV:
430 strcpy (ptr, "/=");
431 break;
432 case BINOP_REM:
433 strcpy (ptr, "%=");
434 break;
435 case BINOP_BITWISE_AND:
436 strcpy (ptr, "&=");
437 break;
438 case BINOP_BITWISE_IOR:
439 strcpy (ptr, "|=");
440 break;
441 case BINOP_BITWISE_XOR:
442 strcpy (ptr, "^=");
443 break;
444 case BINOP_MOD: /* invalid */
445 default:
446 error (_("Invalid binary operation specified."));
447 }
448 break;
449 case BINOP_SUBSCRIPT:
450 strcpy (ptr, "[]");
451 break;
452 case BINOP_EQUAL:
453 strcpy (ptr, "==");
454 break;
455 case BINOP_NOTEQUAL:
456 strcpy (ptr, "!=");
457 break;
458 case BINOP_LESS:
459 strcpy (ptr, "<");
460 break;
461 case BINOP_GTR:
462 strcpy (ptr, ">");
463 break;
464 case BINOP_GEQ:
465 strcpy (ptr, ">=");
466 break;
467 case BINOP_LEQ:
468 strcpy (ptr, "<=");
469 break;
470 case BINOP_MOD: /* invalid */
471 default:
472 error (_("Invalid binary operation specified."));
473 }
474
475 argvec[0] = value_user_defined_op (&arg1, argvec + 1, tstr,
476 &static_memfuncp, 2);
477
478 if (argvec[0])
479 {
480 if (static_memfuncp)
481 {
482 argvec[1] = argvec[0];
483 argvec++;
484 }
485 if (noside == EVAL_AVOID_SIDE_EFFECTS)
486 {
487 struct type *return_type;
488
489 return_type
490 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
491 return value_zero (return_type, VALUE_LVAL (arg1));
492 }
493 return call_function_by_hand (argvec[0], 2 - static_memfuncp,
494 argvec + 1);
495 }
496 throw_error (NOT_FOUND_ERROR,
497 _("member function %s not found"), tstr);
498#ifdef lint
499 return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
500#endif
501}
502
503/* We know that arg1 is a structure, so try to find a unary user
504 defined operator that matches the operator in question.
505 Create an argument vector that calls arg1.operator @ (arg1)
506 and return that value (where '@' is (almost) any unary operator which
507 is legal for GNU C++). */
508
509struct value *
510value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
511{
512 struct gdbarch *gdbarch = get_type_arch (value_type (arg1));
513 struct value **argvec;
514 char *ptr, *mangle_ptr;
515 char tstr[13], mangle_tstr[13];
516 int static_memfuncp, nargs;
517
518 arg1 = coerce_ref (arg1);
519
520 /* now we know that what we have to do is construct our
521 arg vector and find the right function to call it with. */
522
523 if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT)
524 error (_("Can't do that unary op on that type")); /* FIXME be explicit */
525
526 argvec = (struct value **) alloca (sizeof (struct value *) * 4);
527 argvec[1] = value_addr (arg1);
528 argvec[2] = 0;
529
530 nargs = 1;
531
532 /* Make the right function name up. */
533 strcpy (tstr, "operator__");
534 ptr = tstr + 8;
535 strcpy (mangle_tstr, "__");
536 mangle_ptr = mangle_tstr + 2;
537 switch (op)
538 {
539 case UNOP_PREINCREMENT:
540 strcpy (ptr, "++");
541 break;
542 case UNOP_PREDECREMENT:
543 strcpy (ptr, "--");
544 break;
545 case UNOP_POSTINCREMENT:
546 strcpy (ptr, "++");
547 argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
548 argvec[3] = 0;
549 nargs ++;
550 break;
551 case UNOP_POSTDECREMENT:
552 strcpy (ptr, "--");
553 argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
554 argvec[3] = 0;
555 nargs ++;
556 break;
557 case UNOP_LOGICAL_NOT:
558 strcpy (ptr, "!");
559 break;
560 case UNOP_COMPLEMENT:
561 strcpy (ptr, "~");
562 break;
563 case UNOP_NEG:
564 strcpy (ptr, "-");
565 break;
566 case UNOP_PLUS:
567 strcpy (ptr, "+");
568 break;
569 case UNOP_IND:
570 strcpy (ptr, "*");
571 break;
572 case STRUCTOP_PTR:
573 strcpy (ptr, "->");
574 break;
575 default:
576 error (_("Invalid unary operation specified."));
577 }
578
579 argvec[0] = value_user_defined_op (&arg1, argvec + 1, tstr,
580 &static_memfuncp, nargs);
581
582 if (argvec[0])
583 {
584 if (static_memfuncp)
585 {
586 argvec[1] = argvec[0];
587 nargs --;
588 argvec++;
589 }
590 if (noside == EVAL_AVOID_SIDE_EFFECTS)
591 {
592 struct type *return_type;
593
594 return_type
595 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
596 return value_zero (return_type, VALUE_LVAL (arg1));
597 }
598 return call_function_by_hand (argvec[0], nargs, argvec + 1);
599 }
600 throw_error (NOT_FOUND_ERROR,
601 _("member function %s not found"), tstr);
602
603 return 0; /* For lint -- never reached */
604}
605\f
606
607/* Concatenate two values with the following conditions:
608
609 (1) Both values must be either bitstring values or character string
610 values and the resulting value consists of the concatenation of
611 ARG1 followed by ARG2.
612
613 or
614
615 One value must be an integer value and the other value must be
616 either a bitstring value or character string value, which is
617 to be repeated by the number of times specified by the integer
618 value.
619
620
621 (2) Boolean values are also allowed and are treated as bit string
622 values of length 1.
623
624 (3) Character values are also allowed and are treated as character
625 string values of length 1. */
626
627struct value *
628value_concat (struct value *arg1, struct value *arg2)
629{
630 struct value *inval1;
631 struct value *inval2;
632 struct value *outval = NULL;
633 int inval1len, inval2len;
634 int count, idx;
635 char *ptr;
636 char inchar;
637 struct type *type1 = check_typedef (value_type (arg1));
638 struct type *type2 = check_typedef (value_type (arg2));
639 struct type *char_type;
640
641 /* First figure out if we are dealing with two values to be concatenated
642 or a repeat count and a value to be repeated. INVAL1 is set to the
643 first of two concatenated values, or the repeat count. INVAL2 is set
644 to the second of the two concatenated values or the value to be
645 repeated. */
646
647 if (TYPE_CODE (type2) == TYPE_CODE_INT)
648 {
649 struct type *tmp = type1;
650
651 type1 = tmp;
652 tmp = type2;
653 inval1 = arg2;
654 inval2 = arg1;
655 }
656 else
657 {
658 inval1 = arg1;
659 inval2 = arg2;
660 }
661
662 /* Now process the input values. */
663
664 if (TYPE_CODE (type1) == TYPE_CODE_INT)
665 {
666 /* We have a repeat count. Validate the second value and then
667 construct a value repeated that many times. */
668 if (TYPE_CODE (type2) == TYPE_CODE_STRING
669 || TYPE_CODE (type2) == TYPE_CODE_CHAR)
670 {
671 struct cleanup *back_to;
672
673 count = longest_to_int (value_as_long (inval1));
674 inval2len = TYPE_LENGTH (type2);
675 ptr = (char *) xmalloc (count * inval2len);
676 back_to = make_cleanup (xfree, ptr);
677 if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
678 {
679 char_type = type2;
680
681 inchar = (char) unpack_long (type2,
682 value_contents (inval2));
683 for (idx = 0; idx < count; idx++)
684 {
685 *(ptr + idx) = inchar;
686 }
687 }
688 else
689 {
690 char_type = TYPE_TARGET_TYPE (type2);
691
692 for (idx = 0; idx < count; idx++)
693 {
694 memcpy (ptr + (idx * inval2len), value_contents (inval2),
695 inval2len);
696 }
697 }
698 outval = value_string (ptr, count * inval2len, char_type);
699 do_cleanups (back_to);
700 }
701 else if (TYPE_CODE (type2) == TYPE_CODE_BOOL)
702 {
703 error (_("unimplemented support for boolean repeats"));
704 }
705 else
706 {
707 error (_("can't repeat values of that type"));
708 }
709 }
710 else if (TYPE_CODE (type1) == TYPE_CODE_STRING
711 || TYPE_CODE (type1) == TYPE_CODE_CHAR)
712 {
713 struct cleanup *back_to;
714
715 /* We have two character strings to concatenate. */
716 if (TYPE_CODE (type2) != TYPE_CODE_STRING
717 && TYPE_CODE (type2) != TYPE_CODE_CHAR)
718 {
719 error (_("Strings can only be concatenated with other strings."));
720 }
721 inval1len = TYPE_LENGTH (type1);
722 inval2len = TYPE_LENGTH (type2);
723 ptr = (char *) xmalloc (inval1len + inval2len);
724 back_to = make_cleanup (xfree, ptr);
725 if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
726 {
727 char_type = type1;
728
729 *ptr = (char) unpack_long (type1, value_contents (inval1));
730 }
731 else
732 {
733 char_type = TYPE_TARGET_TYPE (type1);
734
735 memcpy (ptr, value_contents (inval1), inval1len);
736 }
737 if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
738 {
739 *(ptr + inval1len) =
740 (char) unpack_long (type2, value_contents (inval2));
741 }
742 else
743 {
744 memcpy (ptr + inval1len, value_contents (inval2), inval2len);
745 }
746 outval = value_string (ptr, inval1len + inval2len, char_type);
747 do_cleanups (back_to);
748 }
749 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL)
750 {
751 /* We have two bitstrings to concatenate. */
752 if (TYPE_CODE (type2) != TYPE_CODE_BOOL)
753 {
754 error (_("Booleans can only be concatenated "
755 "with other bitstrings or booleans."));
756 }
757 error (_("unimplemented support for boolean concatenation."));
758 }
759 else
760 {
761 /* We don't know how to concatenate these operands. */
762 error (_("illegal operands for concatenation."));
763 }
764 return (outval);
765}
766\f
767/* Integer exponentiation: V1**V2, where both arguments are
768 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
769
770static LONGEST
771integer_pow (LONGEST v1, LONGEST v2)
772{
773 if (v2 < 0)
774 {
775 if (v1 == 0)
776 error (_("Attempt to raise 0 to negative power."));
777 else
778 return 0;
779 }
780 else
781 {
782 /* The Russian Peasant's Algorithm. */
783 LONGEST v;
784
785 v = 1;
786 for (;;)
787 {
788 if (v2 & 1L)
789 v *= v1;
790 v2 >>= 1;
791 if (v2 == 0)
792 return v;
793 v1 *= v1;
794 }
795 }
796}
797
798/* Integer exponentiation: V1**V2, where both arguments are
799 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
800
801static ULONGEST
802uinteger_pow (ULONGEST v1, LONGEST v2)
803{
804 if (v2 < 0)
805 {
806 if (v1 == 0)
807 error (_("Attempt to raise 0 to negative power."));
808 else
809 return 0;
810 }
811 else
812 {
813 /* The Russian Peasant's Algorithm. */
814 ULONGEST v;
815
816 v = 1;
817 for (;;)
818 {
819 if (v2 & 1L)
820 v *= v1;
821 v2 >>= 1;
822 if (v2 == 0)
823 return v;
824 v1 *= v1;
825 }
826 }
827}
828
829/* Obtain decimal value of arguments for binary operation, converting from
830 other types if one of them is not decimal floating point. */
831static void
832value_args_as_decimal (struct value *arg1, struct value *arg2,
833 gdb_byte *x, int *len_x, enum bfd_endian *byte_order_x,
834 gdb_byte *y, int *len_y, enum bfd_endian *byte_order_y)
835{
836 struct type *type1, *type2;
837
838 type1 = check_typedef (value_type (arg1));
839 type2 = check_typedef (value_type (arg2));
840
841 /* At least one of the arguments must be of decimal float type. */
842 gdb_assert (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
843 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT);
844
845 if (TYPE_CODE (type1) == TYPE_CODE_FLT
846 || TYPE_CODE (type2) == TYPE_CODE_FLT)
847 /* The DFP extension to the C language does not allow mixing of
848 * decimal float types with other float types in expressions
849 * (see WDTR 24732, page 12). */
850 error (_("Mixing decimal floating types with "
851 "other floating types is not allowed."));
852
853 /* Obtain decimal value of arg1, converting from other types
854 if necessary. */
855
856 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
857 {
858 *byte_order_x = gdbarch_byte_order (get_type_arch (type1));
859 *len_x = TYPE_LENGTH (type1);
860 memcpy (x, value_contents (arg1), *len_x);
861 }
862 else if (is_integral_type (type1))
863 {
864 *byte_order_x = gdbarch_byte_order (get_type_arch (type2));
865 *len_x = TYPE_LENGTH (type2);
866 decimal_from_integral (arg1, x, *len_x, *byte_order_x);
867 }
868 else
869 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1),
870 TYPE_NAME (type2));
871
872 /* Obtain decimal value of arg2, converting from other types
873 if necessary. */
874
875 if (TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
876 {
877 *byte_order_y = gdbarch_byte_order (get_type_arch (type2));
878 *len_y = TYPE_LENGTH (type2);
879 memcpy (y, value_contents (arg2), *len_y);
880 }
881 else if (is_integral_type (type2))
882 {
883 *byte_order_y = gdbarch_byte_order (get_type_arch (type1));
884 *len_y = TYPE_LENGTH (type1);
885 decimal_from_integral (arg2, y, *len_y, *byte_order_y);
886 }
887 else
888 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1),
889 TYPE_NAME (type2));
890}
891
892/* Perform a binary operation on two operands which have reasonable
893 representations as integers or floats. This includes booleans,
894 characters, integers, or floats.
895 Does not support addition and subtraction on pointers;
896 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
897
898static struct value *
899scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
900{
901 struct value *val;
902 struct type *type1, *type2, *result_type;
903
904 arg1 = coerce_ref (arg1);
905 arg2 = coerce_ref (arg2);
906
907 type1 = check_typedef (value_type (arg1));
908 type2 = check_typedef (value_type (arg2));
909
910 if ((TYPE_CODE (type1) != TYPE_CODE_FLT
911 && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
912 && !is_integral_type (type1))
913 || (TYPE_CODE (type2) != TYPE_CODE_FLT
914 && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
915 && !is_integral_type (type2)))
916 error (_("Argument to arithmetic operation not a number or boolean."));
917
918 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
919 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
920 {
921 int len_v1, len_v2, len_v;
922 enum bfd_endian byte_order_v1, byte_order_v2, byte_order_v;
923 gdb_byte v1[16], v2[16];
924 gdb_byte v[16];
925
926 /* If only one type is decimal float, use its type.
927 Otherwise use the bigger type. */
928 if (TYPE_CODE (type1) != TYPE_CODE_DECFLOAT)
929 result_type = type2;
930 else if (TYPE_CODE (type2) != TYPE_CODE_DECFLOAT)
931 result_type = type1;
932 else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
933 result_type = type2;
934 else
935 result_type = type1;
936
937 len_v = TYPE_LENGTH (result_type);
938 byte_order_v = gdbarch_byte_order (get_type_arch (result_type));
939
940 value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
941 v2, &len_v2, &byte_order_v2);
942
943 switch (op)
944 {
945 case BINOP_ADD:
946 case BINOP_SUB:
947 case BINOP_MUL:
948 case BINOP_DIV:
949 case BINOP_EXP:
950 decimal_binop (op, v1, len_v1, byte_order_v1,
951 v2, len_v2, byte_order_v2,
952 v, len_v, byte_order_v);
953 break;
954
955 default:
956 error (_("Operation not valid for decimal floating point number."));
957 }
958
959 val = value_from_decfloat (result_type, v);
960 }
961 else if (TYPE_CODE (type1) == TYPE_CODE_FLT
962 || TYPE_CODE (type2) == TYPE_CODE_FLT)
963 {
964 /* FIXME-if-picky-about-floating-accuracy: Should be doing this
965 in target format. real.c in GCC probably has the necessary
966 code. */
967 DOUBLEST v1, v2, v = 0;
968
969 v1 = value_as_double (arg1);
970 v2 = value_as_double (arg2);
971
972 switch (op)
973 {
974 case BINOP_ADD:
975 v = v1 + v2;
976 break;
977
978 case BINOP_SUB:
979 v = v1 - v2;
980 break;
981
982 case BINOP_MUL:
983 v = v1 * v2;
984 break;
985
986 case BINOP_DIV:
987 v = v1 / v2;
988 break;
989
990 case BINOP_EXP:
991 errno = 0;
992 v = pow (v1, v2);
993 if (errno)
994 error (_("Cannot perform exponentiation: %s"),
995 safe_strerror (errno));
996 break;
997
998 case BINOP_MIN:
999 v = v1 < v2 ? v1 : v2;
1000 break;
1001
1002 case BINOP_MAX:
1003 v = v1 > v2 ? v1 : v2;
1004 break;
1005
1006 default:
1007 error (_("Integer-only operation on floating point number."));
1008 }
1009
1010 /* If only one type is float, use its type.
1011 Otherwise use the bigger type. */
1012 if (TYPE_CODE (type1) != TYPE_CODE_FLT)
1013 result_type = type2;
1014 else if (TYPE_CODE (type2) != TYPE_CODE_FLT)
1015 result_type = type1;
1016 else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
1017 result_type = type2;
1018 else
1019 result_type = type1;
1020
1021 val = allocate_value (result_type);
1022 store_typed_floating (value_contents_raw (val), value_type (val), v);
1023 }
1024 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
1025 || TYPE_CODE (type2) == TYPE_CODE_BOOL)
1026 {
1027 LONGEST v1, v2, v = 0;
1028
1029 v1 = value_as_long (arg1);
1030 v2 = value_as_long (arg2);
1031
1032 switch (op)
1033 {
1034 case BINOP_BITWISE_AND:
1035 v = v1 & v2;
1036 break;
1037
1038 case BINOP_BITWISE_IOR:
1039 v = v1 | v2;
1040 break;
1041
1042 case BINOP_BITWISE_XOR:
1043 v = v1 ^ v2;
1044 break;
1045
1046 case BINOP_EQUAL:
1047 v = v1 == v2;
1048 break;
1049
1050 case BINOP_NOTEQUAL:
1051 v = v1 != v2;
1052 break;
1053
1054 default:
1055 error (_("Invalid operation on booleans."));
1056 }
1057
1058 result_type = type1;
1059
1060 val = allocate_value (result_type);
1061 store_signed_integer (value_contents_raw (val),
1062 TYPE_LENGTH (result_type),
1063 gdbarch_byte_order (get_type_arch (result_type)),
1064 v);
1065 }
1066 else
1067 /* Integral operations here. */
1068 {
1069 /* Determine type length of the result, and if the operation should
1070 be done unsigned. For exponentiation and shift operators,
1071 use the length and type of the left operand. Otherwise,
1072 use the signedness of the operand with the greater length.
1073 If both operands are of equal length, use unsigned operation
1074 if one of the operands is unsigned. */
1075 if (op == BINOP_RSH || op == BINOP_LSH || op == BINOP_EXP)
1076 result_type = type1;
1077 else if (TYPE_LENGTH (type1) > TYPE_LENGTH (type2))
1078 result_type = type1;
1079 else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
1080 result_type = type2;
1081 else if (TYPE_UNSIGNED (type1))
1082 result_type = type1;
1083 else if (TYPE_UNSIGNED (type2))
1084 result_type = type2;
1085 else
1086 result_type = type1;
1087
1088 if (TYPE_UNSIGNED (result_type))
1089 {
1090 LONGEST v2_signed = value_as_long (arg2);
1091 ULONGEST v1, v2, v = 0;
1092
1093 v1 = (ULONGEST) value_as_long (arg1);
1094 v2 = (ULONGEST) v2_signed;
1095
1096 switch (op)
1097 {
1098 case BINOP_ADD:
1099 v = v1 + v2;
1100 break;
1101
1102 case BINOP_SUB:
1103 v = v1 - v2;
1104 break;
1105
1106 case BINOP_MUL:
1107 v = v1 * v2;
1108 break;
1109
1110 case BINOP_DIV:
1111 case BINOP_INTDIV:
1112 if (v2 != 0)
1113 v = v1 / v2;
1114 else
1115 error (_("Division by zero"));
1116 break;
1117
1118 case BINOP_EXP:
1119 v = uinteger_pow (v1, v2_signed);
1120 break;
1121
1122 case BINOP_REM:
1123 if (v2 != 0)
1124 v = v1 % v2;
1125 else
1126 error (_("Division by zero"));
1127 break;
1128
1129 case BINOP_MOD:
1130 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1131 v1 mod 0 has a defined value, v1. */
1132 if (v2 == 0)
1133 {
1134 v = v1;
1135 }
1136 else
1137 {
1138 v = v1 / v2;
1139 /* Note floor(v1/v2) == v1/v2 for unsigned. */
1140 v = v1 - (v2 * v);
1141 }
1142 break;
1143
1144 case BINOP_LSH:
1145 v = v1 << v2;
1146 break;
1147
1148 case BINOP_RSH:
1149 v = v1 >> v2;
1150 break;
1151
1152 case BINOP_BITWISE_AND:
1153 v = v1 & v2;
1154 break;
1155
1156 case BINOP_BITWISE_IOR:
1157 v = v1 | v2;
1158 break;
1159
1160 case BINOP_BITWISE_XOR:
1161 v = v1 ^ v2;
1162 break;
1163
1164 case BINOP_LOGICAL_AND:
1165 v = v1 && v2;
1166 break;
1167
1168 case BINOP_LOGICAL_OR:
1169 v = v1 || v2;
1170 break;
1171
1172 case BINOP_MIN:
1173 v = v1 < v2 ? v1 : v2;
1174 break;
1175
1176 case BINOP_MAX:
1177 v = v1 > v2 ? v1 : v2;
1178 break;
1179
1180 case BINOP_EQUAL:
1181 v = v1 == v2;
1182 break;
1183
1184 case BINOP_NOTEQUAL:
1185 v = v1 != v2;
1186 break;
1187
1188 case BINOP_LESS:
1189 v = v1 < v2;
1190 break;
1191
1192 case BINOP_GTR:
1193 v = v1 > v2;
1194 break;
1195
1196 case BINOP_LEQ:
1197 v = v1 <= v2;
1198 break;
1199
1200 case BINOP_GEQ:
1201 v = v1 >= v2;
1202 break;
1203
1204 default:
1205 error (_("Invalid binary operation on numbers."));
1206 }
1207
1208 val = allocate_value (result_type);
1209 store_unsigned_integer (value_contents_raw (val),
1210 TYPE_LENGTH (value_type (val)),
1211 gdbarch_byte_order
1212 (get_type_arch (result_type)),
1213 v);
1214 }
1215 else
1216 {
1217 LONGEST v1, v2, v = 0;
1218
1219 v1 = value_as_long (arg1);
1220 v2 = value_as_long (arg2);
1221
1222 switch (op)
1223 {
1224 case BINOP_ADD:
1225 v = v1 + v2;
1226 break;
1227
1228 case BINOP_SUB:
1229 v = v1 - v2;
1230 break;
1231
1232 case BINOP_MUL:
1233 v = v1 * v2;
1234 break;
1235
1236 case BINOP_DIV:
1237 case BINOP_INTDIV:
1238 if (v2 != 0)
1239 v = v1 / v2;
1240 else
1241 error (_("Division by zero"));
1242 break;
1243
1244 case BINOP_EXP:
1245 v = integer_pow (v1, v2);
1246 break;
1247
1248 case BINOP_REM:
1249 if (v2 != 0)
1250 v = v1 % v2;
1251 else
1252 error (_("Division by zero"));
1253 break;
1254
1255 case BINOP_MOD:
1256 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1257 X mod 0 has a defined value, X. */
1258 if (v2 == 0)
1259 {
1260 v = v1;
1261 }
1262 else
1263 {
1264 v = v1 / v2;
1265 /* Compute floor. */
1266 if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0))
1267 {
1268 v--;
1269 }
1270 v = v1 - (v2 * v);
1271 }
1272 break;
1273
1274 case BINOP_LSH:
1275 v = v1 << v2;
1276 break;
1277
1278 case BINOP_RSH:
1279 v = v1 >> v2;
1280 break;
1281
1282 case BINOP_BITWISE_AND:
1283 v = v1 & v2;
1284 break;
1285
1286 case BINOP_BITWISE_IOR:
1287 v = v1 | v2;
1288 break;
1289
1290 case BINOP_BITWISE_XOR:
1291 v = v1 ^ v2;
1292 break;
1293
1294 case BINOP_LOGICAL_AND:
1295 v = v1 && v2;
1296 break;
1297
1298 case BINOP_LOGICAL_OR:
1299 v = v1 || v2;
1300 break;
1301
1302 case BINOP_MIN:
1303 v = v1 < v2 ? v1 : v2;
1304 break;
1305
1306 case BINOP_MAX:
1307 v = v1 > v2 ? v1 : v2;
1308 break;
1309
1310 case BINOP_EQUAL:
1311 v = v1 == v2;
1312 break;
1313
1314 case BINOP_NOTEQUAL:
1315 v = v1 != v2;
1316 break;
1317
1318 case BINOP_LESS:
1319 v = v1 < v2;
1320 break;
1321
1322 case BINOP_GTR:
1323 v = v1 > v2;
1324 break;
1325
1326 case BINOP_LEQ:
1327 v = v1 <= v2;
1328 break;
1329
1330 case BINOP_GEQ:
1331 v = v1 >= v2;
1332 break;
1333
1334 default:
1335 error (_("Invalid binary operation on numbers."));
1336 }
1337
1338 val = allocate_value (result_type);
1339 store_signed_integer (value_contents_raw (val),
1340 TYPE_LENGTH (value_type (val)),
1341 gdbarch_byte_order
1342 (get_type_arch (result_type)),
1343 v);
1344 }
1345 }
1346
1347 return val;
1348}
1349
1350/* Performs a binary operation on two vector operands by calling scalar_binop
1351 for each pair of vector components. */
1352
1353static struct value *
1354vector_binop (struct value *val1, struct value *val2, enum exp_opcode op)
1355{
1356 struct value *val, *tmp, *mark;
1357 struct type *type1, *type2, *eltype1, *eltype2;
1358 int t1_is_vec, t2_is_vec, elsize, i;
1359 LONGEST low_bound1, high_bound1, low_bound2, high_bound2;
1360
1361 type1 = check_typedef (value_type (val1));
1362 type2 = check_typedef (value_type (val2));
1363
1364 t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
1365 && TYPE_VECTOR (type1)) ? 1 : 0;
1366 t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
1367 && TYPE_VECTOR (type2)) ? 1 : 0;
1368
1369 if (!t1_is_vec || !t2_is_vec)
1370 error (_("Vector operations are only supported among vectors"));
1371
1372 if (!get_array_bounds (type1, &low_bound1, &high_bound1)
1373 || !get_array_bounds (type2, &low_bound2, &high_bound2))
1374 error (_("Could not determine the vector bounds"));
1375
1376 eltype1 = check_typedef (TYPE_TARGET_TYPE (type1));
1377 eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
1378 elsize = TYPE_LENGTH (eltype1);
1379
1380 if (TYPE_CODE (eltype1) != TYPE_CODE (eltype2)
1381 || elsize != TYPE_LENGTH (eltype2)
1382 || TYPE_UNSIGNED (eltype1) != TYPE_UNSIGNED (eltype2)
1383 || low_bound1 != low_bound2 || high_bound1 != high_bound2)
1384 error (_("Cannot perform operation on vectors with different types"));
1385
1386 val = allocate_value (type1);
1387 mark = value_mark ();
1388 for (i = 0; i < high_bound1 - low_bound1 + 1; i++)
1389 {
1390 tmp = value_binop (value_subscript (val1, i),
1391 value_subscript (val2, i), op);
1392 memcpy (value_contents_writeable (val) + i * elsize,
1393 value_contents_all (tmp),
1394 elsize);
1395 }
1396 value_free_to_mark (mark);
1397
1398 return val;
1399}
1400
1401/* Perform a binary operation on two operands. */
1402
1403struct value *
1404value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
1405{
1406 struct value *val;
1407 struct type *type1 = check_typedef (value_type (arg1));
1408 struct type *type2 = check_typedef (value_type (arg2));
1409 int t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
1410 && TYPE_VECTOR (type1));
1411 int t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
1412 && TYPE_VECTOR (type2));
1413
1414 if (!t1_is_vec && !t2_is_vec)
1415 val = scalar_binop (arg1, arg2, op);
1416 else if (t1_is_vec && t2_is_vec)
1417 val = vector_binop (arg1, arg2, op);
1418 else
1419 {
1420 /* Widen the scalar operand to a vector. */
1421 struct value **v = t1_is_vec ? &arg2 : &arg1;
1422 struct type *t = t1_is_vec ? type2 : type1;
1423
1424 if (TYPE_CODE (t) != TYPE_CODE_FLT
1425 && TYPE_CODE (t) != TYPE_CODE_DECFLOAT
1426 && !is_integral_type (t))
1427 error (_("Argument to operation not a number or boolean."));
1428
1429 *v = value_cast (t1_is_vec ? type1 : type2, *v);
1430 val = vector_binop (arg1, arg2, op);
1431 }
1432
1433 return val;
1434}
1435\f
1436/* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1437
1438int
1439value_logical_not (struct value *arg1)
1440{
1441 int len;
1442 const gdb_byte *p;
1443 struct type *type1;
1444
1445 arg1 = coerce_array (arg1);
1446 type1 = check_typedef (value_type (arg1));
1447
1448 if (TYPE_CODE (type1) == TYPE_CODE_FLT)
1449 return 0 == value_as_double (arg1);
1450 else if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
1451 return decimal_is_zero (value_contents (arg1), TYPE_LENGTH (type1),
1452 gdbarch_byte_order (get_type_arch (type1)));
1453
1454 len = TYPE_LENGTH (type1);
1455 p = value_contents (arg1);
1456
1457 while (--len >= 0)
1458 {
1459 if (*p++)
1460 break;
1461 }
1462
1463 return len < 0;
1464}
1465
1466/* Perform a comparison on two string values (whose content are not
1467 necessarily null terminated) based on their length. */
1468
1469static int
1470value_strcmp (struct value *arg1, struct value *arg2)
1471{
1472 int len1 = TYPE_LENGTH (value_type (arg1));
1473 int len2 = TYPE_LENGTH (value_type (arg2));
1474 const gdb_byte *s1 = value_contents (arg1);
1475 const gdb_byte *s2 = value_contents (arg2);
1476 int i, len = len1 < len2 ? len1 : len2;
1477
1478 for (i = 0; i < len; i++)
1479 {
1480 if (s1[i] < s2[i])
1481 return -1;
1482 else if (s1[i] > s2[i])
1483 return 1;
1484 else
1485 continue;
1486 }
1487
1488 if (len1 < len2)
1489 return -1;
1490 else if (len1 > len2)
1491 return 1;
1492 else
1493 return 0;
1494}
1495
1496/* Simulate the C operator == by returning a 1
1497 iff ARG1 and ARG2 have equal contents. */
1498
1499int
1500value_equal (struct value *arg1, struct value *arg2)
1501{
1502 int len;
1503 const gdb_byte *p1;
1504 const gdb_byte *p2;
1505 struct type *type1, *type2;
1506 enum type_code code1;
1507 enum type_code code2;
1508 int is_int1, is_int2;
1509
1510 arg1 = coerce_array (arg1);
1511 arg2 = coerce_array (arg2);
1512
1513 type1 = check_typedef (value_type (arg1));
1514 type2 = check_typedef (value_type (arg2));
1515 code1 = TYPE_CODE (type1);
1516 code2 = TYPE_CODE (type2);
1517 is_int1 = is_integral_type (type1);
1518 is_int2 = is_integral_type (type2);
1519
1520 if (is_int1 && is_int2)
1521 return longest_to_int (value_as_long (value_binop (arg1, arg2,
1522 BINOP_EQUAL)));
1523 else if ((code1 == TYPE_CODE_FLT || is_int1)
1524 && (code2 == TYPE_CODE_FLT || is_int2))
1525 {
1526 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1527 `long double' values are returned in static storage (m68k). */
1528 DOUBLEST d = value_as_double (arg1);
1529
1530 return d == value_as_double (arg2);
1531 }
1532 else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
1533 && (code2 == TYPE_CODE_DECFLOAT || is_int2))
1534 {
1535 gdb_byte v1[16], v2[16];
1536 int len_v1, len_v2;
1537 enum bfd_endian byte_order_v1, byte_order_v2;
1538
1539 value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
1540 v2, &len_v2, &byte_order_v2);
1541
1542 return decimal_compare (v1, len_v1, byte_order_v1,
1543 v2, len_v2, byte_order_v2) == 0;
1544 }
1545
1546 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1547 is bigger. */
1548 else if (code1 == TYPE_CODE_PTR && is_int2)
1549 return value_as_address (arg1) == (CORE_ADDR) value_as_long (arg2);
1550 else if (code2 == TYPE_CODE_PTR && is_int1)
1551 return (CORE_ADDR) value_as_long (arg1) == value_as_address (arg2);
1552
1553 else if (code1 == code2
1554 && ((len = (int) TYPE_LENGTH (type1))
1555 == (int) TYPE_LENGTH (type2)))
1556 {
1557 p1 = value_contents (arg1);
1558 p2 = value_contents (arg2);
1559 while (--len >= 0)
1560 {
1561 if (*p1++ != *p2++)
1562 break;
1563 }
1564 return len < 0;
1565 }
1566 else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1567 {
1568 return value_strcmp (arg1, arg2) == 0;
1569 }
1570 else
1571 {
1572 error (_("Invalid type combination in equality test."));
1573 return 0; /* For lint -- never reached. */
1574 }
1575}
1576
1577/* Compare values based on their raw contents. Useful for arrays since
1578 value_equal coerces them to pointers, thus comparing just the address
1579 of the array instead of its contents. */
1580
1581int
1582value_equal_contents (struct value *arg1, struct value *arg2)
1583{
1584 struct type *type1, *type2;
1585
1586 type1 = check_typedef (value_type (arg1));
1587 type2 = check_typedef (value_type (arg2));
1588
1589 return (TYPE_CODE (type1) == TYPE_CODE (type2)
1590 && TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
1591 && memcmp (value_contents (arg1), value_contents (arg2),
1592 TYPE_LENGTH (type1)) == 0);
1593}
1594
1595/* Simulate the C operator < by returning 1
1596 iff ARG1's contents are less than ARG2's. */
1597
1598int
1599value_less (struct value *arg1, struct value *arg2)
1600{
1601 enum type_code code1;
1602 enum type_code code2;
1603 struct type *type1, *type2;
1604 int is_int1, is_int2;
1605
1606 arg1 = coerce_array (arg1);
1607 arg2 = coerce_array (arg2);
1608
1609 type1 = check_typedef (value_type (arg1));
1610 type2 = check_typedef (value_type (arg2));
1611 code1 = TYPE_CODE (type1);
1612 code2 = TYPE_CODE (type2);
1613 is_int1 = is_integral_type (type1);
1614 is_int2 = is_integral_type (type2);
1615
1616 if (is_int1 && is_int2)
1617 return longest_to_int (value_as_long (value_binop (arg1, arg2,
1618 BINOP_LESS)));
1619 else if ((code1 == TYPE_CODE_FLT || is_int1)
1620 && (code2 == TYPE_CODE_FLT || is_int2))
1621 {
1622 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1623 `long double' values are returned in static storage (m68k). */
1624 DOUBLEST d = value_as_double (arg1);
1625
1626 return d < value_as_double (arg2);
1627 }
1628 else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
1629 && (code2 == TYPE_CODE_DECFLOAT || is_int2))
1630 {
1631 gdb_byte v1[16], v2[16];
1632 int len_v1, len_v2;
1633 enum bfd_endian byte_order_v1, byte_order_v2;
1634
1635 value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
1636 v2, &len_v2, &byte_order_v2);
1637
1638 return decimal_compare (v1, len_v1, byte_order_v1,
1639 v2, len_v2, byte_order_v2) == -1;
1640 }
1641 else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
1642 return value_as_address (arg1) < value_as_address (arg2);
1643
1644 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1645 is bigger. */
1646 else if (code1 == TYPE_CODE_PTR && is_int2)
1647 return value_as_address (arg1) < (CORE_ADDR) value_as_long (arg2);
1648 else if (code2 == TYPE_CODE_PTR && is_int1)
1649 return (CORE_ADDR) value_as_long (arg1) < value_as_address (arg2);
1650 else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1651 return value_strcmp (arg1, arg2) < 0;
1652 else
1653 {
1654 error (_("Invalid type combination in ordering comparison."));
1655 return 0;
1656 }
1657}
1658\f
1659/* The unary operators +, - and ~. They free the argument ARG1. */
1660
1661struct value *
1662value_pos (struct value *arg1)
1663{
1664 struct type *type;
1665
1666 arg1 = coerce_ref (arg1);
1667 type = check_typedef (value_type (arg1));
1668
1669 if (TYPE_CODE (type) == TYPE_CODE_FLT)
1670 return value_from_double (type, value_as_double (arg1));
1671 else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1672 return value_from_decfloat (type, value_contents (arg1));
1673 else if (is_integral_type (type))
1674 {
1675 return value_from_longest (type, value_as_long (arg1));
1676 }
1677 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
1678 {
1679 struct value *val = allocate_value (type);
1680
1681 memcpy (value_contents_raw (val), value_contents (arg1),
1682 TYPE_LENGTH (type));
1683 return val;
1684 }
1685 else
1686 {
1687 error (_("Argument to positive operation not a number."));
1688 return 0; /* For lint -- never reached. */
1689 }
1690}
1691
1692struct value *
1693value_neg (struct value *arg1)
1694{
1695 struct type *type;
1696
1697 arg1 = coerce_ref (arg1);
1698 type = check_typedef (value_type (arg1));
1699
1700 if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1701 {
1702 struct value *val = allocate_value (type);
1703 int len = TYPE_LENGTH (type);
1704 gdb_byte decbytes[16]; /* a decfloat is at most 128 bits long. */
1705
1706 memcpy (decbytes, value_contents (arg1), len);
1707
1708 if (gdbarch_byte_order (get_type_arch (type)) == BFD_ENDIAN_LITTLE)
1709 decbytes[len-1] = decbytes[len - 1] | 0x80;
1710 else
1711 decbytes[0] = decbytes[0] | 0x80;
1712
1713 memcpy (value_contents_raw (val), decbytes, len);
1714 return val;
1715 }
1716 else if (TYPE_CODE (type) == TYPE_CODE_FLT)
1717 return value_from_double (type, -value_as_double (arg1));
1718 else if (is_integral_type (type))
1719 {
1720 return value_from_longest (type, -value_as_long (arg1));
1721 }
1722 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
1723 {
1724 struct value *tmp, *val = allocate_value (type);
1725 struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
1726 int i;
1727 LONGEST low_bound, high_bound;
1728
1729 if (!get_array_bounds (type, &low_bound, &high_bound))
1730 error (_("Could not determine the vector bounds"));
1731
1732 for (i = 0; i < high_bound - low_bound + 1; i++)
1733 {
1734 tmp = value_neg (value_subscript (arg1, i));
1735 memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
1736 value_contents_all (tmp), TYPE_LENGTH (eltype));
1737 }
1738 return val;
1739 }
1740 else
1741 {
1742 error (_("Argument to negate operation not a number."));
1743 return 0; /* For lint -- never reached. */
1744 }
1745}
1746
1747struct value *
1748value_complement (struct value *arg1)
1749{
1750 struct type *type;
1751 struct value *val;
1752
1753 arg1 = coerce_ref (arg1);
1754 type = check_typedef (value_type (arg1));
1755
1756 if (is_integral_type (type))
1757 val = value_from_longest (type, ~value_as_long (arg1));
1758 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
1759 {
1760 struct value *tmp;
1761 struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
1762 int i;
1763 LONGEST low_bound, high_bound;
1764
1765 if (!get_array_bounds (type, &low_bound, &high_bound))
1766 error (_("Could not determine the vector bounds"));
1767
1768 val = allocate_value (type);
1769 for (i = 0; i < high_bound - low_bound + 1; i++)
1770 {
1771 tmp = value_complement (value_subscript (arg1, i));
1772 memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
1773 value_contents_all (tmp), TYPE_LENGTH (eltype));
1774 }
1775 }
1776 else
1777 error (_("Argument to complement operation not an integer, boolean."));
1778
1779 return val;
1780}
1781\f
1782/* The INDEX'th bit of SET value whose value_type is TYPE,
1783 and whose value_contents is valaddr.
1784 Return -1 if out of range, -2 other error. */
1785
1786int
1787value_bit_index (struct type *type, const gdb_byte *valaddr, int index)
1788{
1789 struct gdbarch *gdbarch = get_type_arch (type);
1790 LONGEST low_bound, high_bound;
1791 LONGEST word;
1792 unsigned rel_index;
1793 struct type *range = TYPE_INDEX_TYPE (type);
1794
1795 if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
1796 return -2;
1797 if (index < low_bound || index > high_bound)
1798 return -1;
1799 rel_index = index - low_bound;
1800 word = extract_unsigned_integer (valaddr + (rel_index / TARGET_CHAR_BIT), 1,
1801 gdbarch_byte_order (gdbarch));
1802 rel_index %= TARGET_CHAR_BIT;
1803 if (gdbarch_bits_big_endian (gdbarch))
1804 rel_index = TARGET_CHAR_BIT - 1 - rel_index;
1805 return (word >> rel_index) & 1;
1806}
1807
1808int
1809value_in (struct value *element, struct value *set)
1810{
1811 int member;
1812 struct type *settype = check_typedef (value_type (set));
1813 struct type *eltype = check_typedef (value_type (element));
1814
1815 if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
1816 eltype = TYPE_TARGET_TYPE (eltype);
1817 if (TYPE_CODE (settype) != TYPE_CODE_SET)
1818 error (_("Second argument of 'IN' has wrong type"));
1819 if (TYPE_CODE (eltype) != TYPE_CODE_INT
1820 && TYPE_CODE (eltype) != TYPE_CODE_CHAR
1821 && TYPE_CODE (eltype) != TYPE_CODE_ENUM
1822 && TYPE_CODE (eltype) != TYPE_CODE_BOOL)
1823 error (_("First argument of 'IN' has wrong type"));
1824 member = value_bit_index (settype, value_contents (set),
1825 value_as_long (element));
1826 if (member < 0)
1827 error (_("First argument of 'IN' not in range"));
1828 return member;
1829}
1830
1831void
1832_initialize_valarith (void)
1833{
1834}
GDB Binutils - Deliverables
This page took 0.027619 seconds and 4 git commands to generate.