GDB (xrefs)

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