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
=
259 NULL
, /* coerce_ref */
260 lval_func_check_synthetic_pointer
,
261 lval_func_copy_closure
,
262 lval_func_free_closure
265 /* Creates a sub-vector from VAL. The elements are selected by the indices of
266 an array with the length of N. Supported values for NOSIDE are
267 EVAL_NORMAL and EVAL_AVOID_SIDE_EFFECTS. */
269 static struct value
*
270 create_value (struct gdbarch
*gdbarch
, struct value
*val
, enum noside noside
,
273 struct type
*type
= check_typedef (value_type (val
));
274 struct type
*elm_type
= TYPE_TARGET_TYPE (type
);
277 /* Check if a single component of a vector is requested which means
278 the resulting type is a (primitive) scalar type. */
281 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
282 ret
= value_zero (elm_type
, not_lval
);
284 ret
= value_subscript (val
, indices
[0]);
288 /* Multiple components of the vector are requested which means the
289 resulting type is a vector as well. */
290 struct type
*dst_type
=
291 lookup_opencl_vector_type (gdbarch
, elm_type
->code (),
292 TYPE_LENGTH (elm_type
),
293 elm_type
->is_unsigned (), n
);
295 if (dst_type
== NULL
)
296 dst_type
= init_vector_type (elm_type
, n
);
298 make_cv_type (TYPE_CONST (type
), TYPE_VOLATILE (type
), dst_type
, NULL
);
300 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
301 ret
= allocate_value (dst_type
);
304 /* Check whether to create a lvalue or not. */
305 if (VALUE_LVAL (val
) != not_lval
&& !array_has_dups (indices
, n
))
307 struct lval_closure
*c
= allocate_lval_closure (indices
, n
, val
);
308 ret
= allocate_computed_value (dst_type
, &opencl_value_funcs
, c
);
314 ret
= allocate_value (dst_type
);
316 /* Copy src val contents into the destination value. */
317 for (i
= 0; i
< n
; i
++)
318 memcpy (value_contents_writeable (ret
)
319 + (i
* TYPE_LENGTH (elm_type
)),
321 + (indices
[i
] * TYPE_LENGTH (elm_type
)),
322 TYPE_LENGTH (elm_type
));
329 /* OpenCL vector component access. */
331 static struct value
*
332 opencl_component_ref (struct expression
*exp
, struct value
*val
,
333 const char *comps
, enum noside noside
)
341 if (!get_array_bounds (check_typedef (value_type (val
)), &lowb
, &highb
))
342 error (_("Could not determine the vector bounds"));
344 src_len
= highb
- lowb
+ 1;
346 /* Throw an error if the amount of array elements does not fit a
347 valid OpenCL vector size (2, 3, 4, 8, 16). */
348 if (src_len
!= 2 && src_len
!= 3 && src_len
!= 4 && src_len
!= 8
350 error (_("Invalid OpenCL vector size"));
352 if (strcmp (comps
, "lo") == 0 )
354 dst_len
= (src_len
== 3) ? 2 : src_len
/ 2;
356 for (i
= 0; i
< dst_len
; i
++)
359 else if (strcmp (comps
, "hi") == 0)
361 dst_len
= (src_len
== 3) ? 2 : src_len
/ 2;
363 for (i
= 0; i
< dst_len
; i
++)
364 indices
[i
] = dst_len
+ i
;
366 else if (strcmp (comps
, "even") == 0)
368 dst_len
= (src_len
== 3) ? 2 : src_len
/ 2;
370 for (i
= 0; i
< dst_len
; i
++)
373 else if (strcmp (comps
, "odd") == 0)
375 dst_len
= (src_len
== 3) ? 2 : src_len
/ 2;
377 for (i
= 0; i
< dst_len
; i
++)
380 else if (strncasecmp (comps
, "s", 1) == 0)
382 #define HEXCHAR_TO_INT(C) ((C >= '0' && C <= '9') ? \
383 C-'0' : ((C >= 'A' && C <= 'F') ? \
384 C-'A'+10 : ((C >= 'a' && C <= 'f') ? \
387 dst_len
= strlen (comps
);
388 /* Skip the s/S-prefix. */
391 for (i
= 0; i
< dst_len
; i
++)
393 indices
[i
] = HEXCHAR_TO_INT(comps
[i
+1]);
394 /* Check if the requested component is invalid or exceeds
396 if (indices
[i
] < 0 || indices
[i
] >= src_len
)
397 error (_("Invalid OpenCL vector component accessor %s"), comps
);
402 dst_len
= strlen (comps
);
404 for (i
= 0; i
< dst_len
; i
++)
417 error (_("Invalid OpenCL vector component accessor %s"), comps
);
422 error (_("Invalid OpenCL vector component accessor %s"), comps
);
426 error (_("Invalid OpenCL vector component accessor %s"), comps
);
432 /* Throw an error if the amount of requested components does not
433 result in a valid length (1, 2, 3, 4, 8, 16). */
434 if (dst_len
!= 1 && dst_len
!= 2 && dst_len
!= 3 && dst_len
!= 4
435 && dst_len
!= 8 && dst_len
!= 16)
436 error (_("Invalid OpenCL vector component accessor %s"), comps
);
438 v
= create_value (exp
->gdbarch
, val
, noside
, indices
, dst_len
);
443 /* Perform the unary logical not (!) operation. */
446 opencl_logical_not (struct type
*expect_type
, struct expression
*exp
,
447 enum noside noside
, enum exp_opcode op
,
450 struct type
*type
= check_typedef (value_type (arg
));
451 struct type
*rettype
;
454 if (type
->code () == TYPE_CODE_ARRAY
&& type
->is_vector ())
456 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
460 if (!get_array_bounds (type
, &lowb
, &highb
))
461 error (_("Could not determine the vector bounds"));
463 /* Determine the resulting type of the operation and allocate the
465 rettype
= lookup_opencl_vector_type (exp
->gdbarch
, TYPE_CODE_INT
,
466 TYPE_LENGTH (eltype
), 0,
468 ret
= allocate_value (rettype
);
470 for (i
= 0; i
< highb
- lowb
+ 1; i
++)
472 /* For vector types, the unary operator shall return a 0 if the
473 value of its operand compares unequal to 0, and -1 (i.e. all bits
474 set) if the value of its operand compares equal to 0. */
475 int tmp
= value_logical_not (value_subscript (arg
, i
)) ? -1 : 0;
476 memset (value_contents_writeable (ret
) + i
* TYPE_LENGTH (eltype
),
477 tmp
, TYPE_LENGTH (eltype
));
482 rettype
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
483 ret
= value_from_longest (rettype
, value_logical_not (arg
));
489 /* Perform a relational operation on two scalar operands. */
492 scalar_relop (struct value
*val1
, struct value
*val2
, enum exp_opcode op
)
499 ret
= value_equal (val1
, val2
);
502 ret
= !value_equal (val1
, val2
);
505 ret
= value_less (val1
, val2
);
508 ret
= value_less (val2
, val1
);
511 ret
= value_less (val2
, val1
) || value_equal (val1
, val2
);
514 ret
= value_less (val1
, val2
) || value_equal (val1
, val2
);
516 case BINOP_LOGICAL_AND
:
517 ret
= !value_logical_not (val1
) && !value_logical_not (val2
);
519 case BINOP_LOGICAL_OR
:
520 ret
= !value_logical_not (val1
) || !value_logical_not (val2
);
523 error (_("Attempt to perform an unsupported operation"));
529 /* Perform a relational operation on two vector operands. */
531 static struct value
*
532 vector_relop (struct expression
*exp
, struct value
*val1
, struct value
*val2
,
536 struct type
*type1
, *type2
, *eltype1
, *eltype2
, *rettype
;
537 int t1_is_vec
, t2_is_vec
, i
;
538 LONGEST lowb1
, lowb2
, highb1
, highb2
;
540 type1
= check_typedef (value_type (val1
));
541 type2
= check_typedef (value_type (val2
));
543 t1_is_vec
= (type1
->code () == TYPE_CODE_ARRAY
&& type1
->is_vector ());
544 t2_is_vec
= (type2
->code () == TYPE_CODE_ARRAY
&& type2
->is_vector ());
546 if (!t1_is_vec
|| !t2_is_vec
)
547 error (_("Vector operations are not supported on scalar types"));
549 eltype1
= check_typedef (TYPE_TARGET_TYPE (type1
));
550 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
));
552 if (!get_array_bounds (type1
,&lowb1
, &highb1
)
553 || !get_array_bounds (type2
, &lowb2
, &highb2
))
554 error (_("Could not determine the vector bounds"));
556 /* Check whether the vector types are compatible. */
557 if (eltype1
->code () != eltype2
->code ()
558 || TYPE_LENGTH (eltype1
) != TYPE_LENGTH (eltype2
)
559 || eltype1
->is_unsigned () != eltype2
->is_unsigned ()
560 || lowb1
!= lowb2
|| highb1
!= highb2
)
561 error (_("Cannot perform operation on vectors with different types"));
563 /* Determine the resulting type of the operation and allocate the value. */
564 rettype
= lookup_opencl_vector_type (exp
->gdbarch
, TYPE_CODE_INT
,
565 TYPE_LENGTH (eltype1
), 0,
567 ret
= allocate_value (rettype
);
569 for (i
= 0; i
< highb1
- lowb1
+ 1; i
++)
571 /* For vector types, the relational, equality and logical operators shall
572 return 0 if the specified relation is false and -1 (i.e. all bits set)
573 if the specified relation is true. */
574 int tmp
= scalar_relop (value_subscript (val1
, i
),
575 value_subscript (val2
, i
), op
) ? -1 : 0;
576 memset (value_contents_writeable (ret
) + i
* TYPE_LENGTH (eltype1
),
577 tmp
, TYPE_LENGTH (eltype1
));
583 /* Perform a cast of ARG into TYPE. There's sadly a lot of duplication in
584 here from valops.c:value_cast, opencl is different only in the
585 behaviour of scalar to vector casting. As far as possibly we're going
586 to try and delegate back to the standard value_cast function. */
589 opencl_value_cast (struct type
*type
, struct value
*arg
)
591 if (type
!= value_type (arg
))
593 /* Casting scalar to vector is a special case for OpenCL, scalar
594 is cast to element type of vector then replicated into each
595 element of the vector. First though, we need to work out if
596 this is a scalar to vector cast; code lifted from
597 valops.c:value_cast. */
598 enum type_code code1
, code2
;
599 struct type
*to_type
;
602 to_type
= check_typedef (type
);
604 code1
= to_type
->code ();
605 code2
= check_typedef (value_type (arg
))->code ();
607 if (code2
== TYPE_CODE_REF
)
608 code2
= check_typedef (value_type (coerce_ref(arg
)))->code ();
610 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_BOOL
611 || code2
== TYPE_CODE_CHAR
|| code2
== TYPE_CODE_FLT
612 || code2
== TYPE_CODE_DECFLOAT
|| code2
== TYPE_CODE_ENUM
613 || code2
== TYPE_CODE_RANGE
);
615 if (code1
== TYPE_CODE_ARRAY
&& to_type
->is_vector () && scalar
)
619 /* Cast to the element type of the vector here as
620 value_vector_widen will error if the scalar value is
621 truncated by the cast. To avoid the error, cast (and
622 possibly truncate) here. */
623 eltype
= check_typedef (TYPE_TARGET_TYPE (to_type
));
624 arg
= value_cast (eltype
, arg
);
626 return value_vector_widen (arg
, type
);
629 /* Standard cast handler. */
630 arg
= value_cast (type
, arg
);
635 /* Perform a relational operation on two operands. */
638 opencl_relop (struct type
*expect_type
, struct expression
*exp
,
639 enum noside noside
, enum exp_opcode op
,
640 struct value
*arg1
, struct value
*arg2
)
643 struct type
*type1
= check_typedef (value_type (arg1
));
644 struct type
*type2
= check_typedef (value_type (arg2
));
645 int t1_is_vec
= (type1
->code () == TYPE_CODE_ARRAY
646 && type1
->is_vector ());
647 int t2_is_vec
= (type2
->code () == TYPE_CODE_ARRAY
648 && type2
->is_vector ());
650 if (!t1_is_vec
&& !t2_is_vec
)
652 int tmp
= scalar_relop (arg1
, arg2
, op
);
654 language_bool_type (exp
->language_defn
, exp
->gdbarch
);
656 val
= value_from_longest (type
, tmp
);
658 else if (t1_is_vec
&& t2_is_vec
)
660 val
= vector_relop (exp
, arg1
, arg2
, op
);
664 /* Widen the scalar operand to a vector. */
665 struct value
**v
= t1_is_vec
? &arg2
: &arg1
;
666 struct type
*t
= t1_is_vec
? type2
: type1
;
668 if (t
->code () != TYPE_CODE_FLT
&& !is_integral_type (t
))
669 error (_("Argument to operation not a number or boolean."));
671 *v
= opencl_value_cast (t1_is_vec
? type1
: type2
, *v
);
672 val
= vector_relop (exp
, arg1
, arg2
, op
);
678 /* A helper function for BINOP_ASSIGN. */
681 eval_opencl_assign (struct type
*expect_type
, struct expression
*exp
,
682 enum noside noside
, enum exp_opcode op
,
683 struct value
*arg1
, struct value
*arg2
)
685 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
688 struct type
*type1
= value_type (arg1
);
689 if (deprecated_value_modifiable (arg1
)
690 && VALUE_LVAL (arg1
) != lval_internalvar
)
691 arg2
= opencl_value_cast (type1
, arg2
);
693 return value_assign (arg1
, arg2
);
700 opencl_structop_operation::evaluate (struct type
*expect_type
,
701 struct expression
*exp
,
704 value
*arg1
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
705 struct type
*type1
= check_typedef (value_type (arg1
));
707 if (type1
->code () == TYPE_CODE_ARRAY
&& type1
->is_vector ())
708 return opencl_component_ref (exp
, arg1
, std::get
<1> (m_storage
).c_str (),
712 struct value
*v
= value_struct_elt (&arg1
, {},
713 std::get
<1> (m_storage
).c_str (),
716 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
717 v
= value_zero (value_type (v
), VALUE_LVAL (v
));
723 opencl_logical_binop_operation::evaluate (struct type
*expect_type
,
724 struct expression
*exp
,
727 enum exp_opcode op
= std::get
<0> (m_storage
);
728 value
*arg1
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
730 /* For scalar operations we need to avoid evaluating operands
731 unnecessarily. However, for vector operations we always need to
732 evaluate both operands. Unfortunately we only know which of the
733 two cases apply after we know the type of the second operand.
734 Therefore we evaluate it once using EVAL_AVOID_SIDE_EFFECTS. */
735 value
*arg2
= std::get
<2> (m_storage
)->evaluate (nullptr, exp
,
736 EVAL_AVOID_SIDE_EFFECTS
);
737 struct type
*type1
= check_typedef (value_type (arg1
));
738 struct type
*type2
= check_typedef (value_type (arg2
));
740 if ((type1
->code () == TYPE_CODE_ARRAY
&& type1
->is_vector ())
741 || (type2
->code () == TYPE_CODE_ARRAY
&& type2
->is_vector ()))
743 arg2
= std::get
<2> (m_storage
)->evaluate (nullptr, exp
, noside
);
745 return opencl_relop (nullptr, exp
, noside
, op
, arg1
, arg2
);
749 /* For scalar built-in types, only evaluate the right
750 hand operand if the left hand operand compares
751 unequal(&&)/equal(||) to 0. */
752 bool tmp
= value_logical_not (arg1
);
754 if (op
== BINOP_LOGICAL_OR
)
759 arg2
= std::get
<2> (m_storage
)->evaluate (nullptr, exp
, noside
);
760 tmp
= value_logical_not (arg2
);
761 if (op
== BINOP_LOGICAL_OR
)
765 type1
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
766 return value_from_longest (type1
, tmp
);
771 opencl_ternop_cond_operation::evaluate (struct type
*expect_type
,
772 struct expression
*exp
,
775 value
*arg1
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
776 struct type
*type1
= check_typedef (value_type (arg1
));
777 if (type1
->code () == TYPE_CODE_ARRAY
&& type1
->is_vector ())
779 struct value
*arg2
, *arg3
, *tmp
, *ret
;
780 struct type
*eltype2
, *type2
, *type3
, *eltype3
;
781 int t2_is_vec
, t3_is_vec
, i
;
782 LONGEST lowb1
, lowb2
, lowb3
, highb1
, highb2
, highb3
;
784 arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
785 arg3
= std::get
<2> (m_storage
)->evaluate (nullptr, exp
, noside
);
786 type2
= check_typedef (value_type (arg2
));
787 type3
= check_typedef (value_type (arg3
));
789 = type2
->code () == TYPE_CODE_ARRAY
&& type2
->is_vector ();
791 = type3
->code () == TYPE_CODE_ARRAY
&& type3
->is_vector ();
793 /* Widen the scalar operand to a vector if necessary. */
794 if (t2_is_vec
|| !t3_is_vec
)
796 arg3
= opencl_value_cast (type2
, arg3
);
797 type3
= value_type (arg3
);
799 else if (!t2_is_vec
|| t3_is_vec
)
801 arg2
= opencl_value_cast (type3
, arg2
);
802 type2
= value_type (arg2
);
804 else if (!t2_is_vec
|| !t3_is_vec
)
806 /* Throw an error if arg2 or arg3 aren't vectors. */
808 Cannot perform conditional operation on incompatible types"));
811 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
));
812 eltype3
= check_typedef (TYPE_TARGET_TYPE (type3
));
814 if (!get_array_bounds (type1
, &lowb1
, &highb1
)
815 || !get_array_bounds (type2
, &lowb2
, &highb2
)
816 || !get_array_bounds (type3
, &lowb3
, &highb3
))
817 error (_("Could not determine the vector bounds"));
819 /* Throw an error if the types of arg2 or arg3 are incompatible. */
820 if (eltype2
->code () != eltype3
->code ()
821 || TYPE_LENGTH (eltype2
) != TYPE_LENGTH (eltype3
)
822 || eltype2
->is_unsigned () != eltype3
->is_unsigned ()
823 || lowb2
!= lowb3
|| highb2
!= highb3
)
825 Cannot perform operation on vectors with different types"));
827 /* Throw an error if the sizes of arg1 and arg2/arg3 differ. */
828 if (lowb1
!= lowb2
|| lowb1
!= lowb3
829 || highb1
!= highb2
|| highb1
!= highb3
)
831 Cannot perform conditional operation on vectors with different sizes"));
833 ret
= allocate_value (type2
);
835 for (i
= 0; i
< highb1
- lowb1
+ 1; i
++)
837 tmp
= value_logical_not (value_subscript (arg1
, i
)) ?
838 value_subscript (arg3
, i
) : value_subscript (arg2
, i
);
839 memcpy (value_contents_writeable (ret
) +
840 i
* TYPE_LENGTH (eltype2
), value_contents_all (tmp
),
841 TYPE_LENGTH (eltype2
));
848 if (value_logical_not (arg1
))
849 return std::get
<2> (m_storage
)->evaluate (nullptr, exp
, noside
);
851 return std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
855 } /* namespace expr */
857 /* Class representing the OpenCL language. */
859 class opencl_language
: public language_defn
863 : language_defn (language_opencl
)
866 /* See language.h. */
868 const char *name () const override
871 /* See language.h. */
873 const char *natural_name () const override
874 { return "OpenCL C"; }
876 /* See language.h. */
877 void language_arch_info (struct gdbarch
*gdbarch
,
878 struct language_arch_info
*lai
) const override
880 /* Helper function to allow shorter lines below. */
881 auto add
= [&] (struct type
* t
) -> struct type
*
883 lai
->add_primitive_type (t
);
887 /* Helper macro to create strings. */
888 #define OCL_STRING(S) #S
890 /* This macro allocates and assigns the type struct pointers
891 for the vector types. */
892 #define BUILD_OCL_VTYPES(TYPE, ELEMENT_TYPE) \
896 tmp = add (init_vector_type (ELEMENT_TYPE, 2)); \
897 tmp->set_name (OCL_STRING(TYPE ## 2)); \
898 tmp = add (init_vector_type (ELEMENT_TYPE, 3)); \
899 tmp->set_name (OCL_STRING(TYPE ## 3)); \
900 TYPE_LENGTH (tmp) = 4 * TYPE_LENGTH (ELEMENT_TYPE); \
901 tmp = add (init_vector_type (ELEMENT_TYPE, 4)); \
902 tmp->set_name (OCL_STRING(TYPE ## 4)); \
903 tmp = add (init_vector_type (ELEMENT_TYPE, 8)); \
904 tmp->set_name (OCL_STRING(TYPE ## 8)); \
905 tmp = init_vector_type (ELEMENT_TYPE, 16); \
906 tmp->set_name (OCL_STRING(TYPE ## 16)); \
910 struct type
*el_type
, *char_type
, *int_type
;
912 char_type
= el_type
= add (arch_integer_type (gdbarch
, 8, 0, "char"));
913 BUILD_OCL_VTYPES (char, el_type
);
914 el_type
= add (arch_integer_type (gdbarch
, 8, 1, "uchar"));
915 BUILD_OCL_VTYPES (uchar
, el_type
);
916 el_type
= add (arch_integer_type (gdbarch
, 16, 0, "short"));
917 BUILD_OCL_VTYPES (short, el_type
);
918 el_type
= add (arch_integer_type (gdbarch
, 16, 1, "ushort"));
919 BUILD_OCL_VTYPES (ushort
, el_type
);
920 int_type
= el_type
= add (arch_integer_type (gdbarch
, 32, 0, "int"));
921 BUILD_OCL_VTYPES (int, el_type
);
922 el_type
= add (arch_integer_type (gdbarch
, 32, 1, "uint"));
923 BUILD_OCL_VTYPES (uint
, el_type
);
924 el_type
= add (arch_integer_type (gdbarch
, 64, 0, "long"));
925 BUILD_OCL_VTYPES (long, el_type
);
926 el_type
= add (arch_integer_type (gdbarch
, 64, 1, "ulong"));
927 BUILD_OCL_VTYPES (ulong
, el_type
);
928 el_type
= add (arch_float_type (gdbarch
, 16, "half", floatformats_ieee_half
));
929 BUILD_OCL_VTYPES (half
, el_type
);
930 el_type
= add (arch_float_type (gdbarch
, 32, "float", floatformats_ieee_single
));
931 BUILD_OCL_VTYPES (float, el_type
);
932 el_type
= add (arch_float_type (gdbarch
, 64, "double", floatformats_ieee_double
));
933 BUILD_OCL_VTYPES (double, el_type
);
935 add (arch_boolean_type (gdbarch
, 8, 1, "bool"));
936 add (arch_integer_type (gdbarch
, 8, 1, "unsigned char"));
937 add (arch_integer_type (gdbarch
, 16, 1, "unsigned short"));
938 add (arch_integer_type (gdbarch
, 32, 1, "unsigned int"));
939 add (arch_integer_type (gdbarch
, 64, 1, "unsigned long"));
940 add (arch_integer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
), 1, "size_t"));
941 add (arch_integer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
), 0, "ptrdiff_t"));
942 add (arch_integer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
), 0, "intptr_t"));
943 add (arch_integer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
), 1, "uintptr_t"));
944 add (arch_type (gdbarch
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, "void"));
946 /* Type of elements of strings. */
947 lai
->set_string_char_type (char_type
);
949 /* Specifies the return type of logical and relational operations. */
950 lai
->set_bool_type (int_type
, "int");
953 /* See language.h. */
955 void print_type (struct type
*type
, const char *varstring
,
956 struct ui_file
*stream
, int show
, int level
,
957 const struct type_print_options
*flags
) const override
959 /* We nearly always defer to C type printing, except that vector types
960 are considered primitive in OpenCL, and should always be printed
961 using their TYPE_NAME. */
964 type
= check_typedef (type
);
965 if (type
->code () == TYPE_CODE_ARRAY
&& type
->is_vector ()
966 && type
->name () != NULL
)
970 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
973 /* See language.h. */
975 enum macro_expansion
macro_expansion () const override
976 { return macro_expansion_c
; }
979 /* Single instance of the OpenCL language class. */
981 static opencl_language opencl_language_defn
;