1 /* OpenCL language support for GDB, the GNU debugger.
2 Copyright (C) 2010-2021 Free Software Foundation, Inc.
4 Contributed by Ken Werner <ken.werner@de.ibm.com>.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
25 #include "parser-defs.h"
32 /* Returns the corresponding OpenCL vector type from the given type code,
33 the length of the element type, the unsigned flag and the amount of
37 lookup_opencl_vector_type (struct gdbarch
*gdbarch
, enum type_code code
,
38 unsigned int el_length
, unsigned int flag_unsigned
,
43 /* Check if n describes a valid OpenCL vector size (2, 3, 4, 8, 16). */
44 if (n
!= 2 && n
!= 3 && n
!= 4 && n
!= 8 && n
!= 16)
45 error (_("Invalid OpenCL vector size: %d"), n
);
47 /* Triple vectors have the size of a quad vector. */
48 length
= (n
== 3) ? el_length
* 4 : el_length
* n
;
50 auto filter
= [&] (struct type
*type
)
54 return (type
->code () == TYPE_CODE_ARRAY
&& type
->is_vector ()
55 && get_array_bounds (type
, &lowb
, &highb
)
56 && TYPE_TARGET_TYPE (type
)->code () == code
57 && TYPE_TARGET_TYPE (type
)->is_unsigned () == flag_unsigned
58 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) == el_length
59 && TYPE_LENGTH (type
) == length
60 && highb
- lowb
+ 1 == n
);
62 const struct language_defn
*lang
= language_def (language_opencl
);
63 return language_lookup_primitive_type (lang
, gdbarch
, filter
);
66 /* Returns nonzero if the array ARR contains duplicates within
67 the first N elements. */
70 array_has_dups (int *arr
, int n
)
74 for (i
= 0; i
< n
; i
++)
76 for (j
= i
+ 1; j
< n
; j
++)
86 /* The OpenCL component access syntax allows to create lvalues referring to
87 selected elements of an original OpenCL vector in arbitrary order. This
88 structure holds the information to describe such lvalues. */
92 /* Reference count. */
94 /* The number of indices. */
96 /* The element indices themselves. */
98 /* A pointer to the original value. */
102 /* Allocates an instance of struct lval_closure. */
104 static struct lval_closure
*
105 allocate_lval_closure (int *indices
, int n
, struct value
*val
)
107 struct lval_closure
*c
= XCNEW (struct lval_closure
);
111 c
->indices
= XCNEWVEC (int, n
);
112 memcpy (c
->indices
, indices
, n
* sizeof (int));
113 value_incref (val
); /* Increment the reference counter of the value. */
120 lval_func_read (struct value
*v
)
122 struct lval_closure
*c
= (struct lval_closure
*) value_computed_closure (v
);
123 struct type
*type
= check_typedef (value_type (v
));
124 struct type
*eltype
= TYPE_TARGET_TYPE (check_typedef (value_type (c
->val
)));
125 LONGEST offset
= value_offset (v
);
126 LONGEST elsize
= TYPE_LENGTH (eltype
);
131 if (type
->code () == TYPE_CODE_ARRAY
132 && !get_array_bounds (type
, &lowb
, &highb
))
133 error (_("Could not determine the vector bounds"));
135 /* Assume elsize aligned offset. */
136 gdb_assert (offset
% elsize
== 0);
138 n
= offset
+ highb
- lowb
+ 1;
139 gdb_assert (n
<= c
->n
);
141 for (i
= offset
; i
< n
; i
++)
142 memcpy (value_contents_raw (v
) + j
++ * elsize
,
143 value_contents (c
->val
) + c
->indices
[i
] * elsize
,
148 lval_func_write (struct value
*v
, struct value
*fromval
)
150 struct value
*mark
= value_mark ();
151 struct lval_closure
*c
= (struct lval_closure
*) value_computed_closure (v
);
152 struct type
*type
= check_typedef (value_type (v
));
153 struct type
*eltype
= TYPE_TARGET_TYPE (check_typedef (value_type (c
->val
)));
154 LONGEST offset
= value_offset (v
);
155 LONGEST elsize
= TYPE_LENGTH (eltype
);
160 if (type
->code () == TYPE_CODE_ARRAY
161 && !get_array_bounds (type
, &lowb
, &highb
))
162 error (_("Could not determine the vector bounds"));
164 /* Assume elsize aligned offset. */
165 gdb_assert (offset
% elsize
== 0);
167 n
= offset
+ highb
- lowb
+ 1;
169 /* Since accesses to the fourth component of a triple vector is undefined we
170 just skip writes to the fourth element. Imagine something like this:
171 int3 i3 = (int3)(0, 1, 2);
173 In this case n would be 4 (offset=12/4 + 1) while c->n would be 3. */
177 for (i
= offset
; i
< n
; i
++)
179 struct value
*from_elm_val
= allocate_value (eltype
);
180 struct value
*to_elm_val
= value_subscript (c
->val
, c
->indices
[i
]);
182 memcpy (value_contents_writeable (from_elm_val
),
183 value_contents (fromval
) + j
++ * elsize
,
185 value_assign (to_elm_val
, from_elm_val
);
188 value_free_to_mark (mark
);
191 /* Return nonzero if bits in V from OFFSET and LENGTH represent a
192 synthetic pointer. */
195 lval_func_check_synthetic_pointer (const struct value
*v
,
196 LONGEST offset
, int length
)
198 struct lval_closure
*c
= (struct lval_closure
*) value_computed_closure (v
);
199 /* Size of the target type in bits. */
201 TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c
->val
)))) * 8;
202 int startrest
= offset
% elsize
;
203 int start
= offset
/ elsize
;
204 int endrest
= (offset
+ length
) % elsize
;
205 int end
= (offset
+ length
) / elsize
;
214 for (i
= start
; i
< end
; i
++)
216 int comp_offset
= (i
== start
) ? startrest
: 0;
217 int comp_length
= (i
== end
) ? endrest
: elsize
;
219 if (!value_bits_synthetic_pointer (c
->val
,
220 c
->indices
[i
] * elsize
+ comp_offset
,
229 lval_func_copy_closure (const struct value
*v
)
231 struct lval_closure
*c
= (struct lval_closure
*) value_computed_closure (v
);
239 lval_func_free_closure (struct value
*v
)
241 struct lval_closure
*c
= (struct lval_closure
*) value_computed_closure (v
);
247 value_decref (c
->val
); /* Decrement the reference counter of the value. */
253 static const struct lval_funcs opencl_value_funcs
=
258 NULL
, /* coerce_ref */
259 lval_func_check_synthetic_pointer
,
260 lval_func_copy_closure
,
261 lval_func_free_closure
264 /* Creates a sub-vector from VAL. The elements are selected by the indices of
265 an array with the length of N. Supported values for NOSIDE are
266 EVAL_NORMAL and EVAL_AVOID_SIDE_EFFECTS. */
268 static struct value
*
269 create_value (struct gdbarch
*gdbarch
, struct value
*val
, enum noside noside
,
272 struct type
*type
= check_typedef (value_type (val
));
273 struct type
*elm_type
= TYPE_TARGET_TYPE (type
);
276 /* Check if a single component of a vector is requested which means
277 the resulting type is a (primitive) scalar type. */
280 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
281 ret
= value_zero (elm_type
, not_lval
);
283 ret
= value_subscript (val
, indices
[0]);
287 /* Multiple components of the vector are requested which means the
288 resulting type is a vector as well. */
289 struct type
*dst_type
=
290 lookup_opencl_vector_type (gdbarch
, elm_type
->code (),
291 TYPE_LENGTH (elm_type
),
292 elm_type
->is_unsigned (), n
);
294 if (dst_type
== NULL
)
295 dst_type
= init_vector_type (elm_type
, n
);
297 make_cv_type (TYPE_CONST (type
), TYPE_VOLATILE (type
), dst_type
, NULL
);
299 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
300 ret
= allocate_value (dst_type
);
303 /* Check whether to create a lvalue or not. */
304 if (VALUE_LVAL (val
) != not_lval
&& !array_has_dups (indices
, n
))
306 struct lval_closure
*c
= allocate_lval_closure (indices
, n
, val
);
307 ret
= allocate_computed_value (dst_type
, &opencl_value_funcs
, c
);
313 ret
= allocate_value (dst_type
);
315 /* Copy src val contents into the destination value. */
316 for (i
= 0; i
< n
; i
++)
317 memcpy (value_contents_writeable (ret
)
318 + (i
* TYPE_LENGTH (elm_type
)),
320 + (indices
[i
] * TYPE_LENGTH (elm_type
)),
321 TYPE_LENGTH (elm_type
));
328 /* OpenCL vector component access. */
330 static struct value
*
331 opencl_component_ref (struct expression
*exp
, struct value
*val
,
332 const char *comps
, enum noside noside
)
340 if (!get_array_bounds (check_typedef (value_type (val
)), &lowb
, &highb
))
341 error (_("Could not determine the vector bounds"));
343 src_len
= highb
- lowb
+ 1;
345 /* Throw an error if the amount of array elements does not fit a
346 valid OpenCL vector size (2, 3, 4, 8, 16). */
347 if (src_len
!= 2 && src_len
!= 3 && src_len
!= 4 && src_len
!= 8
349 error (_("Invalid OpenCL vector size"));
351 if (strcmp (comps
, "lo") == 0 )
353 dst_len
= (src_len
== 3) ? 2 : src_len
/ 2;
355 for (i
= 0; i
< dst_len
; i
++)
358 else if (strcmp (comps
, "hi") == 0)
360 dst_len
= (src_len
== 3) ? 2 : src_len
/ 2;
362 for (i
= 0; i
< dst_len
; i
++)
363 indices
[i
] = dst_len
+ i
;
365 else if (strcmp (comps
, "even") == 0)
367 dst_len
= (src_len
== 3) ? 2 : src_len
/ 2;
369 for (i
= 0; i
< dst_len
; i
++)
372 else if (strcmp (comps
, "odd") == 0)
374 dst_len
= (src_len
== 3) ? 2 : src_len
/ 2;
376 for (i
= 0; i
< dst_len
; i
++)
379 else if (strncasecmp (comps
, "s", 1) == 0)
381 #define HEXCHAR_TO_INT(C) ((C >= '0' && C <= '9') ? \
382 C-'0' : ((C >= 'A' && C <= 'F') ? \
383 C-'A'+10 : ((C >= 'a' && C <= 'f') ? \
386 dst_len
= strlen (comps
);
387 /* Skip the s/S-prefix. */
390 for (i
= 0; i
< dst_len
; i
++)
392 indices
[i
] = HEXCHAR_TO_INT(comps
[i
+1]);
393 /* Check if the requested component is invalid or exceeds
395 if (indices
[i
] < 0 || indices
[i
] >= src_len
)
396 error (_("Invalid OpenCL vector component accessor %s"), comps
);
401 dst_len
= strlen (comps
);
403 for (i
= 0; i
< dst_len
; i
++)
416 error (_("Invalid OpenCL vector component accessor %s"), comps
);
421 error (_("Invalid OpenCL vector component accessor %s"), comps
);
425 error (_("Invalid OpenCL vector component accessor %s"), comps
);
431 /* Throw an error if the amount of requested components does not
432 result in a valid length (1, 2, 3, 4, 8, 16). */
433 if (dst_len
!= 1 && dst_len
!= 2 && dst_len
!= 3 && dst_len
!= 4
434 && dst_len
!= 8 && dst_len
!= 16)
435 error (_("Invalid OpenCL vector component accessor %s"), comps
);
437 v
= create_value (exp
->gdbarch
, val
, noside
, indices
, dst_len
);
442 /* Perform the unary logical not (!) operation. */
444 static struct value
*
445 opencl_logical_not (struct expression
*exp
, struct value
*arg
)
447 struct type
*type
= check_typedef (value_type (arg
));
448 struct type
*rettype
;
451 if (type
->code () == TYPE_CODE_ARRAY
&& type
->is_vector ())
453 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
457 if (!get_array_bounds (type
, &lowb
, &highb
))
458 error (_("Could not determine the vector bounds"));
460 /* Determine the resulting type of the operation and allocate the
462 rettype
= lookup_opencl_vector_type (exp
->gdbarch
, TYPE_CODE_INT
,
463 TYPE_LENGTH (eltype
), 0,
465 ret
= allocate_value (rettype
);
467 for (i
= 0; i
< highb
- lowb
+ 1; i
++)
469 /* For vector types, the unary operator shall return a 0 if the
470 value of its operand compares unequal to 0, and -1 (i.e. all bits
471 set) if the value of its operand compares equal to 0. */
472 int tmp
= value_logical_not (value_subscript (arg
, i
)) ? -1 : 0;
473 memset (value_contents_writeable (ret
) + i
* TYPE_LENGTH (eltype
),
474 tmp
, TYPE_LENGTH (eltype
));
479 rettype
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
480 ret
= value_from_longest (rettype
, value_logical_not (arg
));
486 /* Perform a relational operation on two scalar operands. */
489 scalar_relop (struct value
*val1
, struct value
*val2
, enum exp_opcode op
)
496 ret
= value_equal (val1
, val2
);
499 ret
= !value_equal (val1
, val2
);
502 ret
= value_less (val1
, val2
);
505 ret
= value_less (val2
, val1
);
508 ret
= value_less (val2
, val1
) || value_equal (val1
, val2
);
511 ret
= value_less (val1
, val2
) || value_equal (val1
, val2
);
513 case BINOP_LOGICAL_AND
:
514 ret
= !value_logical_not (val1
) && !value_logical_not (val2
);
516 case BINOP_LOGICAL_OR
:
517 ret
= !value_logical_not (val1
) || !value_logical_not (val2
);
520 error (_("Attempt to perform an unsupported operation"));
526 /* Perform a relational operation on two vector operands. */
528 static struct value
*
529 vector_relop (struct expression
*exp
, struct value
*val1
, struct value
*val2
,
533 struct type
*type1
, *type2
, *eltype1
, *eltype2
, *rettype
;
534 int t1_is_vec
, t2_is_vec
, i
;
535 LONGEST lowb1
, lowb2
, highb1
, highb2
;
537 type1
= check_typedef (value_type (val1
));
538 type2
= check_typedef (value_type (val2
));
540 t1_is_vec
= (type1
->code () == TYPE_CODE_ARRAY
&& type1
->is_vector ());
541 t2_is_vec
= (type2
->code () == TYPE_CODE_ARRAY
&& type2
->is_vector ());
543 if (!t1_is_vec
|| !t2_is_vec
)
544 error (_("Vector operations are not supported on scalar types"));
546 eltype1
= check_typedef (TYPE_TARGET_TYPE (type1
));
547 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
));
549 if (!get_array_bounds (type1
,&lowb1
, &highb1
)
550 || !get_array_bounds (type2
, &lowb2
, &highb2
))
551 error (_("Could not determine the vector bounds"));
553 /* Check whether the vector types are compatible. */
554 if (eltype1
->code () != eltype2
->code ()
555 || TYPE_LENGTH (eltype1
) != TYPE_LENGTH (eltype2
)
556 || eltype1
->is_unsigned () != eltype2
->is_unsigned ()
557 || lowb1
!= lowb2
|| highb1
!= highb2
)
558 error (_("Cannot perform operation on vectors with different types"));
560 /* Determine the resulting type of the operation and allocate the value. */
561 rettype
= lookup_opencl_vector_type (exp
->gdbarch
, TYPE_CODE_INT
,
562 TYPE_LENGTH (eltype1
), 0,
564 ret
= allocate_value (rettype
);
566 for (i
= 0; i
< highb1
- lowb1
+ 1; i
++)
568 /* For vector types, the relational, equality and logical operators shall
569 return 0 if the specified relation is false and -1 (i.e. all bits set)
570 if the specified relation is true. */
571 int tmp
= scalar_relop (value_subscript (val1
, i
),
572 value_subscript (val2
, i
), op
) ? -1 : 0;
573 memset (value_contents_writeable (ret
) + i
* TYPE_LENGTH (eltype1
),
574 tmp
, TYPE_LENGTH (eltype1
));
580 /* Perform a cast of ARG into TYPE. There's sadly a lot of duplication in
581 here from valops.c:value_cast, opencl is different only in the
582 behaviour of scalar to vector casting. As far as possibly we're going
583 to try and delegate back to the standard value_cast function. */
586 opencl_value_cast (struct type
*type
, struct value
*arg
)
588 if (type
!= value_type (arg
))
590 /* Casting scalar to vector is a special case for OpenCL, scalar
591 is cast to element type of vector then replicated into each
592 element of the vector. First though, we need to work out if
593 this is a scalar to vector cast; code lifted from
594 valops.c:value_cast. */
595 enum type_code code1
, code2
;
596 struct type
*to_type
;
599 to_type
= check_typedef (type
);
601 code1
= to_type
->code ();
602 code2
= check_typedef (value_type (arg
))->code ();
604 if (code2
== TYPE_CODE_REF
)
605 code2
= check_typedef (value_type (coerce_ref(arg
)))->code ();
607 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_BOOL
608 || code2
== TYPE_CODE_CHAR
|| code2
== TYPE_CODE_FLT
609 || code2
== TYPE_CODE_DECFLOAT
|| code2
== TYPE_CODE_ENUM
610 || code2
== TYPE_CODE_RANGE
);
612 if (code1
== TYPE_CODE_ARRAY
&& to_type
->is_vector () && scalar
)
616 /* Cast to the element type of the vector here as
617 value_vector_widen will error if the scalar value is
618 truncated by the cast. To avoid the error, cast (and
619 possibly truncate) here. */
620 eltype
= check_typedef (TYPE_TARGET_TYPE (to_type
));
621 arg
= value_cast (eltype
, arg
);
623 return value_vector_widen (arg
, type
);
626 /* Standard cast handler. */
627 arg
= value_cast (type
, arg
);
632 /* Perform a relational operation on two operands. */
635 opencl_relop (struct type
*expect_type
, struct expression
*exp
,
636 enum noside noside
, enum exp_opcode op
,
637 struct value
*arg1
, struct value
*arg2
)
640 struct type
*type1
= check_typedef (value_type (arg1
));
641 struct type
*type2
= check_typedef (value_type (arg2
));
642 int t1_is_vec
= (type1
->code () == TYPE_CODE_ARRAY
643 && type1
->is_vector ());
644 int t2_is_vec
= (type2
->code () == TYPE_CODE_ARRAY
645 && type2
->is_vector ());
647 if (!t1_is_vec
&& !t2_is_vec
)
649 int tmp
= scalar_relop (arg1
, arg2
, op
);
651 language_bool_type (exp
->language_defn
, exp
->gdbarch
);
653 val
= value_from_longest (type
, tmp
);
655 else if (t1_is_vec
&& t2_is_vec
)
657 val
= vector_relop (exp
, arg1
, arg2
, op
);
661 /* Widen the scalar operand to a vector. */
662 struct value
**v
= t1_is_vec
? &arg2
: &arg1
;
663 struct type
*t
= t1_is_vec
? type2
: type1
;
665 if (t
->code () != TYPE_CODE_FLT
&& !is_integral_type (t
))
666 error (_("Argument to operation not a number or boolean."));
668 *v
= opencl_value_cast (t1_is_vec
? type1
: type2
, *v
);
669 val
= vector_relop (exp
, arg1
, arg2
, op
);
675 /* A helper function for BINOP_ASSIGN. */
678 eval_opencl_assign (struct type
*expect_type
, struct expression
*exp
,
679 enum noside noside
, enum exp_opcode op
,
680 struct value
*arg1
, struct value
*arg2
)
682 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
685 struct type
*type1
= value_type (arg1
);
686 if (deprecated_value_modifiable (arg1
)
687 && VALUE_LVAL (arg1
) != lval_internalvar
)
688 arg2
= opencl_value_cast (type1
, arg2
);
690 return value_assign (arg1
, arg2
);
693 /* Expression evaluator for the OpenCL. Most operations are delegated to
694 evaluate_subexp_standard; see that function for a description of the
697 static struct value
*
698 evaluate_subexp_opencl (struct type
*expect_type
, struct expression
*exp
,
699 int *pos
, enum noside noside
)
701 enum exp_opcode op
= exp
->elts
[*pos
].opcode
;
702 struct value
*arg1
= NULL
;
703 struct value
*arg2
= NULL
;
704 struct type
*type1
, *type2
;
708 /* Handle assignment and cast operators to support OpenCL-style
709 scalar-to-vector widening. */
712 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
713 type1
= value_type (arg1
);
714 arg2
= evaluate_subexp (type1
, exp
, pos
, noside
);
716 return eval_opencl_assign (expect_type
, exp
, noside
, op
, arg1
, arg2
);
719 type1
= exp
->elts
[*pos
+ 1].type
;
721 arg1
= evaluate_subexp (type1
, exp
, pos
, noside
);
723 if (noside
== EVAL_SKIP
)
724 return value_from_longest (builtin_type (exp
->gdbarch
)->
727 return opencl_value_cast (type1
, arg1
);
731 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
732 type1
= value_type (arg1
);
733 arg1
= evaluate_subexp (type1
, exp
, pos
, noside
);
735 if (noside
== EVAL_SKIP
)
736 return value_from_longest (builtin_type (exp
->gdbarch
)->
739 return opencl_value_cast (type1
, arg1
);
741 /* Handle binary relational and equality operators that are either not
742 or differently defined for GNU vectors. */
750 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
751 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
753 if (noside
== EVAL_SKIP
)
754 return value_from_longest (builtin_type (exp
->gdbarch
)->
757 return opencl_relop (expect_type
, exp
, noside
, op
, arg1
, arg2
);
759 /* Handle the logical unary operator not(!). */
760 case UNOP_LOGICAL_NOT
:
762 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
764 if (noside
== EVAL_SKIP
)
765 return value_from_longest (builtin_type (exp
->gdbarch
)->
768 return opencl_logical_not (exp
, arg1
);
770 /* Handle the logical operator and(&&) and or(||). */
771 case BINOP_LOGICAL_AND
:
772 case BINOP_LOGICAL_OR
:
774 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
776 if (noside
== EVAL_SKIP
)
778 evaluate_subexp (nullptr, exp
, pos
, noside
);
780 return value_from_longest (builtin_type (exp
->gdbarch
)->
785 /* For scalar operations we need to avoid evaluating operands
786 unnecessarily. However, for vector operations we always need to
787 evaluate both operands. Unfortunately we only know which of the
788 two cases apply after we know the type of the second operand.
789 Therefore we evaluate it once using EVAL_AVOID_SIDE_EFFECTS. */
792 arg2
= evaluate_subexp (nullptr, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
794 type1
= check_typedef (value_type (arg1
));
795 type2
= check_typedef (value_type (arg2
));
797 if ((type1
->code () == TYPE_CODE_ARRAY
&& type1
->is_vector ())
798 || (type2
->code () == TYPE_CODE_ARRAY
&& type2
->is_vector ()))
800 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
802 return opencl_relop (nullptr, exp
, noside
, op
, arg1
, arg2
);
806 /* For scalar built-in types, only evaluate the right
807 hand operand if the left hand operand compares
808 unequal(&&)/equal(||) to 0. */
810 int tmp
= value_logical_not (arg1
);
812 if (op
== BINOP_LOGICAL_OR
)
816 = evaluate_subexp (nullptr, exp
, pos
, tmp
? EVAL_SKIP
: noside
);
817 type1
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
819 if (op
== BINOP_LOGICAL_AND
)
820 res
= !tmp
&& !value_logical_not (arg2
);
821 else /* BINOP_LOGICAL_OR */
822 res
= tmp
|| !value_logical_not (arg2
);
824 return value_from_longest (type1
, res
);
828 /* Handle the ternary selection operator. */
831 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
832 type1
= check_typedef (value_type (arg1
));
833 if (type1
->code () == TYPE_CODE_ARRAY
&& type1
->is_vector ())
835 struct value
*arg3
, *tmp
, *ret
;
836 struct type
*eltype2
, *type3
, *eltype3
;
837 int t2_is_vec
, t3_is_vec
, i
;
838 LONGEST lowb1
, lowb2
, lowb3
, highb1
, highb2
, highb3
;
840 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
841 arg3
= evaluate_subexp (nullptr, exp
, pos
, noside
);
842 type2
= check_typedef (value_type (arg2
));
843 type3
= check_typedef (value_type (arg3
));
845 = type2
->code () == TYPE_CODE_ARRAY
&& type2
->is_vector ();
847 = type3
->code () == TYPE_CODE_ARRAY
&& type3
->is_vector ();
849 /* Widen the scalar operand to a vector if necessary. */
850 if (t2_is_vec
|| !t3_is_vec
)
852 arg3
= opencl_value_cast (type2
, arg3
);
853 type3
= value_type (arg3
);
855 else if (!t2_is_vec
|| t3_is_vec
)
857 arg2
= opencl_value_cast (type3
, arg2
);
858 type2
= value_type (arg2
);
860 else if (!t2_is_vec
|| !t3_is_vec
)
862 /* Throw an error if arg2 or arg3 aren't vectors. */
864 Cannot perform conditional operation on incompatible types"));
867 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
));
868 eltype3
= check_typedef (TYPE_TARGET_TYPE (type3
));
870 if (!get_array_bounds (type1
, &lowb1
, &highb1
)
871 || !get_array_bounds (type2
, &lowb2
, &highb2
)
872 || !get_array_bounds (type3
, &lowb3
, &highb3
))
873 error (_("Could not determine the vector bounds"));
875 /* Throw an error if the types of arg2 or arg3 are incompatible. */
876 if (eltype2
->code () != eltype3
->code ()
877 || TYPE_LENGTH (eltype2
) != TYPE_LENGTH (eltype3
)
878 || eltype2
->is_unsigned () != eltype3
->is_unsigned ()
879 || lowb2
!= lowb3
|| highb2
!= highb3
)
881 Cannot perform operation on vectors with different types"));
883 /* Throw an error if the sizes of arg1 and arg2/arg3 differ. */
884 if (lowb1
!= lowb2
|| lowb1
!= lowb3
885 || highb1
!= highb2
|| highb1
!= highb3
)
887 Cannot perform conditional operation on vectors with different sizes"));
889 ret
= allocate_value (type2
);
891 for (i
= 0; i
< highb1
- lowb1
+ 1; i
++)
893 tmp
= value_logical_not (value_subscript (arg1
, i
)) ?
894 value_subscript (arg3
, i
) : value_subscript (arg2
, i
);
895 memcpy (value_contents_writeable (ret
) +
896 i
* TYPE_LENGTH (eltype2
), value_contents_all (tmp
),
897 TYPE_LENGTH (eltype2
));
904 if (value_logical_not (arg1
))
906 /* Skip the second operand. */
907 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
909 return evaluate_subexp (nullptr, exp
, pos
, noside
);
913 /* Skip the third operand. */
914 arg2
= evaluate_subexp (nullptr, exp
, pos
, noside
);
915 evaluate_subexp (nullptr, exp
, pos
, EVAL_SKIP
);
921 /* Handle STRUCTOP_STRUCT to allow component access on OpenCL vectors. */
922 case STRUCTOP_STRUCT
:
925 int tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
927 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
928 arg1
= evaluate_subexp (nullptr, exp
, pos
, noside
);
929 type1
= check_typedef (value_type (arg1
));
931 if (noside
== EVAL_SKIP
)
933 return value_from_longest (builtin_type (exp
->gdbarch
)->
936 else if (type1
->code () == TYPE_CODE_ARRAY
&& type1
->is_vector ())
938 return opencl_component_ref (exp
, arg1
, &exp
->elts
[pc
+ 2].string
,
943 struct value
*v
= value_struct_elt (&arg1
, NULL
,
944 &exp
->elts
[pc
+ 2].string
, NULL
,
947 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
948 v
= value_zero (value_type (v
), VALUE_LVAL (v
));
956 return evaluate_subexp_c (expect_type
, exp
, pos
, noside
);
959 const struct exp_descriptor exp_descriptor_opencl
=
961 print_subexp_standard
,
962 operator_length_standard
,
963 operator_check_standard
,
964 dump_subexp_body_standard
,
965 evaluate_subexp_opencl
968 /* Class representing the OpenCL language. */
970 class opencl_language
: public language_defn
974 : language_defn (language_opencl
)
977 /* See language.h. */
979 const char *name () const override
982 /* See language.h. */
984 const char *natural_name () const override
985 { return "OpenCL C"; }
987 /* See language.h. */
988 void language_arch_info (struct gdbarch
*gdbarch
,
989 struct language_arch_info
*lai
) const override
991 /* Helper function to allow shorter lines below. */
992 auto add
= [&] (struct type
* t
) -> struct type
*
994 lai
->add_primitive_type (t
);
998 /* Helper macro to create strings. */
999 #define OCL_STRING(S) #S
1001 /* This macro allocates and assigns the type struct pointers
1002 for the vector types. */
1003 #define BUILD_OCL_VTYPES(TYPE, ELEMENT_TYPE) \
1007 tmp = add (init_vector_type (ELEMENT_TYPE, 2)); \
1008 tmp->set_name (OCL_STRING(TYPE ## 2)); \
1009 tmp = add (init_vector_type (ELEMENT_TYPE, 3)); \
1010 tmp->set_name (OCL_STRING(TYPE ## 3)); \
1011 TYPE_LENGTH (tmp) = 4 * TYPE_LENGTH (ELEMENT_TYPE); \
1012 tmp = add (init_vector_type (ELEMENT_TYPE, 4)); \
1013 tmp->set_name (OCL_STRING(TYPE ## 4)); \
1014 tmp = add (init_vector_type (ELEMENT_TYPE, 8)); \
1015 tmp->set_name (OCL_STRING(TYPE ## 8)); \
1016 tmp = init_vector_type (ELEMENT_TYPE, 16); \
1017 tmp->set_name (OCL_STRING(TYPE ## 16)); \
1021 struct type
*el_type
, *char_type
, *int_type
;
1023 char_type
= el_type
= add (arch_integer_type (gdbarch
, 8, 0, "char"));
1024 BUILD_OCL_VTYPES (char, el_type
);
1025 el_type
= add (arch_integer_type (gdbarch
, 8, 1, "uchar"));
1026 BUILD_OCL_VTYPES (uchar
, el_type
);
1027 el_type
= add (arch_integer_type (gdbarch
, 16, 0, "short"));
1028 BUILD_OCL_VTYPES (short, el_type
);
1029 el_type
= add (arch_integer_type (gdbarch
, 16, 1, "ushort"));
1030 BUILD_OCL_VTYPES (ushort
, el_type
);
1031 int_type
= el_type
= add (arch_integer_type (gdbarch
, 32, 0, "int"));
1032 BUILD_OCL_VTYPES (int, el_type
);
1033 el_type
= add (arch_integer_type (gdbarch
, 32, 1, "uint"));
1034 BUILD_OCL_VTYPES (uint
, el_type
);
1035 el_type
= add (arch_integer_type (gdbarch
, 64, 0, "long"));
1036 BUILD_OCL_VTYPES (long, el_type
);
1037 el_type
= add (arch_integer_type (gdbarch
, 64, 1, "ulong"));
1038 BUILD_OCL_VTYPES (ulong
, el_type
);
1039 el_type
= add (arch_float_type (gdbarch
, 16, "half", floatformats_ieee_half
));
1040 BUILD_OCL_VTYPES (half
, el_type
);
1041 el_type
= add (arch_float_type (gdbarch
, 32, "float", floatformats_ieee_single
));
1042 BUILD_OCL_VTYPES (float, el_type
);
1043 el_type
= add (arch_float_type (gdbarch
, 64, "double", floatformats_ieee_double
));
1044 BUILD_OCL_VTYPES (double, el_type
);
1046 add (arch_boolean_type (gdbarch
, 8, 1, "bool"));
1047 add (arch_integer_type (gdbarch
, 8, 1, "unsigned char"));
1048 add (arch_integer_type (gdbarch
, 16, 1, "unsigned short"));
1049 add (arch_integer_type (gdbarch
, 32, 1, "unsigned int"));
1050 add (arch_integer_type (gdbarch
, 64, 1, "unsigned long"));
1051 add (arch_integer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
), 1, "size_t"));
1052 add (arch_integer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
), 0, "ptrdiff_t"));
1053 add (arch_integer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
), 0, "intptr_t"));
1054 add (arch_integer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
), 1, "uintptr_t"));
1055 add (arch_type (gdbarch
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, "void"));
1057 /* Type of elements of strings. */
1058 lai
->set_string_char_type (char_type
);
1060 /* Specifies the return type of logical and relational operations. */
1061 lai
->set_bool_type (int_type
, "int");
1064 /* See language.h. */
1066 void print_type (struct type
*type
, const char *varstring
,
1067 struct ui_file
*stream
, int show
, int level
,
1068 const struct type_print_options
*flags
) const override
1070 /* We nearly always defer to C type printing, except that vector types
1071 are considered primitive in OpenCL, and should always be printed
1072 using their TYPE_NAME. */
1075 type
= check_typedef (type
);
1076 if (type
->code () == TYPE_CODE_ARRAY
&& type
->is_vector ()
1077 && type
->name () != NULL
)
1081 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
1084 /* See language.h. */
1086 enum macro_expansion
macro_expansion () const override
1087 { return macro_expansion_c
; }
1089 /* See language.h. */
1091 const struct exp_descriptor
*expression_ops () const override
1092 { return &exp_descriptor_opencl
; }
1094 /* See language.h. */
1096 const struct op_print
*opcode_print_table () const override
1097 { return c_op_print_tab
; }
1100 /* Single instance of the OpenCL language class. */
1102 static opencl_language opencl_language_defn
;