Automatic date update in version.in
[binutils-gdb.git] / gdb / opencl-lang.c
blob2b58deed57302dd6bad23affd1f2d9735aefafa7
1 /* OpenCL language support for GDB, the GNU debugger.
2 Copyright (C) 2010-2024 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/>. */
21 #include "defs.h"
22 #include "gdbtypes.h"
23 #include "symtab.h"
24 #include "expression.h"
25 #include "parser-defs.h"
26 #include "language.h"
27 #include "varobj.h"
28 #include "c-lang.h"
29 #include "gdbarch.h"
30 #include "c-exp.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
34 elements (N). */
36 static struct type *
37 lookup_opencl_vector_type (struct gdbarch *gdbarch, enum type_code code,
38 unsigned int el_length, unsigned int flag_unsigned,
39 int n)
41 unsigned int length;
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)
52 LONGEST lowb, highb;
54 return (type->code () == TYPE_CODE_ARRAY && type->is_vector ()
55 && get_array_bounds (type, &lowb, &highb)
56 && type->target_type ()->code () == code
57 && type->target_type ()->is_unsigned () == flag_unsigned
58 && type->target_type ()->length () == el_length
59 && type->length () == 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. */
69 static int
70 array_has_dups (int *arr, int n)
72 int i, j;
74 for (i = 0; i < n; i++)
76 for (j = i + 1; j < n; j++)
78 if (arr[i] == arr[j])
79 return 1;
83 return 0;
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. */
90 struct lval_closure
92 /* Reference count. */
93 int refc;
94 /* The number of indices. */
95 int n;
96 /* The element indices themselves. */
97 int *indices;
98 /* A pointer to the original value. */
99 struct value *val;
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);
109 c->refc = 1;
110 c->n = n;
111 c->indices = XCNEWVEC (int, n);
112 memcpy (c->indices, indices, n * sizeof (int));
113 val->incref (); /* Increment the reference counter of the value. */
114 c->val = val;
116 return c;
119 static void
120 lval_func_read (struct value *v)
122 struct lval_closure *c = (struct lval_closure *) v->computed_closure ();
123 struct type *type = check_typedef (v->type ());
124 struct type *eltype = check_typedef (c->val->type ())->target_type ();
125 LONGEST offset = v->offset ();
126 LONGEST elsize = eltype->length ();
127 int n, i, j = 0;
128 LONGEST lowb = 0;
129 LONGEST highb = 0;
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);
137 offset /= elsize;
138 n = offset + highb - lowb + 1;
139 gdb_assert (n <= c->n);
141 for (i = offset; i < n; i++)
142 memcpy (v->contents_raw ().data () + j++ * elsize,
143 c->val->contents ().data () + c->indices[i] * elsize,
144 elsize);
147 static void
148 lval_func_write (struct value *v, struct value *fromval)
150 scoped_value_mark mark;
152 struct lval_closure *c = (struct lval_closure *) v->computed_closure ();
153 struct type *type = check_typedef (v->type ());
154 struct type *eltype = check_typedef (c->val->type ())->target_type ();
155 LONGEST offset = v->offset ();
156 LONGEST elsize = eltype->length ();
157 int n, i, j = 0;
158 LONGEST lowb = 0;
159 LONGEST highb = 0;
161 if (type->code () == TYPE_CODE_ARRAY
162 && !get_array_bounds (type, &lowb, &highb))
163 error (_("Could not determine the vector bounds"));
165 /* Assume elsize aligned offset. */
166 gdb_assert (offset % elsize == 0);
167 offset /= elsize;
168 n = offset + highb - lowb + 1;
170 /* Since accesses to the fourth component of a triple vector is undefined we
171 just skip writes to the fourth element. Imagine something like this:
172 int3 i3 = (int3)(0, 1, 2);
173 i3.hi.hi = 5;
174 In this case n would be 4 (offset=12/4 + 1) while c->n would be 3. */
175 if (n > c->n)
176 n = c->n;
178 for (i = offset; i < n; i++)
180 struct value *from_elm_val = value::allocate (eltype);
181 struct value *to_elm_val = value_subscript (c->val, c->indices[i]);
183 memcpy (from_elm_val->contents_writeable ().data (),
184 fromval->contents ().data () + j++ * elsize,
185 elsize);
186 value_assign (to_elm_val, from_elm_val);
190 /* Return true if bits in V from OFFSET and LENGTH represent a
191 synthetic pointer. */
193 static bool
194 lval_func_check_synthetic_pointer (const struct value *v,
195 LONGEST offset, int length)
197 struct lval_closure *c = (struct lval_closure *) v->computed_closure ();
198 /* Size of the target type in bits. */
199 int elsize =
200 check_typedef (c->val->type ())->target_type ()->length () * 8;
201 int startrest = offset % elsize;
202 int start = offset / elsize;
203 int endrest = (offset + length) % elsize;
204 int end = (offset + length) / elsize;
205 int i;
207 if (endrest)
208 end++;
210 if (end > c->n)
211 return false;
213 for (i = start; i < end; i++)
215 int comp_offset = (i == start) ? startrest : 0;
216 int comp_length = (i == end) ? endrest : elsize;
218 if (!c->val->bits_synthetic_pointer (c->indices[i] * elsize + comp_offset,
219 comp_length))
220 return false;
223 return true;
226 static void *
227 lval_func_copy_closure (const struct value *v)
229 struct lval_closure *c = (struct lval_closure *) v->computed_closure ();
231 ++c->refc;
233 return c;
236 static void
237 lval_func_free_closure (struct value *v)
239 struct lval_closure *c = (struct lval_closure *) v->computed_closure ();
241 --c->refc;
243 if (c->refc == 0)
245 c->val->decref (); /* Decrement the reference counter of the value. */
246 xfree (c->indices);
247 xfree (c);
251 static const struct lval_funcs opencl_value_funcs =
253 lval_func_read,
254 lval_func_write,
255 nullptr,
256 NULL, /* indirect */
257 NULL, /* coerce_ref */
258 lval_func_check_synthetic_pointer,
259 lval_func_copy_closure,
260 lval_func_free_closure
263 /* Creates a sub-vector from VAL. The elements are selected by the indices of
264 an array with the length of N. Supported values for NOSIDE are
265 EVAL_NORMAL and EVAL_AVOID_SIDE_EFFECTS. */
267 static struct value *
268 create_value (struct gdbarch *gdbarch, struct value *val, enum noside noside,
269 int *indices, int n)
271 struct type *type = check_typedef (val->type ());
272 struct type *elm_type = type->target_type ();
273 struct value *ret;
275 /* Check if a single component of a vector is requested which means
276 the resulting type is a (primitive) scalar type. */
277 if (n == 1)
279 if (noside == EVAL_AVOID_SIDE_EFFECTS)
280 ret = value::zero (elm_type, not_lval);
281 else
282 ret = value_subscript (val, indices[0]);
284 else
286 /* Multiple components of the vector are requested which means the
287 resulting type is a vector as well. */
288 struct type *dst_type =
289 lookup_opencl_vector_type (gdbarch, elm_type->code (),
290 elm_type->length (),
291 elm_type->is_unsigned (), n);
293 if (dst_type == NULL)
294 dst_type = init_vector_type (elm_type, n);
296 make_cv_type (TYPE_CONST (type), TYPE_VOLATILE (type), dst_type, NULL);
298 if (noside == EVAL_AVOID_SIDE_EFFECTS)
299 ret = value::allocate (dst_type);
300 else
302 /* Check whether to create a lvalue or not. */
303 if (val->lval () != not_lval && !array_has_dups (indices, n))
305 struct lval_closure *c = allocate_lval_closure (indices, n, val);
306 ret = value::allocate_computed (dst_type, &opencl_value_funcs, c);
308 else
310 int i;
312 ret = value::allocate (dst_type);
314 /* Copy src val contents into the destination value. */
315 for (i = 0; i < n; i++)
316 memcpy (ret->contents_writeable ().data ()
317 + (i * elm_type->length ()),
318 val->contents ().data ()
319 + (indices[i] * elm_type->length ()),
320 elm_type->length ());
324 return ret;
327 /* OpenCL vector component access. */
329 static struct value *
330 opencl_component_ref (struct expression *exp, struct value *val,
331 const char *comps, enum noside noside)
333 LONGEST lowb, highb;
334 int src_len;
335 struct value *v;
336 int indices[16], i;
337 int dst_len;
339 if (!get_array_bounds (check_typedef (val->type ()), &lowb, &highb))
340 error (_("Could not determine the vector bounds"));
342 src_len = highb - lowb + 1;
344 /* Throw an error if the amount of array elements does not fit a
345 valid OpenCL vector size (2, 3, 4, 8, 16). */
346 if (src_len != 2 && src_len != 3 && src_len != 4 && src_len != 8
347 && src_len != 16)
348 error (_("Invalid OpenCL vector size"));
350 if (strcmp (comps, "lo") == 0 )
352 dst_len = (src_len == 3) ? 2 : src_len / 2;
354 for (i = 0; i < dst_len; i++)
355 indices[i] = i;
357 else if (strcmp (comps, "hi") == 0)
359 dst_len = (src_len == 3) ? 2 : src_len / 2;
361 for (i = 0; i < dst_len; i++)
362 indices[i] = dst_len + i;
364 else if (strcmp (comps, "even") == 0)
366 dst_len = (src_len == 3) ? 2 : src_len / 2;
368 for (i = 0; i < dst_len; i++)
369 indices[i] = i*2;
371 else if (strcmp (comps, "odd") == 0)
373 dst_len = (src_len == 3) ? 2 : src_len / 2;
375 for (i = 0; i < dst_len; i++)
376 indices[i] = i*2+1;
378 else if (strncasecmp (comps, "s", 1) == 0)
380 #define HEXCHAR_TO_INT(C) ((C >= '0' && C <= '9') ? \
381 C-'0' : ((C >= 'A' && C <= 'F') ? \
382 C-'A'+10 : ((C >= 'a' && C <= 'f') ? \
383 C-'a'+10 : -1)))
385 dst_len = strlen (comps);
386 /* Skip the s/S-prefix. */
387 dst_len--;
389 for (i = 0; i < dst_len; i++)
391 indices[i] = HEXCHAR_TO_INT(comps[i+1]);
392 /* Check if the requested component is invalid or exceeds
393 the vector. */
394 if (indices[i] < 0 || indices[i] >= src_len)
395 error (_("Invalid OpenCL vector component accessor %s"), comps);
398 else
400 dst_len = strlen (comps);
402 for (i = 0; i < dst_len; i++)
404 /* x, y, z, w */
405 switch (comps[i])
407 case 'x':
408 indices[i] = 0;
409 break;
410 case 'y':
411 indices[i] = 1;
412 break;
413 case 'z':
414 if (src_len < 3)
415 error (_("Invalid OpenCL vector component accessor %s"), comps);
416 indices[i] = 2;
417 break;
418 case 'w':
419 if (src_len < 4)
420 error (_("Invalid OpenCL vector component accessor %s"), comps);
421 indices[i] = 3;
422 break;
423 default:
424 error (_("Invalid OpenCL vector component accessor %s"), comps);
425 break;
430 /* Throw an error if the amount of requested components does not
431 result in a valid length (1, 2, 3, 4, 8, 16). */
432 if (dst_len != 1 && dst_len != 2 && dst_len != 3 && dst_len != 4
433 && dst_len != 8 && dst_len != 16)
434 error (_("Invalid OpenCL vector component accessor %s"), comps);
436 v = create_value (exp->gdbarch, val, noside, indices, dst_len);
438 return v;
441 /* Perform the unary logical not (!) operation. */
443 struct value *
444 opencl_logical_not (struct type *expect_type, struct expression *exp,
445 enum noside noside, enum exp_opcode op,
446 struct value *arg)
448 struct type *type = check_typedef (arg->type ());
449 struct type *rettype;
450 struct value *ret;
452 if (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
454 struct type *eltype = check_typedef (type->target_type ());
455 LONGEST lowb, highb;
456 int i;
458 if (!get_array_bounds (type, &lowb, &highb))
459 error (_("Could not determine the vector bounds"));
461 /* Determine the resulting type of the operation and allocate the
462 value. */
463 rettype = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT,
464 eltype->length (), 0,
465 highb - lowb + 1);
466 ret = value::allocate (rettype);
468 for (i = 0; i < highb - lowb + 1; i++)
470 /* For vector types, the unary operator shall return a 0 if the
471 value of its operand compares unequal to 0, and -1 (i.e. all bits
472 set) if the value of its operand compares equal to 0. */
473 int tmp = value_logical_not (value_subscript (arg, i)) ? -1 : 0;
474 memset ((ret->contents_writeable ().data ()
475 + i * eltype->length ()),
476 tmp, eltype->length ());
479 else
481 rettype = language_bool_type (exp->language_defn, exp->gdbarch);
482 ret = value_from_longest (rettype, value_logical_not (arg));
485 return ret;
488 /* Perform a relational operation on two scalar operands. */
490 static int
491 scalar_relop (struct value *val1, struct value *val2, enum exp_opcode op)
493 int ret;
495 switch (op)
497 case BINOP_EQUAL:
498 ret = value_equal (val1, val2);
499 break;
500 case BINOP_NOTEQUAL:
501 ret = !value_equal (val1, val2);
502 break;
503 case BINOP_LESS:
504 ret = value_less (val1, val2);
505 break;
506 case BINOP_GTR:
507 ret = value_less (val2, val1);
508 break;
509 case BINOP_GEQ:
510 ret = value_less (val2, val1) || value_equal (val1, val2);
511 break;
512 case BINOP_LEQ:
513 ret = value_less (val1, val2) || value_equal (val1, val2);
514 break;
515 case BINOP_LOGICAL_AND:
516 ret = !value_logical_not (val1) && !value_logical_not (val2);
517 break;
518 case BINOP_LOGICAL_OR:
519 ret = !value_logical_not (val1) || !value_logical_not (val2);
520 break;
521 default:
522 error (_("Attempt to perform an unsupported operation"));
523 break;
525 return ret;
528 /* Perform a relational operation on two vector operands. */
530 static struct value *
531 vector_relop (struct expression *exp, struct value *val1, struct value *val2,
532 enum exp_opcode op)
534 struct value *ret;
535 struct type *type1, *type2, *eltype1, *eltype2, *rettype;
536 int t1_is_vec, t2_is_vec, i;
537 LONGEST lowb1, lowb2, highb1, highb2;
539 type1 = check_typedef (val1->type ());
540 type2 = check_typedef (val2->type ());
542 t1_is_vec = (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ());
543 t2_is_vec = (type2->code () == TYPE_CODE_ARRAY && type2->is_vector ());
545 if (!t1_is_vec || !t2_is_vec)
546 error (_("Vector operations are not supported on scalar types"));
548 eltype1 = check_typedef (type1->target_type ());
549 eltype2 = check_typedef (type2->target_type ());
551 if (!get_array_bounds (type1,&lowb1, &highb1)
552 || !get_array_bounds (type2, &lowb2, &highb2))
553 error (_("Could not determine the vector bounds"));
555 /* Check whether the vector types are compatible. */
556 if (eltype1->code () != eltype2->code ()
557 || eltype1->length () != eltype2->length ()
558 || eltype1->is_unsigned () != eltype2->is_unsigned ()
559 || lowb1 != lowb2 || highb1 != highb2)
560 error (_("Cannot perform operation on vectors with different types"));
562 /* Determine the resulting type of the operation and allocate the value. */
563 rettype = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT,
564 eltype1->length (), 0,
565 highb1 - lowb1 + 1);
566 ret = value::allocate (rettype);
568 for (i = 0; i < highb1 - lowb1 + 1; i++)
570 /* For vector types, the relational, equality and logical operators shall
571 return 0 if the specified relation is false and -1 (i.e. all bits set)
572 if the specified relation is true. */
573 int tmp = scalar_relop (value_subscript (val1, i),
574 value_subscript (val2, i), op) ? -1 : 0;
575 memset ((ret->contents_writeable ().data ()
576 + i * eltype1->length ()),
577 tmp, eltype1->length ());
580 return ret;
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. */
588 struct value *
589 opencl_value_cast (struct type *type, struct value *arg)
591 if (type != arg->type ())
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;
600 int scalar;
602 to_type = check_typedef (type);
604 code1 = to_type->code ();
605 code2 = check_typedef (arg->type ())->code ();
607 if (code2 == TYPE_CODE_REF)
608 code2 = check_typedef (coerce_ref(arg)->type ())->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)
617 struct type *eltype;
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 (to_type->target_type ());
624 arg = value_cast (eltype, arg);
626 return value_vector_widen (arg, type);
628 else
629 /* Standard cast handler. */
630 arg = value_cast (type, arg);
632 return arg;
635 /* Perform a relational operation on two operands. */
637 struct value *
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)
642 struct value *val;
643 struct type *type1 = check_typedef (arg1->type ());
644 struct type *type2 = check_typedef (arg2->type ());
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);
653 struct type *type =
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);
662 else
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);
675 return val;
678 /* A helper function for BINOP_ASSIGN. */
680 struct value *
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)
686 return arg1;
688 struct type *type1 = arg1->type ();
689 if (arg1->deprecated_modifiable ()
690 && arg1->lval () != lval_internalvar)
691 arg2 = opencl_value_cast (type1, arg2);
693 return value_assign (arg1, arg2);
696 namespace expr
699 value *
700 opencl_structop_operation::evaluate (struct type *expect_type,
701 struct expression *exp,
702 enum noside noside)
704 value *arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
705 struct type *type1 = check_typedef (arg1->type ());
707 if (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ())
708 return opencl_component_ref (exp, arg1, std::get<1> (m_storage).c_str (),
709 noside);
710 else
712 struct value *v = value_struct_elt (&arg1, {},
713 std::get<1> (m_storage).c_str (),
714 NULL, "structure");
716 if (noside == EVAL_AVOID_SIDE_EFFECTS)
717 v = value::zero (v->type (), v->lval ());
718 return v;
722 value *
723 opencl_logical_binop_operation::evaluate (struct type *expect_type,
724 struct expression *exp,
725 enum noside noside)
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 (arg1->type ());
738 struct type *type2 = check_typedef (arg2->type ());
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);
747 else
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)
755 tmp = !tmp;
757 if (!tmp)
759 arg2 = std::get<2> (m_storage)->evaluate (nullptr, exp, noside);
760 tmp = value_logical_not (arg2);
761 if (op == BINOP_LOGICAL_OR)
762 tmp = !tmp;
765 type1 = language_bool_type (exp->language_defn, exp->gdbarch);
766 return value_from_longest (type1, tmp);
770 value *
771 opencl_ternop_cond_operation::evaluate (struct type *expect_type,
772 struct expression *exp,
773 enum noside noside)
775 value *arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
776 struct type *type1 = check_typedef (arg1->type ());
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 (arg2->type ());
787 type3 = check_typedef (arg3->type ());
788 t2_is_vec
789 = type2->code () == TYPE_CODE_ARRAY && type2->is_vector ();
790 t3_is_vec
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 = arg3->type ();
799 else if (!t2_is_vec || t3_is_vec)
801 arg2 = opencl_value_cast (type3, arg2);
802 type2 = arg2->type ();
804 else if (!t2_is_vec || !t3_is_vec)
806 /* Throw an error if arg2 or arg3 aren't vectors. */
807 error (_("\
808 Cannot perform conditional operation on incompatible types"));
811 eltype2 = check_typedef (type2->target_type ());
812 eltype3 = check_typedef (type3->target_type ());
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 || eltype2->length () != eltype3->length ()
822 || eltype2->is_unsigned () != eltype3->is_unsigned ()
823 || lowb2 != lowb3 || highb2 != highb3)
824 error (_("\
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)
830 error (_("\
831 Cannot perform conditional operation on vectors with different sizes"));
833 ret = value::allocate (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 (ret->contents_writeable ().data () +
840 i * eltype2->length (), tmp->contents_all ().data (),
841 eltype2->length ());
844 return ret;
846 else
848 if (value_logical_not (arg1))
849 return std::get<2> (m_storage)->evaluate (nullptr, exp, noside);
850 else
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
861 public:
862 opencl_language ()
863 : language_defn (language_opencl)
864 { /* Nothing. */ }
866 /* See language.h. */
868 const char *name () const override
869 { return "opencl"; }
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);
884 return 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) \
893 do \
895 struct type *tmp; \
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 tmp->set_length (4 * (ELEMENT_TYPE)->length ()); \
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)); \
908 while (false)
910 struct type *el_type, *char_type, *int_type;
912 type_allocator alloc (gdbarch);
913 char_type = el_type = add (init_integer_type (alloc, 8, 0, "char"));
914 BUILD_OCL_VTYPES (char, el_type);
915 el_type = add (init_integer_type (alloc, 8, 1, "uchar"));
916 BUILD_OCL_VTYPES (uchar, el_type);
917 el_type = add (init_integer_type (alloc, 16, 0, "short"));
918 BUILD_OCL_VTYPES (short, el_type);
919 el_type = add (init_integer_type (alloc, 16, 1, "ushort"));
920 BUILD_OCL_VTYPES (ushort, el_type);
921 int_type = el_type = add (init_integer_type (alloc, 32, 0, "int"));
922 BUILD_OCL_VTYPES (int, el_type);
923 el_type = add (init_integer_type (alloc, 32, 1, "uint"));
924 BUILD_OCL_VTYPES (uint, el_type);
925 el_type = add (init_integer_type (alloc, 64, 0, "long"));
926 BUILD_OCL_VTYPES (long, el_type);
927 el_type = add (init_integer_type (alloc, 64, 1, "ulong"));
928 BUILD_OCL_VTYPES (ulong, el_type);
929 el_type = add (init_float_type (alloc, 16, "half", floatformats_ieee_half));
930 BUILD_OCL_VTYPES (half, el_type);
931 el_type = add (init_float_type (alloc, 32, "float", floatformats_ieee_single));
932 BUILD_OCL_VTYPES (float, el_type);
933 el_type = add (init_float_type (alloc, 64, "double", floatformats_ieee_double));
934 BUILD_OCL_VTYPES (double, el_type);
936 add (init_boolean_type (alloc, 8, 1, "bool"));
937 add (init_integer_type (alloc, 8, 1, "unsigned char"));
938 add (init_integer_type (alloc, 16, 1, "unsigned short"));
939 add (init_integer_type (alloc, 32, 1, "unsigned int"));
940 add (init_integer_type (alloc, 64, 1, "unsigned long"));
941 add (init_integer_type (alloc, gdbarch_ptr_bit (gdbarch), 1, "size_t"));
942 add (init_integer_type (alloc, gdbarch_ptr_bit (gdbarch), 0, "ptrdiff_t"));
943 add (init_integer_type (alloc, gdbarch_ptr_bit (gdbarch), 0, "intptr_t"));
944 add (init_integer_type (alloc, gdbarch_ptr_bit (gdbarch), 1, "uintptr_t"));
945 add (builtin_type (gdbarch)->builtin_void);
947 /* Type of elements of strings. */
948 lai->set_string_char_type (char_type);
950 /* Specifies the return type of logical and relational operations. */
951 lai->set_bool_type (int_type, "int");
954 /* See language.h. */
956 bool can_print_type_offsets () const override
958 return true;
961 /* See language.h. */
963 void print_type (struct type *type, const char *varstring,
964 struct ui_file *stream, int show, int level,
965 const struct type_print_options *flags) const override
967 /* We nearly always defer to C type printing, except that vector types
968 are considered primitive in OpenCL, and should always be printed
969 using their TYPE_NAME. */
970 if (show > 0)
972 type = check_typedef (type);
973 if (type->code () == TYPE_CODE_ARRAY && type->is_vector ()
974 && type->name () != NULL)
975 show = 0;
978 c_print_type (type, varstring, stream, show, level, la_language, flags);
981 /* See language.h. */
983 enum macro_expansion macro_expansion () const override
984 { return macro_expansion_c; }
987 /* Single instance of the OpenCL language class. */
989 static opencl_language opencl_language_defn;