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