1 /* Perform arithmetic and other operations on values, for GDB.
2 Copyright (C) 1986, 1989 Free Software Foundation, Inc.
4 This file is part of GDB.
6 GDB is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 1, or (at your option)
11 GDB is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GDB; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
24 #include "expression.h"
27 value
value_x_binop ();
28 value
value_subscripted_rvalue ();
31 value_add (arg1
, arg2
)
34 register value val
, valint
, valptr
;
40 if ((TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
41 || TYPE_CODE (VALUE_TYPE (arg2
)) == TYPE_CODE_PTR
)
43 (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_INT
44 || TYPE_CODE (VALUE_TYPE (arg2
)) == TYPE_CODE_INT
))
45 /* Exactly one argument is a pointer, and one is an integer. */
47 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
)
57 len
= TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (valptr
)));
58 if (len
== 0) len
= 1; /* For (void *) */
59 val
= value_from_long (builtin_type_long
,
60 value_as_long (valptr
)
61 + (len
* value_as_long (valint
)));
62 VALUE_TYPE (val
) = VALUE_TYPE (valptr
);
66 return value_binop (arg1
, arg2
, BINOP_ADD
);
70 value_sub (arg1
, arg2
)
78 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
80 TYPE_CODE (VALUE_TYPE (arg2
)) == TYPE_CODE_INT
)
82 val
= value_from_long (builtin_type_long
,
84 - TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
))) * value_as_long (arg2
));
85 VALUE_TYPE (val
) = VALUE_TYPE (arg1
);
89 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
91 VALUE_TYPE (arg1
) == VALUE_TYPE (arg2
))
93 val
= value_from_long (builtin_type_long
,
94 (value_as_long (arg1
) - value_as_long (arg2
))
95 / TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
))));
99 return value_binop (arg1
, arg2
, BINOP_SUB
);
102 /* Return the value of ARRAY[IDX]. */
105 value_subscript (array
, idx
)
108 if (TYPE_CODE (VALUE_TYPE (array
)) == TYPE_CODE_ARRAY
109 && VALUE_LVAL (array
) != lval_memory
)
110 return value_subscripted_rvalue (array
, idx
);
112 return value_ind (value_add (array
, idx
));
115 /* Return the value of EXPR[IDX], expr an aggregate rvalue
116 (eg, a vector register) */
119 value_subscripted_rvalue (array
, idx
)
122 struct type
*elt_type
= TYPE_TARGET_TYPE (VALUE_TYPE (array
));
123 int elt_size
= TYPE_LENGTH (elt_type
);
124 int elt_offs
= elt_size
* value_as_long (idx
);
127 if (elt_offs
>= TYPE_LENGTH (VALUE_TYPE (array
)))
128 error ("no such vector element");
130 if (TYPE_CODE (elt_type
) == TYPE_CODE_FLT
)
132 if (elt_size
== sizeof (float))
133 v
= value_from_double (elt_type
, (double) *(float *)
134 (VALUE_CONTENTS (array
) + elt_offs
));
136 v
= value_from_double (elt_type
, *(double *)
137 (VALUE_CONTENTS (array
) + elt_offs
));
142 union {int i
; char c
;} test
;
147 offs
= sizeof (LONGEST
) - elt_size
;
148 v
= value_from_long (elt_type
, *(LONGEST
*)
149 (VALUE_CONTENTS (array
) + elt_offs
- offs
));
152 if (VALUE_LVAL (array
) == lval_internalvar
)
153 VALUE_LVAL (v
) = lval_internalvar_component
;
155 VALUE_LVAL (v
) = not_lval
;
156 VALUE_ADDRESS (v
) = VALUE_ADDRESS (array
);
157 VALUE_OFFSET (v
) = VALUE_OFFSET (array
) + elt_offs
;
158 VALUE_BITSIZE (v
) = elt_size
* 8;
162 /* Check to see if either argument is a structure. This is called so
163 we know whether to go ahead with the normal binop or look for a
164 user defined function instead.
166 For now, we do not overload the `=' operator. */
169 binop_user_defined_p (op
, arg1
, arg2
)
173 if (op
== BINOP_ASSIGN
)
175 return (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_STRUCT
176 || TYPE_CODE (VALUE_TYPE (arg2
)) == TYPE_CODE_STRUCT
177 || (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_REF
178 && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
))) == TYPE_CODE_STRUCT
)
179 || (TYPE_CODE (VALUE_TYPE (arg2
)) == TYPE_CODE_REF
180 && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2
))) == TYPE_CODE_STRUCT
));
183 /* Check to see if argument is a structure. This is called so
184 we know whether to go ahead with the normal unop or look for a
185 user defined function instead.
187 For now, we do not overload the `&' operator. */
189 int unop_user_defined_p (op
, arg1
)
195 return (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_STRUCT
196 || (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_REF
197 && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
))) == TYPE_CODE_STRUCT
));
200 /* We know either arg1 or arg2 is a structure, so try to find the right
201 user defined function. Create an argument vector that calls
202 arg1.operator @ (arg1,arg2) and return that value (where '@' is any
203 binary operator which is legal for GNU C++). */
206 value_x_binop (arg1
, arg2
, op
, otherop
)
218 /* now we know that what we have to do is construct our
219 arg vector and find the right function to call it with. */
221 if (TYPE_CODE (VALUE_TYPE (arg1
)) != TYPE_CODE_STRUCT
)
222 error ("friend functions not implemented yet");
224 argvec
= (value
*) alloca (sizeof (value
) * 4);
225 argvec
[1] = value_addr (arg1
);
229 /* make the right function name up */
230 strcpy(tstr
, "operator __");
234 case BINOP_ADD
: strcpy(ptr
,"+"); break;
235 case BINOP_SUB
: strcpy(ptr
,"-"); break;
236 case BINOP_MUL
: strcpy(ptr
,"*"); break;
237 case BINOP_DIV
: strcpy(ptr
,"/"); break;
238 case BINOP_REM
: strcpy(ptr
,"%"); break;
239 case BINOP_LSH
: strcpy(ptr
,"<<"); break;
240 case BINOP_RSH
: strcpy(ptr
,">>"); break;
241 case BINOP_LOGAND
: strcpy(ptr
,"&"); break;
242 case BINOP_LOGIOR
: strcpy(ptr
,"|"); break;
243 case BINOP_LOGXOR
: strcpy(ptr
,"^"); break;
244 case BINOP_AND
: strcpy(ptr
,"&&"); break;
245 case BINOP_OR
: strcpy(ptr
,"||"); break;
246 case BINOP_MIN
: strcpy(ptr
,"<?"); break;
247 case BINOP_MAX
: strcpy(ptr
,">?"); break;
248 case BINOP_ASSIGN
: strcpy(ptr
,"="); break;
249 case BINOP_ASSIGN_MODIFY
:
252 case BINOP_ADD
: strcpy(ptr
,"+="); break;
253 case BINOP_SUB
: strcpy(ptr
,"-="); break;
254 case BINOP_MUL
: strcpy(ptr
,"*="); break;
255 case BINOP_DIV
: strcpy(ptr
,"/="); break;
256 case BINOP_REM
: strcpy(ptr
,"%="); break;
257 case BINOP_LOGAND
: strcpy(ptr
,"&="); break;
258 case BINOP_LOGIOR
: strcpy(ptr
,"|="); break;
259 case BINOP_LOGXOR
: strcpy(ptr
,"^="); break;
261 error ("Invalid binary operation specified.");
264 case BINOP_SUBSCRIPT
: strcpy(ptr
,"[]"); break;
265 case BINOP_EQUAL
: strcpy(ptr
,"=="); break;
266 case BINOP_NOTEQUAL
: strcpy(ptr
,"!="); break;
267 case BINOP_LESS
: strcpy(ptr
,"<"); break;
268 case BINOP_GTR
: strcpy(ptr
,">"); break;
269 case BINOP_GEQ
: strcpy(ptr
,">="); break;
270 case BINOP_LEQ
: strcpy(ptr
,"<="); break;
272 error ("Invalid binary operation specified.");
274 argvec
[0] = value_struct_elt (arg1
, argvec
+1, tstr
, &static_memfuncp
, "structure");
279 argvec
[1] = argvec
[0];
282 return call_function (argvec
[0], 2 - static_memfuncp
, argvec
+ 1);
284 error ("member function %s not found", tstr
);
287 /* We know that arg1 is a structure, so try to find a unary user
288 defined operator that matches the operator in question.
289 Create an argument vector that calls arg1.operator @ (arg1)
290 and return that value (where '@' is (almost) any unary operator which
291 is legal for GNU C++). */
294 value_x_unop (arg1
, op
)
305 /* now we know that what we have to do is construct our
306 arg vector and find the right function to call it with. */
308 if (TYPE_CODE (VALUE_TYPE (arg1
)) != TYPE_CODE_STRUCT
)
309 error ("friend functions not implemented yet");
311 argvec
= (value
*) alloca (sizeof (value
) * 3);
312 argvec
[1] = value_addr (arg1
);
315 /* make the right function name up */
316 strcpy(tstr
,"operator __");
320 case UNOP_PREINCREMENT
: strcpy(ptr
,"++"); break;
321 case UNOP_PREDECREMENT
: strcpy(ptr
,"++"); break;
322 case UNOP_POSTINCREMENT
: strcpy(ptr
,"++"); break;
323 case UNOP_POSTDECREMENT
: strcpy(ptr
,"++"); break;
324 case UNOP_ZEROP
: strcpy(ptr
,"!"); break;
325 case UNOP_LOGNOT
: strcpy(ptr
,"~"); break;
326 case UNOP_NEG
: strcpy(ptr
,"-"); break;
328 error ("Invalid binary operation specified.");
330 argvec
[0] = value_struct_elt (arg1
, argvec
+1, tstr
, static_memfuncp
, "structure");
335 argvec
[1] = argvec
[0];
338 return call_function (argvec
[0], 1 - static_memfuncp
, argvec
+ 1);
340 error ("member function %s not found", tstr
);
343 /* Perform a binary operation on two integers or two floats.
344 Does not support addition and subtraction on pointers;
345 use value_add or value_sub if you want to handle those possibilities. */
348 value_binop (arg1
, arg2
, op
)
357 if ((TYPE_CODE (VALUE_TYPE (arg1
)) != TYPE_CODE_FLT
359 TYPE_CODE (VALUE_TYPE (arg1
)) != TYPE_CODE_INT
)
361 (TYPE_CODE (VALUE_TYPE (arg2
)) != TYPE_CODE_FLT
363 TYPE_CODE (VALUE_TYPE (arg2
)) != TYPE_CODE_INT
))
364 error ("Argument to arithmetic operation not a number.");
366 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_FLT
368 TYPE_CODE (VALUE_TYPE (arg2
)) == TYPE_CODE_FLT
)
371 v1
= value_as_double (arg1
);
372 v2
= value_as_double (arg2
);
392 error ("Integer-only operation on floating point number.");
395 val
= allocate_value (builtin_type_double
);
396 *(double *) VALUE_CONTENTS (val
) = v
;
399 /* Integral operations here. */
401 /* Should we promote to unsigned longest? */
402 if ((TYPE_UNSIGNED (VALUE_TYPE (arg1
))
403 || TYPE_UNSIGNED (VALUE_TYPE (arg2
)))
404 && (TYPE_LENGTH (VALUE_TYPE (arg1
)) >= sizeof (unsigned LONGEST
)
405 || TYPE_LENGTH (VALUE_TYPE (arg1
)) >= sizeof (unsigned LONGEST
)))
407 unsigned LONGEST v1
, v2
, v
;
408 v1
= (unsigned LONGEST
) value_as_long (arg1
);
409 v2
= (unsigned LONGEST
) value_as_long (arg2
);
462 v
= v1
< v2
? v1
: v2
;
466 v
= v1
> v2
? v1
: v2
;
470 error ("Invalid binary operation on numbers.");
473 val
= allocate_value (BUILTIN_TYPE_UNSIGNED_LONGEST
);
474 *(unsigned LONGEST
*) VALUE_CONTENTS (val
) = v
;
479 v1
= value_as_long (arg1
);
480 v2
= value_as_long (arg2
);
533 v
= v1
< v2
? v1
: v2
;
537 v
= v1
> v2
? v1
: v2
;
541 error ("Invalid binary operation on numbers.");
544 val
= allocate_value (BUILTIN_TYPE_LONGEST
);
545 *(LONGEST
*) VALUE_CONTENTS (val
) = v
;
552 /* Simulate the C operator ! -- return 1 if ARG1 contains zeros. */
563 len
= TYPE_LENGTH (VALUE_TYPE (arg1
));
564 p
= VALUE_CONTENTS (arg1
);
575 /* Simulate the C operator == by returning a 1
576 iff ARG1 and ARG2 have equal contents. */
579 value_equal (arg1
, arg2
)
580 register value arg1
, arg2
;
584 register char *p1
, *p2
;
585 enum type_code code1
;
586 enum type_code code2
;
591 code1
= TYPE_CODE (VALUE_TYPE (arg1
));
592 code2
= TYPE_CODE (VALUE_TYPE (arg2
));
594 if (code1
== TYPE_CODE_INT
&& code2
== TYPE_CODE_INT
)
595 return value_as_long (arg1
) == value_as_long (arg2
);
596 else if ((code1
== TYPE_CODE_FLT
|| code1
== TYPE_CODE_INT
)
597 && (code2
== TYPE_CODE_FLT
|| code2
== TYPE_CODE_INT
))
598 return value_as_double (arg1
) == value_as_double (arg2
);
599 else if ((code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_INT
)
600 || (code2
== TYPE_CODE_PTR
&& code1
== TYPE_CODE_INT
))
601 return (char *) value_as_long (arg1
) == (char *) value_as_long (arg2
);
602 else if (code1
== code2
603 && ((len
= TYPE_LENGTH (VALUE_TYPE (arg1
)))
604 == TYPE_LENGTH (VALUE_TYPE (arg2
))))
606 p1
= VALUE_CONTENTS (arg1
);
607 p2
= VALUE_CONTENTS (arg2
);
616 error ("Invalid type combination in equality test.");
619 /* Simulate the C operator < by returning 1
620 iff ARG1's contents are less than ARG2's. */
623 value_less (arg1
, arg2
)
624 register value arg1
, arg2
;
626 register enum type_code code1
;
627 register enum type_code code2
;
632 code1
= TYPE_CODE (VALUE_TYPE (arg1
));
633 code2
= TYPE_CODE (VALUE_TYPE (arg2
));
635 if (code1
== TYPE_CODE_INT
&& code2
== TYPE_CODE_INT
)
636 return value_as_long (arg1
) < value_as_long (arg2
);
637 else if ((code1
== TYPE_CODE_FLT
|| code1
== TYPE_CODE_INT
)
638 && (code2
== TYPE_CODE_FLT
|| code2
== TYPE_CODE_INT
))
639 return value_as_double (arg1
) < value_as_double (arg2
);
640 else if ((code1
== TYPE_CODE_PTR
|| code1
== TYPE_CODE_INT
)
641 && (code2
== TYPE_CODE_PTR
|| code2
== TYPE_CODE_INT
))
642 return (char *) value_as_long (arg1
) < (char *) value_as_long (arg2
);
644 error ("Invalid type combination in ordering comparison.");
647 /* The unary operators - and ~. Both free the argument ARG1. */
653 register struct type
*type
;
657 type
= VALUE_TYPE (arg1
);
659 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
660 return value_from_double (type
, - value_as_double (arg1
));
661 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
662 return value_from_long (type
, - value_as_long (arg1
));
664 error ("Argument to negate operation not a number.");
673 if (TYPE_CODE (VALUE_TYPE (arg1
)) != TYPE_CODE_INT
)
674 error ("Argument to complement operation not an integer.");
676 return value_from_long (VALUE_TYPE (arg1
), ~ value_as_long (arg1
));