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