1 /* Perform arithmetic and other operations on values, for GDB.
2
3 Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
5 Foundation, Inc.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
23
24 #include "defs.h"
25 #include "value.h"
26 #include "symtab.h"
27 #include "gdbtypes.h"
28 #include "expression.h"
29 #include "target.h"
30 #include "language.h"
31 #include "gdb_string.h"
32 #include "doublest.h"
33 #include <math.h>
34 #include "infcall.h"
35
36 /* Define whether or not the C operator '/' truncates towards zero for
37 differently signed operands (truncation direction is undefined in C). */
38
39 #ifndef TRUNCATION_TOWARDS_ZERO
40 #define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
41 #endif
42
43 static struct value *value_subscripted_rvalue (struct value *, struct value *, int);
44
45 void _initialize_valarith (void);
46
47
48 /* Given a pointer, return the size of its target.
49 If the pointer type is void *, then return 1.
50 If the target type is incomplete, then error out.
51 This isn't a general purpose function, but just a
52 helper for value_sub & value_add.
53 */
54
55 static LONGEST
find_size_for_pointer_math(struct type * ptr_type)56 find_size_for_pointer_math (struct type *ptr_type)
57 {
58 LONGEST sz = -1;
59 struct type *ptr_target;
60
61 ptr_target = check_typedef (TYPE_TARGET_TYPE (ptr_type));
62
63 sz = TYPE_LENGTH (ptr_target);
64 if (sz == 0)
65 {
66 if (TYPE_CODE (ptr_type) == TYPE_CODE_VOID)
67 sz = 1;
68 else
69 {
70 char *name;
71
72 name = TYPE_NAME (ptr_target);
73 if (name == NULL)
74 name = TYPE_TAG_NAME (ptr_target);
75 if (name == NULL)
76 error ("Cannot perform pointer math on incomplete types, "
77 "try casting to a known type, or void *.");
78 else
79 error ("Cannot perform pointer math on incomplete type \"%s\", "
80 "try casting to a known type, or void *.", name);
81 }
82 }
83 return sz;
84 }
85
86 struct value *
value_add(struct value * arg1,struct value * arg2)87 value_add (struct value *arg1, struct value *arg2)
88 {
89 struct value *valint;
90 struct value *valptr;
91 LONGEST sz;
92 struct type *type1, *type2, *valptrtype;
93
94 COERCE_ARRAY (arg1);
95 COERCE_ARRAY (arg2);
96 type1 = check_typedef (VALUE_TYPE (arg1));
97 type2 = check_typedef (VALUE_TYPE (arg2));
98
99 if ((TYPE_CODE (type1) == TYPE_CODE_PTR
100 || TYPE_CODE (type2) == TYPE_CODE_PTR)
101 &&
102 (is_integral_type (type1) || is_integral_type (type2)))
103 /* Exactly one argument is a pointer, and one is an integer. */
104 {
105 struct value *retval;
106
107 if (TYPE_CODE (type1) == TYPE_CODE_PTR)
108 {
109 valptr = arg1;
110 valint = arg2;
111 valptrtype = type1;
112 }
113 else
114 {
115 valptr = arg2;
116 valint = arg1;
117 valptrtype = type2;
118 }
119
120 sz = find_size_for_pointer_math (valptrtype);
121
122 retval = value_from_pointer (valptrtype,
123 value_as_address (valptr)
124 + (sz * value_as_long (valint)));
125 VALUE_BFD_SECTION (retval) = VALUE_BFD_SECTION (valptr);
126 return retval;
127 }
128
129 return value_binop (arg1, arg2, BINOP_ADD);
130 }
131
132 struct value *
value_sub(struct value * arg1,struct value * arg2)133 value_sub (struct value *arg1, struct value *arg2)
134 {
135 struct type *type1, *type2;
136 COERCE_ARRAY (arg1);
137 COERCE_ARRAY (arg2);
138 type1 = check_typedef (VALUE_TYPE (arg1));
139 type2 = check_typedef (VALUE_TYPE (arg2));
140
141 if (TYPE_CODE (type1) == TYPE_CODE_PTR)
142 {
143 if (is_integral_type (type2))
144 {
145 /* pointer - integer. */
146 LONGEST sz = find_size_for_pointer_math (type1);
147
148 return value_from_pointer (type1,
149 (value_as_address (arg1)
150 - (sz * value_as_long (arg2))));
151 }
152 else if (TYPE_CODE (type2) == TYPE_CODE_PTR
153 && TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)))
154 == TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2))))
155 {
156 /* pointer to <type x> - pointer to <type x>. */
157 LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
158 return value_from_longest
159 (builtin_type_long, /* FIXME -- should be ptrdiff_t */
160 (value_as_long (arg1) - value_as_long (arg2)) / sz);
161 }
162 else
163 {
164 error ("\
165 First argument of `-' is a pointer and second argument is neither\n\
166 an integer nor a pointer of the same type.");
167 }
168 }
169
170 return value_binop (arg1, arg2, BINOP_SUB);
171 }
172
173 /* Return the value of ARRAY[IDX].
174 See comments in value_coerce_array() for rationale for reason for
175 doing lower bounds adjustment here rather than there.
176 FIXME: Perhaps we should validate that the index is valid and if
177 verbosity is set, warn about invalid indices (but still use them). */
178
179 struct value *
value_subscript(struct value * array,struct value * idx)180 value_subscript (struct value *array, struct value *idx)
181 {
182 struct value *bound;
183 int c_style = current_language->c_style_arrays;
184 struct type *tarray;
185
186 COERCE_REF (array);
187 tarray = check_typedef (VALUE_TYPE (array));
188 COERCE_VARYING_ARRAY (array, tarray);
189
190 if (TYPE_CODE (tarray) == TYPE_CODE_ARRAY
191 || TYPE_CODE (tarray) == TYPE_CODE_STRING)
192 {
193 struct type *range_type = TYPE_INDEX_TYPE (tarray);
194 LONGEST lowerbound, upperbound;
195 get_discrete_bounds (range_type, &lowerbound, &upperbound);
196
197 if (VALUE_LVAL (array) != lval_memory)
198 return value_subscripted_rvalue (array, idx, lowerbound);
199
200 if (c_style == 0)
201 {
202 LONGEST index = value_as_long (idx);
203 if (index >= lowerbound && index <= upperbound)
204 return value_subscripted_rvalue (array, idx, lowerbound);
205 /* Emit warning unless we have an array of unknown size.
206 An array of unknown size has lowerbound 0 and upperbound -1. */
207 if (upperbound > -1)
208 warning ("array or string index out of range");
209 /* fall doing C stuff */
210 c_style = 1;
211 }
212
213 if (lowerbound != 0)
214 {
215 bound = value_from_longest (builtin_type_int, (LONGEST) lowerbound);
216 idx = value_sub (idx, bound);
217 }
218
219 array = value_coerce_array (array);
220 }
221
222 if (TYPE_CODE (tarray) == TYPE_CODE_BITSTRING)
223 {
224 struct type *range_type = TYPE_INDEX_TYPE (tarray);
225 LONGEST index = value_as_long (idx);
226 struct value *v;
227 int offset, byte, bit_index;
228 LONGEST lowerbound, upperbound;
229 get_discrete_bounds (range_type, &lowerbound, &upperbound);
230 if (index < lowerbound || index > upperbound)
231 error ("bitstring index out of range");
232 index -= lowerbound;
233 offset = index / TARGET_CHAR_BIT;
234 byte = *((char *) VALUE_CONTENTS (array) + offset);
235 bit_index = index % TARGET_CHAR_BIT;
236 byte >>= (BITS_BIG_ENDIAN ? TARGET_CHAR_BIT - 1 - bit_index : bit_index);
237 v = value_from_longest (LA_BOOL_TYPE, byte & 1);
238 VALUE_BITPOS (v) = bit_index;
239 VALUE_BITSIZE (v) = 1;
240 VALUE_LVAL (v) = VALUE_LVAL (array);
241 if (VALUE_LVAL (array) == lval_internalvar)
242 VALUE_LVAL (v) = lval_internalvar_component;
243 VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
244 VALUE_OFFSET (v) = offset + VALUE_OFFSET (array);
245 return v;
246 }
247
248 if (c_style)
249 return value_ind (value_add (array, idx));
250 else
251 error ("not an array or string");
252 }
253
254 /* Return the value of EXPR[IDX], expr an aggregate rvalue
255 (eg, a vector register). This routine used to promote floats
256 to doubles, but no longer does. */
257
258 static struct value *
value_subscripted_rvalue(struct value * array,struct value * idx,int lowerbound)259 value_subscripted_rvalue (struct value *array, struct value *idx, int lowerbound)
260 {
261 struct type *array_type = check_typedef (VALUE_TYPE (array));
262 struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
263 unsigned int elt_size = TYPE_LENGTH (elt_type);
264 LONGEST index = value_as_long (idx);
265 unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
266 struct value *v;
267
268 if (index < lowerbound || elt_offs >= TYPE_LENGTH (array_type))
269 error ("no such vector element");
270
271 v = allocate_value (elt_type);
272 if (VALUE_LAZY (array))
273 VALUE_LAZY (v) = 1;
274 else
275 memcpy (VALUE_CONTENTS (v), VALUE_CONTENTS (array) + elt_offs, elt_size);
276
277 if (VALUE_LVAL (array) == lval_internalvar)
278 VALUE_LVAL (v) = lval_internalvar_component;
279 else
280 VALUE_LVAL (v) = VALUE_LVAL (array);
281 VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
282 VALUE_REGNO (v) = VALUE_REGNO (array);
283 VALUE_OFFSET (v) = VALUE_OFFSET (array) + elt_offs;
284 return v;
285 }
286
287 /* Check to see if either argument is a structure. This is called so
288 we know whether to go ahead with the normal binop or look for a
289 user defined function instead.
290
291 For now, we do not overload the `=' operator. */
292
293 int
binop_user_defined_p(enum exp_opcode op,struct value * arg1,struct value * arg2)294 binop_user_defined_p (enum exp_opcode op, struct value *arg1, struct value *arg2)
295 {
296 struct type *type1, *type2;
297 if (op == BINOP_ASSIGN || op == BINOP_CONCAT)
298 return 0;
299 type1 = check_typedef (VALUE_TYPE (arg1));
300 type2 = check_typedef (VALUE_TYPE (arg2));
301 return (TYPE_CODE (type1) == TYPE_CODE_STRUCT
302 || TYPE_CODE (type2) == TYPE_CODE_STRUCT
303 || (TYPE_CODE (type1) == TYPE_CODE_REF
304 && TYPE_CODE (TYPE_TARGET_TYPE (type1)) == TYPE_CODE_STRUCT)
305 || (TYPE_CODE (type2) == TYPE_CODE_REF
306 && TYPE_CODE (TYPE_TARGET_TYPE (type2)) == TYPE_CODE_STRUCT));
307 }
308
309 /* Check to see if argument is a structure. This is called so
310 we know whether to go ahead with the normal unop or look for a
311 user defined function instead.
312
313 For now, we do not overload the `&' operator. */
314
315 int
unop_user_defined_p(enum exp_opcode op,struct value * arg1)316 unop_user_defined_p (enum exp_opcode op, struct value *arg1)
317 {
318 struct type *type1;
319 if (op == UNOP_ADDR)
320 return 0;
321 type1 = check_typedef (VALUE_TYPE (arg1));
322 for (;;)
323 {
324 if (TYPE_CODE (type1) == TYPE_CODE_STRUCT)
325 return 1;
326 else if (TYPE_CODE (type1) == TYPE_CODE_REF)
327 type1 = TYPE_TARGET_TYPE (type1);
328 else
329 return 0;
330 }
331 }
332
333 /* We know either arg1 or arg2 is a structure, so try to find the right
334 user defined function. Create an argument vector that calls
335 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
336 binary operator which is legal for GNU C++).
337
338 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
339 is the opcode saying how to modify it. Otherwise, OTHEROP is
340 unused. */
341
342 struct value *
value_x_binop(struct value * arg1,struct value * arg2,enum exp_opcode op,enum exp_opcode otherop,enum noside noside)343 value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
344 enum exp_opcode otherop, enum noside noside)
345 {
346 struct value **argvec;
347 char *ptr;
348 char tstr[13];
349 int static_memfuncp;
350
351 COERCE_REF (arg1);
352 COERCE_REF (arg2);
353 COERCE_ENUM (arg1);
354 COERCE_ENUM (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_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure");
476
477 if (argvec[0])
478 {
479 if (static_memfuncp)
480 {
481 argvec[1] = argvec[0];
482 argvec++;
483 }
484 if (noside == EVAL_AVOID_SIDE_EFFECTS)
485 {
486 struct type *return_type;
487 return_type
488 = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (argvec[0])));
489 return value_zero (return_type, VALUE_LVAL (arg1));
490 }
491 return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
492 }
493 error ("member function %s not found", tstr);
494 #ifdef lint
495 return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
496 #endif
497 }
498
499 /* We know that arg1 is a structure, so try to find a unary user
500 defined operator that matches the operator in question.
501 Create an argument vector that calls arg1.operator @ (arg1)
502 and return that value (where '@' is (almost) any unary operator which
503 is legal for GNU C++). */
504
505 struct value *
value_x_unop(struct value * arg1,enum exp_opcode op,enum noside noside)506 value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
507 {
508 struct value **argvec;
509 char *ptr, *mangle_ptr;
510 char tstr[13], mangle_tstr[13];
511 int static_memfuncp, nargs;
512
513 COERCE_REF (arg1);
514 COERCE_ENUM (arg1);
515
516 /* now we know that what we have to do is construct our
517 arg vector and find the right function to call it with. */
518
519 if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_STRUCT)
520 error ("Can't do that unary op on that type"); /* FIXME be explicit */
521
522 argvec = (struct value **) alloca (sizeof (struct value *) * 4);
523 argvec[1] = value_addr (arg1);
524 argvec[2] = 0;
525
526 nargs = 1;
527
528 /* make the right function name up */
529 strcpy (tstr, "operator__");
530 ptr = tstr + 8;
531 strcpy (mangle_tstr, "__");
532 mangle_ptr = mangle_tstr + 2;
533 switch (op)
534 {
535 case UNOP_PREINCREMENT:
536 strcpy (ptr, "++");
537 break;
538 case UNOP_PREDECREMENT:
539 strcpy (ptr, "--");
540 break;
541 case UNOP_POSTINCREMENT:
542 strcpy (ptr, "++");
543 argvec[2] = value_from_longest (builtin_type_int, 0);
544 argvec[3] = 0;
545 nargs ++;
546 break;
547 case UNOP_POSTDECREMENT:
548 strcpy (ptr, "--");
549 argvec[2] = value_from_longest (builtin_type_int, 0);
550 argvec[3] = 0;
551 nargs ++;
552 break;
553 case UNOP_LOGICAL_NOT:
554 strcpy (ptr, "!");
555 break;
556 case UNOP_COMPLEMENT:
557 strcpy (ptr, "~");
558 break;
559 case UNOP_NEG:
560 strcpy (ptr, "-");
561 break;
562 case UNOP_IND:
563 strcpy (ptr, "*");
564 break;
565 default:
566 error ("Invalid unary operation specified.");
567 }
568
569 argvec[0] = value_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure");
570
571 if (argvec[0])
572 {
573 if (static_memfuncp)
574 {
575 argvec[1] = argvec[0];
576 nargs --;
577 argvec++;
578 }
579 if (noside == EVAL_AVOID_SIDE_EFFECTS)
580 {
581 struct type *return_type;
582 return_type
583 = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (argvec[0])));
584 return value_zero (return_type, VALUE_LVAL (arg1));
585 }
586 return call_function_by_hand (argvec[0], nargs, argvec + 1);
587 }
588 error ("member function %s not found", tstr);
589 return 0; /* For lint -- never reached */
590 }
591
592
593 /* Concatenate two values with the following conditions:
594
595 (1) Both values must be either bitstring values or character string
596 values and the resulting value consists of the concatenation of
597 ARG1 followed by ARG2.
598
599 or
600
601 One value must be an integer value and the other value must be
602 either a bitstring value or character string value, which is
603 to be repeated by the number of times specified by the integer
604 value.
605
606
607 (2) Boolean values are also allowed and are treated as bit string
608 values of length 1.
609
610 (3) Character values are also allowed and are treated as character
611 string values of length 1.
612 */
613
614 struct value *
value_concat(struct value * arg1,struct value * arg2)615 value_concat (struct value *arg1, struct value *arg2)
616 {
617 struct value *inval1;
618 struct value *inval2;
619 struct value *outval = NULL;
620 int inval1len, inval2len;
621 int count, idx;
622 char *ptr;
623 char inchar;
624 struct type *type1 = check_typedef (VALUE_TYPE (arg1));
625 struct type *type2 = check_typedef (VALUE_TYPE (arg2));
626
627 COERCE_VARYING_ARRAY (arg1, type1);
628 COERCE_VARYING_ARRAY (arg2, type2);
629
630 /* First figure out if we are dealing with two values to be concatenated
631 or a repeat count and a value to be repeated. INVAL1 is set to the
632 first of two concatenated values, or the repeat count. INVAL2 is set
633 to the second of the two concatenated values or the value to be
634 repeated. */
635
636 if (TYPE_CODE (type2) == TYPE_CODE_INT)
637 {
638 struct type *tmp = type1;
639 type1 = tmp;
640 tmp = type2;
641 inval1 = arg2;
642 inval2 = arg1;
643 }
644 else
645 {
646 inval1 = arg1;
647 inval2 = arg2;
648 }
649
650 /* Now process the input values. */
651
652 if (TYPE_CODE (type1) == TYPE_CODE_INT)
653 {
654 /* We have a repeat count. Validate the second value and then
655 construct a value repeated that many times. */
656 if (TYPE_CODE (type2) == TYPE_CODE_STRING
657 || TYPE_CODE (type2) == TYPE_CODE_CHAR)
658 {
659 count = longest_to_int (value_as_long (inval1));
660 inval2len = TYPE_LENGTH (type2);
661 ptr = (char *) alloca (count * inval2len);
662 if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
663 {
664 inchar = (char) unpack_long (type2,
665 VALUE_CONTENTS (inval2));
666 for (idx = 0; idx < count; idx++)
667 {
668 *(ptr + idx) = inchar;
669 }
670 }
671 else
672 {
673 for (idx = 0; idx < count; idx++)
674 {
675 memcpy (ptr + (idx * inval2len), VALUE_CONTENTS (inval2),
676 inval2len);
677 }
678 }
679 outval = value_string (ptr, count * inval2len);
680 }
681 else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING
682 || TYPE_CODE (type2) == TYPE_CODE_BOOL)
683 {
684 error ("unimplemented support for bitstring/boolean repeats");
685 }
686 else
687 {
688 error ("can't repeat values of that type");
689 }
690 }
691 else if (TYPE_CODE (type1) == TYPE_CODE_STRING
692 || TYPE_CODE (type1) == TYPE_CODE_CHAR)
693 {
694 /* We have two character strings to concatenate. */
695 if (TYPE_CODE (type2) != TYPE_CODE_STRING
696 && TYPE_CODE (type2) != TYPE_CODE_CHAR)
697 {
698 error ("Strings can only be concatenated with other strings.");
699 }
700 inval1len = TYPE_LENGTH (type1);
701 inval2len = TYPE_LENGTH (type2);
702 ptr = (char *) alloca (inval1len + inval2len);
703 if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
704 {
705 *ptr = (char) unpack_long (type1, VALUE_CONTENTS (inval1));
706 }
707 else
708 {
709 memcpy (ptr, VALUE_CONTENTS (inval1), inval1len);
710 }
711 if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
712 {
713 *(ptr + inval1len) =
714 (char) unpack_long (type2, VALUE_CONTENTS (inval2));
715 }
716 else
717 {
718 memcpy (ptr + inval1len, VALUE_CONTENTS (inval2), inval2len);
719 }
720 outval = value_string (ptr, inval1len + inval2len);
721 }
722 else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING
723 || TYPE_CODE (type1) == TYPE_CODE_BOOL)
724 {
725 /* We have two bitstrings to concatenate. */
726 if (TYPE_CODE (type2) != TYPE_CODE_BITSTRING
727 && TYPE_CODE (type2) != TYPE_CODE_BOOL)
728 {
729 error ("Bitstrings or booleans can only be concatenated with other bitstrings or booleans.");
730 }
731 error ("unimplemented support for bitstring/boolean concatenation.");
732 }
733 else
734 {
735 /* We don't know how to concatenate these operands. */
736 error ("illegal operands for concatenation.");
737 }
738 return (outval);
739 }
740
741
742
743 /* Perform a binary operation on two operands which have reasonable
744 representations as integers or floats. This includes booleans,
745 characters, integers, or floats.
746 Does not support addition and subtraction on pointers;
747 use value_add or value_sub if you want to handle those possibilities. */
748
749 struct value *
value_binop(struct value * arg1,struct value * arg2,enum exp_opcode op)750 value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
751 {
752 struct value *val;
753 struct type *type1, *type2;
754
755 COERCE_REF (arg1);
756 COERCE_REF (arg2);
757 type1 = check_typedef (VALUE_TYPE (arg1));
758 type2 = check_typedef (VALUE_TYPE (arg2));
759
760 if ((TYPE_CODE (type1) != TYPE_CODE_FLT && !is_integral_type (type1))
761 ||
762 (TYPE_CODE (type2) != TYPE_CODE_FLT && !is_integral_type (type2)))
763 error ("Argument to arithmetic operation not a number or boolean.");
764
765 if (TYPE_CODE (type1) == TYPE_CODE_FLT
766 ||
767 TYPE_CODE (type2) == TYPE_CODE_FLT)
768 {
769 /* FIXME-if-picky-about-floating-accuracy: Should be doing this
770 in target format. real.c in GCC probably has the necessary
771 code. */
772 DOUBLEST v1, v2, v = 0;
773 v1 = value_as_double (arg1);
774 v2 = value_as_double (arg2);
775 switch (op)
776 {
777 case BINOP_ADD:
778 v = v1 + v2;
779 break;
780
781 case BINOP_SUB:
782 v = v1 - v2;
783 break;
784
785 case BINOP_MUL:
786 v = v1 * v2;
787 break;
788
789 case BINOP_DIV:
790 v = v1 / v2;
791 break;
792
793 case BINOP_EXP:
794 v = pow (v1, v2);
795 if (errno)
796 error ("Cannot perform exponentiation: %s", safe_strerror (errno));
797 break;
798
799 default:
800 error ("Integer-only operation on floating point number.");
801 }
802
803 /* If either arg was long double, make sure that value is also long
804 double. */
805
806 if (TYPE_LENGTH (type1) * 8 > TARGET_DOUBLE_BIT
807 || TYPE_LENGTH (type2) * 8 > TARGET_DOUBLE_BIT)
808 val = allocate_value (builtin_type_long_double);
809 else
810 val = allocate_value (builtin_type_double);
811
812 store_typed_floating (VALUE_CONTENTS_RAW (val), VALUE_TYPE (val), v);
813 }
814 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
815 &&
816 TYPE_CODE (type2) == TYPE_CODE_BOOL)
817 {
818 LONGEST v1, v2, v = 0;
819 v1 = value_as_long (arg1);
820 v2 = value_as_long (arg2);
821
822 switch (op)
823 {
824 case BINOP_BITWISE_AND:
825 v = v1 & v2;
826 break;
827
828 case BINOP_BITWISE_IOR:
829 v = v1 | v2;
830 break;
831
832 case BINOP_BITWISE_XOR:
833 v = v1 ^ v2;
834 break;
835
836 case BINOP_EQUAL:
837 v = v1 == v2;
838 break;
839
840 case BINOP_NOTEQUAL:
841 v = v1 != v2;
842 break;
843
844 default:
845 error ("Invalid operation on booleans.");
846 }
847
848 val = allocate_value (type1);
849 store_signed_integer (VALUE_CONTENTS_RAW (val),
850 TYPE_LENGTH (type1),
851 v);
852 }
853 else
854 /* Integral operations here. */
855 /* FIXME: Also mixed integral/booleans, with result an integer. */
856 /* FIXME: This implements ANSI C rules (also correct for C++).
857 What about FORTRAN and (the deleted) chill ? */
858 {
859 unsigned int promoted_len1 = TYPE_LENGTH (type1);
860 unsigned int promoted_len2 = TYPE_LENGTH (type2);
861 int is_unsigned1 = TYPE_UNSIGNED (type1);
862 int is_unsigned2 = TYPE_UNSIGNED (type2);
863 unsigned int result_len;
864 int unsigned_operation;
865
866 /* Determine type length and signedness after promotion for
867 both operands. */
868 if (promoted_len1 < TYPE_LENGTH (builtin_type_int))
869 {
870 is_unsigned1 = 0;
871 promoted_len1 = TYPE_LENGTH (builtin_type_int);
872 }
873 if (promoted_len2 < TYPE_LENGTH (builtin_type_int))
874 {
875 is_unsigned2 = 0;
876 promoted_len2 = TYPE_LENGTH (builtin_type_int);
877 }
878
879 /* Determine type length of the result, and if the operation should
880 be done unsigned.
881 Use the signedness of the operand with the greater length.
882 If both operands are of equal length, use unsigned operation
883 if one of the operands is unsigned. */
884 if (promoted_len1 > promoted_len2)
885 {
886 unsigned_operation = is_unsigned1;
887 result_len = promoted_len1;
888 }
889 else if (promoted_len2 > promoted_len1)
890 {
891 unsigned_operation = is_unsigned2;
892 result_len = promoted_len2;
893 }
894 else
895 {
896 unsigned_operation = is_unsigned1 || is_unsigned2;
897 result_len = promoted_len1;
898 }
899
900 if (unsigned_operation)
901 {
902 ULONGEST v1, v2, v = 0;
903 v1 = (ULONGEST) value_as_long (arg1);
904 v2 = (ULONGEST) value_as_long (arg2);
905
906 /* Truncate values to the type length of the result. */
907 if (result_len < sizeof (ULONGEST))
908 {
909 v1 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1;
910 v2 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1;
911 }
912
913 switch (op)
914 {
915 case BINOP_ADD:
916 v = v1 + v2;
917 break;
918
919 case BINOP_SUB:
920 v = v1 - v2;
921 break;
922
923 case BINOP_MUL:
924 v = v1 * v2;
925 break;
926
927 case BINOP_DIV:
928 v = v1 / v2;
929 break;
930
931 case BINOP_EXP:
932 v = pow (v1, v2);
933 if (errno)
934 error ("Cannot perform exponentiation: %s", safe_strerror (errno));
935 break;
936
937 case BINOP_REM:
938 v = v1 % v2;
939 break;
940
941 case BINOP_MOD:
942 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
943 v1 mod 0 has a defined value, v1. */
944 if (v2 == 0)
945 {
946 v = v1;
947 }
948 else
949 {
950 v = v1 / v2;
951 /* Note floor(v1/v2) == v1/v2 for unsigned. */
952 v = v1 - (v2 * v);
953 }
954 break;
955
956 case BINOP_LSH:
957 v = v1 << v2;
958 break;
959
960 case BINOP_RSH:
961 v = v1 >> v2;
962 break;
963
964 case BINOP_BITWISE_AND:
965 v = v1 & v2;
966 break;
967
968 case BINOP_BITWISE_IOR:
969 v = v1 | v2;
970 break;
971
972 case BINOP_BITWISE_XOR:
973 v = v1 ^ v2;
974 break;
975
976 case BINOP_LOGICAL_AND:
977 v = v1 && v2;
978 break;
979
980 case BINOP_LOGICAL_OR:
981 v = v1 || v2;
982 break;
983
984 case BINOP_MIN:
985 v = v1 < v2 ? v1 : v2;
986 break;
987
988 case BINOP_MAX:
989 v = v1 > v2 ? v1 : v2;
990 break;
991
992 case BINOP_EQUAL:
993 v = v1 == v2;
994 break;
995
996 case BINOP_NOTEQUAL:
997 v = v1 != v2;
998 break;
999
1000 case BINOP_LESS:
1001 v = v1 < v2;
1002 break;
1003
1004 default:
1005 error ("Invalid binary operation on numbers.");
1006 }
1007
1008 /* This is a kludge to get around the fact that we don't
1009 know how to determine the result type from the types of
1010 the operands. (I'm not really sure how much we feel the
1011 need to duplicate the exact rules of the current
1012 language. They can get really hairy. But not to do so
1013 makes it hard to document just what we *do* do). */
1014
1015 /* Can't just call init_type because we wouldn't know what
1016 name to give the type. */
1017 val = allocate_value
1018 (result_len > TARGET_LONG_BIT / HOST_CHAR_BIT
1019 ? builtin_type_unsigned_long_long
1020 : builtin_type_unsigned_long);
1021 store_unsigned_integer (VALUE_CONTENTS_RAW (val),
1022 TYPE_LENGTH (VALUE_TYPE (val)),
1023 v);
1024 }
1025 else
1026 {
1027 LONGEST v1, v2, v = 0;
1028 v1 = value_as_long (arg1);
1029 v2 = value_as_long (arg2);
1030
1031 switch (op)
1032 {
1033 case BINOP_ADD:
1034 v = v1 + v2;
1035 break;
1036
1037 case BINOP_SUB:
1038 v = v1 - v2;
1039 break;
1040
1041 case BINOP_MUL:
1042 v = v1 * v2;
1043 break;
1044
1045 case BINOP_DIV:
1046 if (v2 != 0)
1047 v = v1 / v2;
1048 else
1049 error ("Division by zero");
1050 break;
1051
1052 case BINOP_EXP:
1053 v = pow (v1, v2);
1054 if (errno)
1055 error ("Cannot perform exponentiation: %s", safe_strerror (errno));
1056 break;
1057
1058 case BINOP_REM:
1059 if (v2 != 0)
1060 v = v1 % v2;
1061 else
1062 error ("Division by zero");
1063 break;
1064
1065 case BINOP_MOD:
1066 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
1067 X mod 0 has a defined value, X. */
1068 if (v2 == 0)
1069 {
1070 v = v1;
1071 }
1072 else
1073 {
1074 v = v1 / v2;
1075 /* Compute floor. */
1076 if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0))
1077 {
1078 v--;
1079 }
1080 v = v1 - (v2 * v);
1081 }
1082 break;
1083
1084 case BINOP_LSH:
1085 v = v1 << v2;
1086 break;
1087
1088 case BINOP_RSH:
1089 v = v1 >> v2;
1090 break;
1091
1092 case BINOP_BITWISE_AND:
1093 v = v1 & v2;
1094 break;
1095
1096 case BINOP_BITWISE_IOR:
1097 v = v1 | v2;
1098 break;
1099
1100 case BINOP_BITWISE_XOR:
1101 v = v1 ^ v2;
1102 break;
1103
1104 case BINOP_LOGICAL_AND:
1105 v = v1 && v2;
1106 break;
1107
1108 case BINOP_LOGICAL_OR:
1109 v = v1 || v2;
1110 break;
1111
1112 case BINOP_MIN:
1113 v = v1 < v2 ? v1 : v2;
1114 break;
1115
1116 case BINOP_MAX:
1117 v = v1 > v2 ? v1 : v2;
1118 break;
1119
1120 case BINOP_EQUAL:
1121 v = v1 == v2;
1122 break;
1123
1124 case BINOP_LESS:
1125 v = v1 < v2;
1126 break;
1127
1128 default:
1129 error ("Invalid binary operation on numbers.");
1130 }
1131
1132 /* This is a kludge to get around the fact that we don't
1133 know how to determine the result type from the types of
1134 the operands. (I'm not really sure how much we feel the
1135 need to duplicate the exact rules of the current
1136 language. They can get really hairy. But not to do so
1137 makes it hard to document just what we *do* do). */
1138
1139 /* Can't just call init_type because we wouldn't know what
1140 name to give the type. */
1141 val = allocate_value
1142 (result_len > TARGET_LONG_BIT / HOST_CHAR_BIT
1143 ? builtin_type_long_long
1144 : builtin_type_long);
1145 store_signed_integer (VALUE_CONTENTS_RAW (val),
1146 TYPE_LENGTH (VALUE_TYPE (val)),
1147 v);
1148 }
1149 }
1150
1151 return val;
1152 }
1153
1154 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
1155
1156 int
value_logical_not(struct value * arg1)1157 value_logical_not (struct value *arg1)
1158 {
1159 int len;
1160 char *p;
1161 struct type *type1;
1162
1163 COERCE_NUMBER (arg1);
1164 type1 = check_typedef (VALUE_TYPE (arg1));
1165
1166 if (TYPE_CODE (type1) == TYPE_CODE_FLT)
1167 return 0 == value_as_double (arg1);
1168
1169 len = TYPE_LENGTH (type1);
1170 p = VALUE_CONTENTS (arg1);
1171
1172 while (--len >= 0)
1173 {
1174 if (*p++)
1175 break;
1176 }
1177
1178 return len < 0;
1179 }
1180
1181 /* Perform a comparison on two string values (whose content are not
1182 necessarily null terminated) based on their length */
1183
1184 static int
value_strcmp(struct value * arg1,struct value * arg2)1185 value_strcmp (struct value *arg1, struct value *arg2)
1186 {
1187 int len1 = TYPE_LENGTH (VALUE_TYPE (arg1));
1188 int len2 = TYPE_LENGTH (VALUE_TYPE (arg2));
1189 char *s1 = VALUE_CONTENTS (arg1);
1190 char *s2 = VALUE_CONTENTS (arg2);
1191 int i, len = len1 < len2 ? len1 : len2;
1192
1193 for (i = 0; i < len; i++)
1194 {
1195 if (s1[i] < s2[i])
1196 return -1;
1197 else if (s1[i] > s2[i])
1198 return 1;
1199 else
1200 continue;
1201 }
1202
1203 if (len1 < len2)
1204 return -1;
1205 else if (len1 > len2)
1206 return 1;
1207 else
1208 return 0;
1209 }
1210
1211 /* Simulate the C operator == by returning a 1
1212 iff ARG1 and ARG2 have equal contents. */
1213
1214 int
value_equal(struct value * arg1,struct value * arg2)1215 value_equal (struct value *arg1, struct value *arg2)
1216 {
1217 int len;
1218 char *p1, *p2;
1219 struct type *type1, *type2;
1220 enum type_code code1;
1221 enum type_code code2;
1222 int is_int1, is_int2;
1223
1224 COERCE_ARRAY (arg1);
1225 COERCE_ARRAY (arg2);
1226
1227 type1 = check_typedef (VALUE_TYPE (arg1));
1228 type2 = check_typedef (VALUE_TYPE (arg2));
1229 code1 = TYPE_CODE (type1);
1230 code2 = TYPE_CODE (type2);
1231 is_int1 = is_integral_type (type1);
1232 is_int2 = is_integral_type (type2);
1233
1234 if (is_int1 && is_int2)
1235 return longest_to_int (value_as_long (value_binop (arg1, arg2,
1236 BINOP_EQUAL)));
1237 else if ((code1 == TYPE_CODE_FLT || is_int1)
1238 && (code2 == TYPE_CODE_FLT || is_int2))
1239 return value_as_double (arg1) == value_as_double (arg2);
1240
1241 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1242 is bigger. */
1243 else if (code1 == TYPE_CODE_PTR && is_int2)
1244 return value_as_address (arg1) == (CORE_ADDR) value_as_long (arg2);
1245 else if (code2 == TYPE_CODE_PTR && is_int1)
1246 return (CORE_ADDR) value_as_long (arg1) == value_as_address (arg2);
1247
1248 else if (code1 == code2
1249 && ((len = (int) TYPE_LENGTH (type1))
1250 == (int) TYPE_LENGTH (type2)))
1251 {
1252 p1 = VALUE_CONTENTS (arg1);
1253 p2 = VALUE_CONTENTS (arg2);
1254 while (--len >= 0)
1255 {
1256 if (*p1++ != *p2++)
1257 break;
1258 }
1259 return len < 0;
1260 }
1261 else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1262 {
1263 return value_strcmp (arg1, arg2) == 0;
1264 }
1265 else
1266 {
1267 error ("Invalid type combination in equality test.");
1268 return 0; /* For lint -- never reached */
1269 }
1270 }
1271
1272 /* Simulate the C operator < by returning 1
1273 iff ARG1's contents are less than ARG2's. */
1274
1275 int
value_less(struct value * arg1,struct value * arg2)1276 value_less (struct value *arg1, struct value *arg2)
1277 {
1278 enum type_code code1;
1279 enum type_code code2;
1280 struct type *type1, *type2;
1281 int is_int1, is_int2;
1282
1283 COERCE_ARRAY (arg1);
1284 COERCE_ARRAY (arg2);
1285
1286 type1 = check_typedef (VALUE_TYPE (arg1));
1287 type2 = check_typedef (VALUE_TYPE (arg2));
1288 code1 = TYPE_CODE (type1);
1289 code2 = TYPE_CODE (type2);
1290 is_int1 = is_integral_type (type1);
1291 is_int2 = is_integral_type (type2);
1292
1293 if (is_int1 && is_int2)
1294 return longest_to_int (value_as_long (value_binop (arg1, arg2,
1295 BINOP_LESS)));
1296 else if ((code1 == TYPE_CODE_FLT || is_int1)
1297 && (code2 == TYPE_CODE_FLT || is_int2))
1298 return value_as_double (arg1) < value_as_double (arg2);
1299 else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
1300 return value_as_address (arg1) < value_as_address (arg2);
1301
1302 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1303 is bigger. */
1304 else if (code1 == TYPE_CODE_PTR && is_int2)
1305 return value_as_address (arg1) < (CORE_ADDR) value_as_long (arg2);
1306 else if (code2 == TYPE_CODE_PTR && is_int1)
1307 return (CORE_ADDR) value_as_long (arg1) < value_as_address (arg2);
1308 else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1309 return value_strcmp (arg1, arg2) < 0;
1310 else
1311 {
1312 error ("Invalid type combination in ordering comparison.");
1313 return 0;
1314 }
1315 }
1316
1317 /* The unary operators - and ~. Both free the argument ARG1. */
1318
1319 struct value *
value_neg(struct value * arg1)1320 value_neg (struct value *arg1)
1321 {
1322 struct type *type;
1323 struct type *result_type = VALUE_TYPE (arg1);
1324
1325 COERCE_REF (arg1);
1326
1327 type = check_typedef (VALUE_TYPE (arg1));
1328
1329 if (TYPE_CODE (type) == TYPE_CODE_FLT)
1330 return value_from_double (result_type, -value_as_double (arg1));
1331 else if (is_integral_type (type))
1332 {
1333 /* Perform integral promotion for ANSI C/C++. FIXME: What about
1334 FORTRAN and (the deleted) chill ? */
1335 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1336 result_type = builtin_type_int;
1337
1338 return value_from_longest (result_type, -value_as_long (arg1));
1339 }
1340 else
1341 {
1342 error ("Argument to negate operation not a number.");
1343 return 0; /* For lint -- never reached */
1344 }
1345 }
1346
1347 struct value *
value_complement(struct value * arg1)1348 value_complement (struct value *arg1)
1349 {
1350 struct type *type;
1351 struct type *result_type = VALUE_TYPE (arg1);
1352
1353 COERCE_REF (arg1);
1354
1355 type = check_typedef (VALUE_TYPE (arg1));
1356
1357 if (!is_integral_type (type))
1358 error ("Argument to complement operation not an integer or boolean.");
1359
1360 /* Perform integral promotion for ANSI C/C++.
1361 FIXME: What about FORTRAN ? */
1362 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1363 result_type = builtin_type_int;
1364
1365 return value_from_longest (result_type, ~value_as_long (arg1));
1366 }
1367
1368 /* The INDEX'th bit of SET value whose VALUE_TYPE is TYPE,
1369 and whose VALUE_CONTENTS is valaddr.
1370 Return -1 if out of range, -2 other error. */
1371
1372 int
value_bit_index(struct type * type,char * valaddr,int index)1373 value_bit_index (struct type *type, char *valaddr, int index)
1374 {
1375 LONGEST low_bound, high_bound;
1376 LONGEST word;
1377 unsigned rel_index;
1378 struct type *range = TYPE_FIELD_TYPE (type, 0);
1379 if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
1380 return -2;
1381 if (index < low_bound || index > high_bound)
1382 return -1;
1383 rel_index = index - low_bound;
1384 word = unpack_long (builtin_type_unsigned_char,
1385 valaddr + (rel_index / TARGET_CHAR_BIT));
1386 rel_index %= TARGET_CHAR_BIT;
1387 if (BITS_BIG_ENDIAN)
1388 rel_index = TARGET_CHAR_BIT - 1 - rel_index;
1389 return (word >> rel_index) & 1;
1390 }
1391
1392 struct value *
value_in(struct value * element,struct value * set)1393 value_in (struct value *element, struct value *set)
1394 {
1395 int member;
1396 struct type *settype = check_typedef (VALUE_TYPE (set));
1397 struct type *eltype = check_typedef (VALUE_TYPE (element));
1398 if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
1399 eltype = TYPE_TARGET_TYPE (eltype);
1400 if (TYPE_CODE (settype) != TYPE_CODE_SET)
1401 error ("Second argument of 'IN' has wrong type");
1402 if (TYPE_CODE (eltype) != TYPE_CODE_INT
1403 && TYPE_CODE (eltype) != TYPE_CODE_CHAR
1404 && TYPE_CODE (eltype) != TYPE_CODE_ENUM
1405 && TYPE_CODE (eltype) != TYPE_CODE_BOOL)
1406 error ("First argument of 'IN' has wrong type");
1407 member = value_bit_index (settype, VALUE_CONTENTS (set),
1408 value_as_long (element));
1409 if (member < 0)
1410 error ("First argument of 'IN' not in range");
1411 return value_from_longest (LA_BOOL_TYPE, member);
1412 }
1413
1414 void
_initialize_valarith(void)1415 _initialize_valarith (void)
1416 {
1417 }
1418