1 /* OpenCL language support for GDB, the GNU debugger.
2 Copyright (C) 2010-2014 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"
30 extern void _initialize_opencl_language (void);
32 /* This macro generates enum values from a given type. */
34 #define OCL_P_TYPE(TYPE)\
35 opencl_primitive_type_##TYPE,\
36 opencl_primitive_type_##TYPE##2,\
37 opencl_primitive_type_##TYPE##3,\
38 opencl_primitive_type_##TYPE##4,\
39 opencl_primitive_type_##TYPE##8,\
40 opencl_primitive_type_##TYPE##16
42 enum opencl_primitive_types {
54 opencl_primitive_type_bool,
55 opencl_primitive_type_unsigned_char,
56 opencl_primitive_type_unsigned_short,
57 opencl_primitive_type_unsigned_int,
58 opencl_primitive_type_unsigned_long,
59 opencl_primitive_type_size_t,
60 opencl_primitive_type_ptrdiff_t,
61 opencl_primitive_type_intptr_t,
62 opencl_primitive_type_uintptr_t,
63 opencl_primitive_type_void,
64 nr_opencl_primitive_types
67 static struct gdbarch_data *opencl_type_data;
70 builtin_opencl_type (struct gdbarch *gdbarch)
72 return gdbarch_data (gdbarch, opencl_type_data);
75 /* Returns the corresponding OpenCL vector type from the given type code,
76 the length of the element type, the unsigned flag and the amount of
80 lookup_opencl_vector_type (struct gdbarch *gdbarch, enum type_code code,
81 unsigned int el_length, unsigned int flag_unsigned,
86 struct type *type = NULL;
87 struct type **types = builtin_opencl_type (gdbarch);
89 /* Check if n describes a valid OpenCL vector size (2, 3, 4, 8, 16). */
90 if (n != 2 && n != 3 && n != 4 && n != 8 && n != 16)
91 error (_("Invalid OpenCL vector size: %d"), n);
93 /* Triple vectors have the size of a quad vector. */
94 length = (n == 3) ? el_length * 4 : el_length * n;
96 for (i = 0; i < nr_opencl_primitive_types; i++)
100 if (TYPE_CODE (types[i]) == TYPE_CODE_ARRAY && TYPE_VECTOR (types[i])
101 && get_array_bounds (types[i], &lowb, &highb)
102 && TYPE_CODE (TYPE_TARGET_TYPE (types[i])) == code
103 && TYPE_UNSIGNED (TYPE_TARGET_TYPE (types[i])) == flag_unsigned
104 && TYPE_LENGTH (TYPE_TARGET_TYPE (types[i])) == el_length
105 && TYPE_LENGTH (types[i]) == length
106 && highb - lowb + 1 == n)
116 /* Returns nonzero if the array ARR contains duplicates within
117 the first N elements. */
120 array_has_dups (int *arr, int n)
124 for (i = 0; i < n; i++)
126 for (j = i + 1; j < n; j++)
128 if (arr[i] == arr[j])
136 /* The OpenCL component access syntax allows to create lvalues referring to
137 selected elements of an original OpenCL vector in arbitrary order. This
138 structure holds the information to describe such lvalues. */
142 /* Reference count. */
144 /* The number of indices. */
146 /* The element indices themselves. */
148 /* A pointer to the original value. */
152 /* Allocates an instance of struct lval_closure. */
154 static struct lval_closure *
155 allocate_lval_closure (int *indices, int n, struct value *val)
157 struct lval_closure *c = XCNEW (struct lval_closure);
161 c->indices = XCNEWVEC (int, n);
162 memcpy (c->indices, indices, n * sizeof (int));
163 value_incref (val); /* Increment the reference counter of the value. */
170 lval_func_read (struct value *v)
172 struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
173 struct type *type = check_typedef (value_type (v));
174 struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val)));
175 int offset = value_offset (v);
176 int elsize = TYPE_LENGTH (eltype);
181 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
182 && !get_array_bounds (type, &lowb, &highb))
183 error (_("Could not determine the vector bounds"));
185 /* Assume elsize aligned offset. */
186 gdb_assert (offset % elsize == 0);
188 n = offset + highb - lowb + 1;
189 gdb_assert (n <= c->n);
191 for (i = offset; i < n; i++)
192 memcpy (value_contents_raw (v) + j++ * elsize,
193 value_contents (c->val) + c->indices[i] * elsize,
198 lval_func_write (struct value *v, struct value *fromval)
200 struct value *mark = value_mark ();
201 struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
202 struct type *type = check_typedef (value_type (v));
203 struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val)));
204 int offset = value_offset (v);
205 int elsize = TYPE_LENGTH (eltype);
210 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
211 && !get_array_bounds (type, &lowb, &highb))
212 error (_("Could not determine the vector bounds"));
214 /* Assume elsize aligned offset. */
215 gdb_assert (offset % elsize == 0);
217 n = offset + highb - lowb + 1;
219 /* Since accesses to the fourth component of a triple vector is undefined we
220 just skip writes to the fourth element. Imagine something like this:
221 int3 i3 = (int3)(0, 1, 2);
223 In this case n would be 4 (offset=12/4 + 1) while c->n would be 3. */
227 for (i = offset; i < n; i++)
229 struct value *from_elm_val = allocate_value (eltype);
230 struct value *to_elm_val = value_subscript (c->val, c->indices[i]);
232 memcpy (value_contents_writeable (from_elm_val),
233 value_contents (fromval) + j++ * elsize,
235 value_assign (to_elm_val, from_elm_val);
238 value_free_to_mark (mark);
241 /* Return nonzero if all bits in V within OFFSET and LENGTH are valid. */
244 lval_func_check_validity (const struct value *v, int offset, int length)
246 struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
247 /* Size of the target type in bits. */
249 TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
250 int startrest = offset % elsize;
251 int start = offset / elsize;
252 int endrest = (offset + length) % elsize;
253 int end = (offset + length) / elsize;
262 for (i = start; i < end; i++)
264 int comp_offset = (i == start) ? startrest : 0;
265 int comp_length = (i == end) ? endrest : elsize;
267 if (!value_bits_valid (c->val, c->indices[i] * elsize + comp_offset,
275 /* Return nonzero if any bit in V is valid. */
278 lval_func_check_any_valid (const struct value *v)
280 struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
281 /* Size of the target type in bits. */
283 TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
286 for (i = 0; i < c->n; i++)
287 if (value_bits_valid (c->val, c->indices[i] * elsize, elsize))
293 /* Return nonzero if bits in V from OFFSET and LENGTH represent a
294 synthetic pointer. */
297 lval_func_check_synthetic_pointer (const struct value *v,
298 int offset, int length)
300 struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
301 /* Size of the target type in bits. */
303 TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
304 int startrest = offset % elsize;
305 int start = offset / elsize;
306 int endrest = (offset + length) % elsize;
307 int end = (offset + length) / elsize;
316 for (i = start; i < end; i++)
318 int comp_offset = (i == start) ? startrest : 0;
319 int comp_length = (i == end) ? endrest : elsize;
321 if (!value_bits_synthetic_pointer (c->val,
322 c->indices[i] * elsize + comp_offset,
331 lval_func_copy_closure (const struct value *v)
333 struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
341 lval_func_free_closure (struct value *v)
343 struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
349 value_free (c->val); /* Decrement the reference counter of the value. */
355 static const struct lval_funcs opencl_value_funcs =
359 lval_func_check_validity,
360 lval_func_check_any_valid,
362 NULL, /* coerce_ref */
363 lval_func_check_synthetic_pointer,
364 lval_func_copy_closure,
365 lval_func_free_closure
368 /* Creates a sub-vector from VAL. The elements are selected by the indices of
369 an array with the length of N. Supported values for NOSIDE are
370 EVAL_NORMAL and EVAL_AVOID_SIDE_EFFECTS. */
372 static struct value *
373 create_value (struct gdbarch *gdbarch, struct value *val, enum noside noside,
376 struct type *type = check_typedef (value_type (val));
377 struct type *elm_type = TYPE_TARGET_TYPE (type);
380 /* Check if a single component of a vector is requested which means
381 the resulting type is a (primitive) scalar type. */
384 if (noside == EVAL_AVOID_SIDE_EFFECTS)
385 ret = value_zero (elm_type, not_lval);
387 ret = value_subscript (val, indices[0]);
391 /* Multiple components of the vector are requested which means the
392 resulting type is a vector as well. */
393 struct type *dst_type =
394 lookup_opencl_vector_type (gdbarch, TYPE_CODE (elm_type),
395 TYPE_LENGTH (elm_type),
396 TYPE_UNSIGNED (elm_type), n);
398 if (dst_type == NULL)
399 dst_type = init_vector_type (elm_type, n);
401 make_cv_type (TYPE_CONST (type), TYPE_VOLATILE (type), dst_type, NULL);
403 if (noside == EVAL_AVOID_SIDE_EFFECTS)
404 ret = allocate_value (dst_type);
407 /* Check whether to create a lvalue or not. */
408 if (VALUE_LVAL (val) != not_lval && !array_has_dups (indices, n))
410 struct lval_closure *c = allocate_lval_closure (indices, n, val);
411 ret = allocate_computed_value (dst_type, &opencl_value_funcs, c);
417 ret = allocate_value (dst_type);
419 /* Copy src val contents into the destination value. */
420 for (i = 0; i < n; i++)
421 memcpy (value_contents_writeable (ret)
422 + (i * TYPE_LENGTH (elm_type)),
424 + (indices[i] * TYPE_LENGTH (elm_type)),
425 TYPE_LENGTH (elm_type));
432 /* OpenCL vector component access. */
434 static struct value *
435 opencl_component_ref (struct expression *exp, struct value *val, char *comps,
444 if (!get_array_bounds (check_typedef (value_type (val)), &lowb, &highb))
445 error (_("Could not determine the vector bounds"));
447 src_len = highb - lowb + 1;
449 /* Throw an error if the amount of array elements does not fit a
450 valid OpenCL vector size (2, 3, 4, 8, 16). */
451 if (src_len != 2 && src_len != 3 && src_len != 4 && src_len != 8
453 error (_("Invalid OpenCL vector size"));
455 if (strcmp (comps, "lo") == 0 )
457 dst_len = (src_len == 3) ? 2 : src_len / 2;
459 for (i = 0; i < dst_len; i++)
462 else if (strcmp (comps, "hi") == 0)
464 dst_len = (src_len == 3) ? 2 : src_len / 2;
466 for (i = 0; i < dst_len; i++)
467 indices[i] = dst_len + i;
469 else if (strcmp (comps, "even") == 0)
471 dst_len = (src_len == 3) ? 2 : src_len / 2;
473 for (i = 0; i < dst_len; i++)
476 else if (strcmp (comps, "odd") == 0)
478 dst_len = (src_len == 3) ? 2 : src_len / 2;
480 for (i = 0; i < dst_len; i++)
483 else if (strncasecmp (comps, "s", 1) == 0)
485 #define HEXCHAR_TO_INT(C) ((C >= '0' && C <= '9') ? \
486 C-'0' : ((C >= 'A' && C <= 'F') ? \
487 C-'A'+10 : ((C >= 'a' && C <= 'f') ? \
490 dst_len = strlen (comps);
491 /* Skip the s/S-prefix. */
494 for (i = 0; i < dst_len; i++)
496 indices[i] = HEXCHAR_TO_INT(comps[i+1]);
497 /* Check if the requested component is invalid or exceeds
499 if (indices[i] < 0 || indices[i] >= src_len)
500 error (_("Invalid OpenCL vector component accessor %s"), comps);
505 dst_len = strlen (comps);
507 for (i = 0; i < dst_len; i++)
520 error (_("Invalid OpenCL vector component accessor %s"), comps);
525 error (_("Invalid OpenCL vector component accessor %s"), comps);
529 error (_("Invalid OpenCL vector component accessor %s"), comps);
535 /* Throw an error if the amount of requested components does not
536 result in a valid length (1, 2, 3, 4, 8, 16). */
537 if (dst_len != 1 && dst_len != 2 && dst_len != 3 && dst_len != 4
538 && dst_len != 8 && dst_len != 16)
539 error (_("Invalid OpenCL vector component accessor %s"), comps);
541 v = create_value (exp->gdbarch, val, noside, indices, dst_len);
546 /* Perform the unary logical not (!) operation. */
548 static struct value *
549 opencl_logical_not (struct expression *exp, struct value *arg)
551 struct type *type = check_typedef (value_type (arg));
552 struct type *rettype;
555 if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
557 struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
561 if (!get_array_bounds (type, &lowb, &highb))
562 error (_("Could not determine the vector bounds"));
564 /* Determine the resulting type of the operation and allocate the
566 rettype = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT,
567 TYPE_LENGTH (eltype), 0,
569 ret = allocate_value (rettype);
571 for (i = 0; i < highb - lowb + 1; i++)
573 /* For vector types, the unary operator shall return a 0 if the
574 value of its operand compares unequal to 0, and -1 (i.e. all bits
575 set) if the value of its operand compares equal to 0. */
576 int tmp = value_logical_not (value_subscript (arg, i)) ? -1 : 0;
577 memset (value_contents_writeable (ret) + i * TYPE_LENGTH (eltype),
578 tmp, TYPE_LENGTH (eltype));
583 rettype = language_bool_type (exp->language_defn, exp->gdbarch);
584 ret = value_from_longest (rettype, value_logical_not (arg));
590 /* Perform a relational operation on two scalar operands. */
593 scalar_relop (struct value *val1, struct value *val2, enum exp_opcode op)
600 ret = value_equal (val1, val2);
603 ret = !value_equal (val1, val2);
606 ret = value_less (val1, val2);
609 ret = value_less (val2, val1);
612 ret = value_less (val2, val1) || value_equal (val1, val2);
615 ret = value_less (val1, val2) || value_equal (val1, val2);
617 case BINOP_LOGICAL_AND:
618 ret = !value_logical_not (val1) && !value_logical_not (val2);
620 case BINOP_LOGICAL_OR:
621 ret = !value_logical_not (val1) || !value_logical_not (val2);
624 error (_("Attempt to perform an unsupported operation"));
630 /* Perform a relational operation on two vector operands. */
632 static struct value *
633 vector_relop (struct expression *exp, struct value *val1, struct value *val2,
637 struct type *type1, *type2, *eltype1, *eltype2, *rettype;
638 int t1_is_vec, t2_is_vec, i;
639 LONGEST lowb1, lowb2, highb1, highb2;
641 type1 = check_typedef (value_type (val1));
642 type2 = check_typedef (value_type (val2));
644 t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1));
645 t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2));
647 if (!t1_is_vec || !t2_is_vec)
648 error (_("Vector operations are not supported on scalar types"));
650 eltype1 = check_typedef (TYPE_TARGET_TYPE (type1));
651 eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
653 if (!get_array_bounds (type1,&lowb1, &highb1)
654 || !get_array_bounds (type2, &lowb2, &highb2))
655 error (_("Could not determine the vector bounds"));
657 /* Check whether the vector types are compatible. */
658 if (TYPE_CODE (eltype1) != TYPE_CODE (eltype2)
659 || TYPE_LENGTH (eltype1) != TYPE_LENGTH (eltype2)
660 || TYPE_UNSIGNED (eltype1) != TYPE_UNSIGNED (eltype2)
661 || lowb1 != lowb2 || highb1 != highb2)
662 error (_("Cannot perform operation on vectors with different types"));
664 /* Determine the resulting type of the operation and allocate the value. */
665 rettype = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT,
666 TYPE_LENGTH (eltype1), 0,
668 ret = allocate_value (rettype);
670 for (i = 0; i < highb1 - lowb1 + 1; i++)
672 /* For vector types, the relational, equality and logical operators shall
673 return 0 if the specified relation is false and -1 (i.e. all bits set)
674 if the specified relation is true. */
675 int tmp = scalar_relop (value_subscript (val1, i),
676 value_subscript (val2, i), op) ? -1 : 0;
677 memset (value_contents_writeable (ret) + i * TYPE_LENGTH (eltype1),
678 tmp, TYPE_LENGTH (eltype1));
684 /* Perform a cast of ARG into TYPE. There's sadly a lot of duplication in
685 here from valops.c:value_cast, opencl is different only in the
686 behaviour of scalar to vector casting. As far as possibly we're going
687 to try and delegate back to the standard value_cast function. */
689 static struct value *
690 opencl_value_cast (struct type *type, struct value *arg)
692 if (type != value_type (arg))
694 /* Casting scalar to vector is a special case for OpenCL, scalar
695 is cast to element type of vector then replicated into each
696 element of the vector. First though, we need to work out if
697 this is a scalar to vector cast; code lifted from
698 valops.c:value_cast. */
699 enum type_code code1, code2;
700 struct type *to_type;
703 to_type = check_typedef (type);
705 code1 = TYPE_CODE (to_type);
706 code2 = TYPE_CODE (check_typedef (value_type (arg)));
708 if (code2 == TYPE_CODE_REF)
709 code2 = TYPE_CODE (check_typedef (value_type (coerce_ref (arg))));
711 scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL
712 || code2 == TYPE_CODE_CHAR || code2 == TYPE_CODE_FLT
713 || code2 == TYPE_CODE_DECFLOAT || code2 == TYPE_CODE_ENUM
714 || code2 == TYPE_CODE_RANGE);
716 if (code1 == TYPE_CODE_ARRAY && TYPE_VECTOR (to_type) && scalar)
720 /* Cast to the element type of the vector here as
721 value_vector_widen will error if the scalar value is
722 truncated by the cast. To avoid the error, cast (and
723 possibly truncate) here. */
724 eltype = check_typedef (TYPE_TARGET_TYPE (to_type));
725 arg = value_cast (eltype, arg);
727 return value_vector_widen (arg, type);
730 /* Standard cast handler. */
731 arg = value_cast (type, arg);
736 /* Perform a relational operation on two operands. */
738 static struct value *
739 opencl_relop (struct expression *exp, struct value *arg1, struct value *arg2,
743 struct type *type1 = check_typedef (value_type (arg1));
744 struct type *type2 = check_typedef (value_type (arg2));
745 int t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
746 && TYPE_VECTOR (type1));
747 int t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
748 && TYPE_VECTOR (type2));
750 if (!t1_is_vec && !t2_is_vec)
752 int tmp = scalar_relop (arg1, arg2, op);
754 language_bool_type (exp->language_defn, exp->gdbarch);
756 val = value_from_longest (type, tmp);
758 else if (t1_is_vec && t2_is_vec)
760 val = vector_relop (exp, arg1, arg2, op);
764 /* Widen the scalar operand to a vector. */
765 struct value **v = t1_is_vec ? &arg2 : &arg1;
766 struct type *t = t1_is_vec ? type2 : type1;
768 if (TYPE_CODE (t) != TYPE_CODE_FLT && !is_integral_type (t))
769 error (_("Argument to operation not a number or boolean."));
771 *v = opencl_value_cast (t1_is_vec ? type1 : type2, *v);
772 val = vector_relop (exp, arg1, arg2, op);
778 /* Expression evaluator for the OpenCL. Most operations are delegated to
779 evaluate_subexp_standard; see that function for a description of the
782 static struct value *
783 evaluate_subexp_opencl (struct type *expect_type, struct expression *exp,
784 int *pos, enum noside noside)
786 enum exp_opcode op = exp->elts[*pos].opcode;
787 struct value *arg1 = NULL;
788 struct value *arg2 = NULL;
789 struct type *type1, *type2;
793 /* Handle assignment and cast operators to support OpenCL-style
794 scalar-to-vector widening. */
797 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
798 type1 = value_type (arg1);
799 arg2 = evaluate_subexp (type1, exp, pos, noside);
801 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
804 if (deprecated_value_modifiable (arg1)
805 && VALUE_LVAL (arg1) != lval_internalvar)
806 arg2 = opencl_value_cast (type1, arg2);
808 return value_assign (arg1, arg2);
811 type1 = exp->elts[*pos + 1].type;
813 arg1 = evaluate_subexp (type1, exp, pos, noside);
815 if (noside == EVAL_SKIP)
816 return value_from_longest (builtin_type (exp->gdbarch)->
819 return opencl_value_cast (type1, arg1);
823 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
824 type1 = value_type (arg1);
825 arg1 = evaluate_subexp (type1, exp, pos, noside);
827 if (noside == EVAL_SKIP)
828 return value_from_longest (builtin_type (exp->gdbarch)->
831 return opencl_value_cast (type1, arg1);
833 /* Handle binary relational and equality operators that are either not
834 or differently defined for GNU vectors. */
842 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
843 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
845 if (noside == EVAL_SKIP)
846 return value_from_longest (builtin_type (exp->gdbarch)->
849 return opencl_relop (exp, arg1, arg2, op);
851 /* Handle the logical unary operator not(!). */
852 case UNOP_LOGICAL_NOT:
854 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
856 if (noside == EVAL_SKIP)
857 return value_from_longest (builtin_type (exp->gdbarch)->
860 return opencl_logical_not (exp, arg1);
862 /* Handle the logical operator and(&&) and or(||). */
863 case BINOP_LOGICAL_AND:
864 case BINOP_LOGICAL_OR:
866 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
868 if (noside == EVAL_SKIP)
870 evaluate_subexp (NULL_TYPE, exp, pos, noside);
872 return value_from_longest (builtin_type (exp->gdbarch)->
877 /* For scalar operations we need to avoid evaluating operands
878 unecessarily. However, for vector operations we always need to
879 evaluate both operands. Unfortunately we only know which of the
880 two cases apply after we know the type of the second operand.
881 Therefore we evaluate it once using EVAL_AVOID_SIDE_EFFECTS. */
884 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
885 EVAL_AVOID_SIDE_EFFECTS);
887 type1 = check_typedef (value_type (arg1));
888 type2 = check_typedef (value_type (arg2));
890 if ((TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
891 || (TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2)))
893 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
895 return opencl_relop (exp, arg1, arg2, op);
899 /* For scalar built-in types, only evaluate the right
900 hand operand if the left hand operand compares
901 unequal(&&)/equal(||) to 0. */
903 int tmp = value_logical_not (arg1);
905 if (op == BINOP_LOGICAL_OR)
908 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
909 tmp ? EVAL_SKIP : noside);
910 type1 = language_bool_type (exp->language_defn, exp->gdbarch);
912 if (op == BINOP_LOGICAL_AND)
913 res = !tmp && !value_logical_not (arg2);
914 else /* BINOP_LOGICAL_OR */
915 res = tmp || !value_logical_not (arg2);
917 return value_from_longest (type1, res);
921 /* Handle the ternary selection operator. */
924 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
925 type1 = check_typedef (value_type (arg1));
926 if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
928 struct value *arg3, *tmp, *ret;
929 struct type *eltype2, *type3, *eltype3;
930 int t2_is_vec, t3_is_vec, i;
931 LONGEST lowb1, lowb2, lowb3, highb1, highb2, highb3;
933 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
934 arg3 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
935 type2 = check_typedef (value_type (arg2));
936 type3 = check_typedef (value_type (arg3));
938 = TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2);
940 = TYPE_CODE (type3) == TYPE_CODE_ARRAY && TYPE_VECTOR (type3);
942 /* Widen the scalar operand to a vector if necessary. */
943 if (t2_is_vec || !t3_is_vec)
945 arg3 = opencl_value_cast (type2, arg3);
946 type3 = value_type (arg3);
948 else if (!t2_is_vec || t3_is_vec)
950 arg2 = opencl_value_cast (type3, arg2);
951 type2 = value_type (arg2);
953 else if (!t2_is_vec || !t3_is_vec)
955 /* Throw an error if arg2 or arg3 aren't vectors. */
957 Cannot perform conditional operation on incompatible types"));
960 eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
961 eltype3 = check_typedef (TYPE_TARGET_TYPE (type3));
963 if (!get_array_bounds (type1, &lowb1, &highb1)
964 || !get_array_bounds (type2, &lowb2, &highb2)
965 || !get_array_bounds (type3, &lowb3, &highb3))
966 error (_("Could not determine the vector bounds"));
968 /* Throw an error if the types of arg2 or arg3 are incompatible. */
969 if (TYPE_CODE (eltype2) != TYPE_CODE (eltype3)
970 || TYPE_LENGTH (eltype2) != TYPE_LENGTH (eltype3)
971 || TYPE_UNSIGNED (eltype2) != TYPE_UNSIGNED (eltype3)
972 || lowb2 != lowb3 || highb2 != highb3)
974 Cannot perform operation on vectors with different types"));
976 /* Throw an error if the sizes of arg1 and arg2/arg3 differ. */
977 if (lowb1 != lowb2 || lowb1 != lowb3
978 || highb1 != highb2 || highb1 != highb3)
980 Cannot perform conditional operation on vectors with different sizes"));
982 ret = allocate_value (type2);
984 for (i = 0; i < highb1 - lowb1 + 1; i++)
986 tmp = value_logical_not (value_subscript (arg1, i)) ?
987 value_subscript (arg3, i) : value_subscript (arg2, i);
988 memcpy (value_contents_writeable (ret) +
989 i * TYPE_LENGTH (eltype2), value_contents_all (tmp),
990 TYPE_LENGTH (eltype2));
997 if (value_logical_not (arg1))
999 /* Skip the second operand. */
1000 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1002 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
1006 /* Skip the third operand. */
1007 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1008 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1014 /* Handle STRUCTOP_STRUCT to allow component access on OpenCL vectors. */
1015 case STRUCTOP_STRUCT:
1018 int tem = longest_to_int (exp->elts[pc + 1].longconst);
1020 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1021 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1022 type1 = check_typedef (value_type (arg1));
1024 if (noside == EVAL_SKIP)
1026 return value_from_longest (builtin_type (exp->gdbarch)->
1029 else if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
1031 return opencl_component_ref (exp, arg1, &exp->elts[pc + 2].string,
1036 struct value *v = value_struct_elt (&arg1, NULL,
1037 &exp->elts[pc + 2].string, NULL,
1040 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1041 v = value_zero (value_type (v), not_lval);
1049 return evaluate_subexp_c (expect_type, exp, pos, noside);
1052 /* Print OpenCL types. */
1055 opencl_print_type (struct type *type, const char *varstring,
1056 struct ui_file *stream, int show, int level,
1057 const struct type_print_options *flags)
1059 /* We nearly always defer to C type printing, except that vector
1060 types are considered primitive in OpenCL, and should always
1061 be printed using their TYPE_NAME. */
1064 CHECK_TYPEDEF (type);
1065 if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type)
1066 && TYPE_NAME (type) != NULL)
1070 c_print_type (type, varstring, stream, show, level, flags);
1074 opencl_language_arch_info (struct gdbarch *gdbarch,
1075 struct language_arch_info *lai)
1077 struct type **types = builtin_opencl_type (gdbarch);
1079 /* Copy primitive types vector from gdbarch. */
1080 lai->primitive_type_vector = types;
1082 /* Type of elements of strings. */
1083 lai->string_char_type = types [opencl_primitive_type_char];
1085 /* Specifies the return type of logical and relational operations. */
1086 lai->bool_type_symbol = "int";
1087 lai->bool_type_default = types [opencl_primitive_type_int];
1090 const struct exp_descriptor exp_descriptor_opencl =
1092 print_subexp_standard,
1093 operator_length_standard,
1094 operator_check_standard,
1096 dump_subexp_body_standard,
1097 evaluate_subexp_opencl
1100 const struct language_defn opencl_language_defn =
1102 "opencl", /* Language name */
1109 &exp_descriptor_opencl,
1113 c_printchar, /* Print a character constant */
1114 c_printstr, /* Function to print string constant */
1115 c_emit_char, /* Print a single char */
1116 opencl_print_type, /* Print a type using appropriate syntax */
1117 c_print_typedef, /* Print a typedef using appropriate syntax */
1118 c_val_print, /* Print a value using appropriate syntax */
1119 c_value_print, /* Print a top-level value */
1120 default_read_var_value, /* la_read_var_value */
1121 NULL, /* Language specific skip_trampoline */
1122 NULL, /* name_of_this */
1123 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1124 basic_lookup_transparent_type,/* lookup_transparent_type */
1125 NULL, /* Language specific symbol demangler */
1126 NULL, /* Language specific
1127 class_name_from_physname */
1128 c_op_print_tab, /* expression operators for printing */
1129 1, /* c-style arrays */
1130 0, /* String lower bound */
1131 default_word_break_characters,
1132 default_make_symbol_completion_list,
1133 opencl_language_arch_info,
1134 default_print_array_index,
1135 default_pass_by_reference,
1137 NULL, /* la_get_symbol_name_cmp */
1138 iterate_over_symbols,
1139 &default_varobj_ops,
1144 build_opencl_types (struct gdbarch *gdbarch)
1147 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_opencl_primitive_types + 1,
1150 /* Helper macro to create strings. */
1151 #define OCL_STRING(S) #S
1152 /* This macro allocates and assigns the type struct pointers
1153 for the vector types. */
1154 #define BUILD_OCL_VTYPES(TYPE)\
1155 types[opencl_primitive_type_##TYPE##2] \
1156 = init_vector_type (types[opencl_primitive_type_##TYPE], 2); \
1157 TYPE_NAME (types[opencl_primitive_type_##TYPE##2]) = OCL_STRING(TYPE ## 2); \
1158 types[opencl_primitive_type_##TYPE##3] \
1159 = init_vector_type (types[opencl_primitive_type_##TYPE], 3); \
1160 TYPE_NAME (types[opencl_primitive_type_##TYPE##3]) = OCL_STRING(TYPE ## 3); \
1161 TYPE_LENGTH (types[opencl_primitive_type_##TYPE##3]) \
1162 = 4 * TYPE_LENGTH (types[opencl_primitive_type_##TYPE]); \
1163 types[opencl_primitive_type_##TYPE##4] \
1164 = init_vector_type (types[opencl_primitive_type_##TYPE], 4); \
1165 TYPE_NAME (types[opencl_primitive_type_##TYPE##4]) = OCL_STRING(TYPE ## 4); \
1166 types[opencl_primitive_type_##TYPE##8] \
1167 = init_vector_type (types[opencl_primitive_type_##TYPE], 8); \
1168 TYPE_NAME (types[opencl_primitive_type_##TYPE##8]) = OCL_STRING(TYPE ## 8); \
1169 types[opencl_primitive_type_##TYPE##16] \
1170 = init_vector_type (types[opencl_primitive_type_##TYPE], 16); \
1171 TYPE_NAME (types[opencl_primitive_type_##TYPE##16]) = OCL_STRING(TYPE ## 16)
1173 types[opencl_primitive_type_char]
1174 = arch_integer_type (gdbarch, 8, 0, "char");
1175 BUILD_OCL_VTYPES (char);
1176 types[opencl_primitive_type_uchar]
1177 = arch_integer_type (gdbarch, 8, 1, "uchar");
1178 BUILD_OCL_VTYPES (uchar);
1179 types[opencl_primitive_type_short]
1180 = arch_integer_type (gdbarch, 16, 0, "short");
1181 BUILD_OCL_VTYPES (short);
1182 types[opencl_primitive_type_ushort]
1183 = arch_integer_type (gdbarch, 16, 1, "ushort");
1184 BUILD_OCL_VTYPES (ushort);
1185 types[opencl_primitive_type_int]
1186 = arch_integer_type (gdbarch, 32, 0, "int");
1187 BUILD_OCL_VTYPES (int);
1188 types[opencl_primitive_type_uint]
1189 = arch_integer_type (gdbarch, 32, 1, "uint");
1190 BUILD_OCL_VTYPES (uint);
1191 types[opencl_primitive_type_long]
1192 = arch_integer_type (gdbarch, 64, 0, "long");
1193 BUILD_OCL_VTYPES (long);
1194 types[opencl_primitive_type_ulong]
1195 = arch_integer_type (gdbarch, 64, 1, "ulong");
1196 BUILD_OCL_VTYPES (ulong);
1197 types[opencl_primitive_type_half]
1198 = arch_float_type (gdbarch, 16, "half", floatformats_ieee_half);
1199 BUILD_OCL_VTYPES (half);
1200 types[opencl_primitive_type_float]
1201 = arch_float_type (gdbarch, 32, "float", floatformats_ieee_single);
1202 BUILD_OCL_VTYPES (float);
1203 types[opencl_primitive_type_double]
1204 = arch_float_type (gdbarch, 64, "double", floatformats_ieee_double);
1205 BUILD_OCL_VTYPES (double);
1206 types[opencl_primitive_type_bool]
1207 = arch_boolean_type (gdbarch, 8, 1, "bool");
1208 types[opencl_primitive_type_unsigned_char]
1209 = arch_integer_type (gdbarch, 8, 1, "unsigned char");
1210 types[opencl_primitive_type_unsigned_short]
1211 = arch_integer_type (gdbarch, 16, 1, "unsigned short");
1212 types[opencl_primitive_type_unsigned_int]
1213 = arch_integer_type (gdbarch, 32, 1, "unsigned int");
1214 types[opencl_primitive_type_unsigned_long]
1215 = arch_integer_type (gdbarch, 64, 1, "unsigned long");
1216 types[opencl_primitive_type_size_t]
1217 = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "size_t");
1218 types[opencl_primitive_type_ptrdiff_t]
1219 = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "ptrdiff_t");
1220 types[opencl_primitive_type_intptr_t]
1221 = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "intptr_t");
1222 types[opencl_primitive_type_uintptr_t]
1223 = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "uintptr_t");
1224 types[opencl_primitive_type_void]
1225 = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
1230 /* Provide a prototype to silence -Wmissing-prototypes. */
1231 extern initialize_file_ftype _initialize_opencl_language;
1234 _initialize_opencl_language (void)
1236 opencl_type_data = gdbarch_data_register_post_init (build_opencl_types);
1237 add_language (&opencl_language_defn);