1 /* OpenCL language support for GDB, the GNU debugger.
2 Copyright (C) 2010, 2011 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/>. */
22 #include "gdb_string.h"
25 #include "expression.h"
26 #include "parser-defs.h"
30 #include "gdb_assert.h"
32 extern void _initialize_opencl_language (void);
34 /* This macro generates enum values from a given type. */
36 #define OCL_P_TYPE(TYPE)\
37 opencl_primitive_type_##TYPE,\
38 opencl_primitive_type_##TYPE##2,\
39 opencl_primitive_type_##TYPE##3,\
40 opencl_primitive_type_##TYPE##4,\
41 opencl_primitive_type_##TYPE##8,\
42 opencl_primitive_type_##TYPE##16
44 enum opencl_primitive_types
{
56 opencl_primitive_type_bool
,
57 opencl_primitive_type_unsigned_char
,
58 opencl_primitive_type_unsigned_short
,
59 opencl_primitive_type_unsigned_int
,
60 opencl_primitive_type_unsigned_long
,
61 opencl_primitive_type_size_t
,
62 opencl_primitive_type_ptrdiff_t
,
63 opencl_primitive_type_intptr_t
,
64 opencl_primitive_type_uintptr_t
,
65 opencl_primitive_type_void
,
66 nr_opencl_primitive_types
69 static struct gdbarch_data
*opencl_type_data
;
72 builtin_opencl_type (struct gdbarch
*gdbarch
)
74 return gdbarch_data (gdbarch
, opencl_type_data
);
77 /* Returns the corresponding OpenCL vector type from the given type code,
78 the length of the element type, the unsigned flag and the amount of
82 lookup_opencl_vector_type (struct gdbarch
*gdbarch
, enum type_code code
,
83 unsigned int el_length
, unsigned int flag_unsigned
,
88 struct type
*type
= NULL
;
89 struct type
**types
= builtin_opencl_type (gdbarch
);
91 /* Check if n describes a valid OpenCL vector size (2, 3, 4, 8, 16). */
92 if (n
!= 2 && n
!= 3 && n
!= 4 && n
!= 8 && n
!= 16)
93 error (_("Invalid OpenCL vector size: %d"), n
);
95 /* Triple vectors have the size of a quad vector. */
96 length
= (n
== 3) ? el_length
* 4 : el_length
* n
;
98 for (i
= 0; i
< nr_opencl_primitive_types
; i
++)
102 if (TYPE_CODE (types
[i
]) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (types
[i
])
103 && get_array_bounds (types
[i
], &lowb
, &highb
)
104 && TYPE_CODE (TYPE_TARGET_TYPE (types
[i
])) == code
105 && TYPE_UNSIGNED (TYPE_TARGET_TYPE (types
[i
])) == flag_unsigned
106 && TYPE_LENGTH (TYPE_TARGET_TYPE (types
[i
])) == el_length
107 && TYPE_LENGTH (types
[i
]) == length
108 && highb
- lowb
+ 1 == n
)
118 /* Returns nonzero if the array ARR contains duplicates within
119 the first N elements. */
122 array_has_dups (int *arr
, int n
)
126 for (i
= 0; i
< n
; i
++)
128 for (j
= i
+ 1; j
< n
; j
++)
130 if (arr
[i
] == arr
[j
])
138 /* The OpenCL component access syntax allows to create lvalues referring to
139 selected elements of an original OpenCL vector in arbitrary order. This
140 structure holds the information to describe such lvalues. */
144 /* Reference count. */
146 /* The number of indices. */
148 /* The element indices themselves. */
150 /* A pointer to the original value. */
154 /* Allocates an instance of struct lval_closure. */
156 static struct lval_closure
*
157 allocate_lval_closure (int *indices
, int n
, struct value
*val
)
159 struct lval_closure
*c
= XZALLOC (struct lval_closure
);
163 c
->indices
= XCALLOC (n
, int);
164 memcpy (c
->indices
, indices
, n
* sizeof (int));
165 value_incref (val
); /* Increment the reference counter of the value. */
172 lval_func_read (struct value
*v
)
174 struct lval_closure
*c
= (struct lval_closure
*) value_computed_closure (v
);
175 struct type
*type
= check_typedef (value_type (v
));
176 struct type
*eltype
= TYPE_TARGET_TYPE (check_typedef (value_type (c
->val
)));
177 int offset
= value_offset (v
);
178 int elsize
= TYPE_LENGTH (eltype
);
183 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
184 && !get_array_bounds (type
, &lowb
, &highb
))
185 error (_("Could not determine the vector bounds"));
187 /* Assume elsize aligned offset. */
188 gdb_assert (offset
% elsize
== 0);
190 n
= offset
+ highb
- lowb
+ 1;
191 gdb_assert (n
<= c
->n
);
193 for (i
= offset
; i
< n
; i
++)
194 memcpy (value_contents_raw (v
) + j
++ * elsize
,
195 value_contents (c
->val
) + c
->indices
[i
] * elsize
,
200 lval_func_write (struct value
*v
, struct value
*fromval
)
202 struct value
*mark
= value_mark ();
203 struct lval_closure
*c
= (struct lval_closure
*) value_computed_closure (v
);
204 struct type
*type
= check_typedef (value_type (v
));
205 struct type
*eltype
= TYPE_TARGET_TYPE (check_typedef (value_type (c
->val
)));
206 int offset
= value_offset (v
);
207 int elsize
= TYPE_LENGTH (eltype
);
212 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
213 && !get_array_bounds (type
, &lowb
, &highb
))
214 error (_("Could not determine the vector bounds"));
216 /* Assume elsize aligned offset. */
217 gdb_assert (offset
% elsize
== 0);
219 n
= offset
+ highb
- lowb
+ 1;
221 /* Since accesses to the fourth component of a triple vector is undefined we
222 just skip writes to the fourth element. Imagine something like this:
223 int3 i3 = (int3)(0, 1, 2);
225 In this case n would be 4 (offset=12/4 + 1) while c->n would be 3. */
229 for (i
= offset
; i
< n
; i
++)
231 struct value
*from_elm_val
= allocate_value (eltype
);
232 struct value
*to_elm_val
= value_subscript (c
->val
, c
->indices
[i
]);
234 memcpy (value_contents_writeable (from_elm_val
),
235 value_contents (fromval
) + j
++ * elsize
,
237 value_assign (to_elm_val
, from_elm_val
);
240 value_free_to_mark (mark
);
243 /* Return nonzero if all bits in V within OFFSET and LENGTH are valid. */
246 lval_func_check_validity (const struct value
*v
, int offset
, int length
)
248 struct lval_closure
*c
= (struct lval_closure
*) value_computed_closure (v
);
249 /* Size of the target type in bits. */
251 TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c
->val
)))) * 8;
252 int startrest
= offset
% elsize
;
253 int start
= offset
/ elsize
;
254 int endrest
= (offset
+ length
) % elsize
;
255 int end
= (offset
+ length
) / elsize
;
264 for (i
= start
; i
< end
; i
++)
266 int comp_offset
= (i
== start
) ? startrest
: 0;
267 int comp_length
= (i
== end
) ? endrest
: elsize
;
269 if (!value_bits_valid (c
->val
, c
->indices
[i
] * elsize
+ comp_offset
,
277 /* Return nonzero if any bit in V is valid. */
280 lval_func_check_any_valid (const struct value
*v
)
282 struct lval_closure
*c
= (struct lval_closure
*) value_computed_closure (v
);
283 /* Size of the target type in bits. */
285 TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c
->val
)))) * 8;
288 for (i
= 0; i
< c
->n
; i
++)
289 if (value_bits_valid (c
->val
, c
->indices
[i
] * elsize
, elsize
))
295 /* Return nonzero if bits in V from OFFSET and LENGTH represent a
296 synthetic pointer. */
299 lval_func_check_synthetic_pointer (const struct value
*v
,
300 int offset
, int length
)
302 struct lval_closure
*c
= (struct lval_closure
*) value_computed_closure (v
);
303 /* Size of the target type in bits. */
305 TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c
->val
)))) * 8;
306 int startrest
= offset
% elsize
;
307 int start
= offset
/ elsize
;
308 int endrest
= (offset
+ length
) % elsize
;
309 int end
= (offset
+ length
) / elsize
;
318 for (i
= start
; i
< end
; i
++)
320 int comp_offset
= (i
== start
) ? startrest
: 0;
321 int comp_length
= (i
== end
) ? endrest
: elsize
;
323 if (!value_bits_synthetic_pointer (c
->val
,
324 c
->indices
[i
] * elsize
+ comp_offset
,
333 lval_func_copy_closure (const struct value
*v
)
335 struct lval_closure
*c
= (struct lval_closure
*) value_computed_closure (v
);
343 lval_func_free_closure (struct value
*v
)
345 struct lval_closure
*c
= (struct lval_closure
*) value_computed_closure (v
);
351 value_free (c
->val
); /* Decrement the reference counter of the value. */
357 static struct lval_funcs opencl_value_funcs
=
361 lval_func_check_validity
,
362 lval_func_check_any_valid
,
364 lval_func_check_synthetic_pointer
,
365 lval_func_copy_closure
,
366 lval_func_free_closure
369 /* Creates a sub-vector from VAL. The elements are selected by the indices of
370 an array with the length of N. Supported values for NOSIDE are
371 EVAL_NORMAL and EVAL_AVOID_SIDE_EFFECTS. */
373 static struct value
*
374 create_value (struct gdbarch
*gdbarch
, struct value
*val
, enum noside noside
,
377 struct type
*type
= check_typedef (value_type (val
));
378 struct type
*elm_type
= TYPE_TARGET_TYPE (type
);
381 /* Check if a single component of a vector is requested which means
382 the resulting type is a (primitive) scalar type. */
385 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
386 ret
= value_zero (elm_type
, not_lval
);
388 ret
= value_subscript (val
, indices
[0]);
392 /* Multiple components of the vector are requested which means the
393 resulting type is a vector as well. */
394 struct type
*dst_type
=
395 lookup_opencl_vector_type (gdbarch
, TYPE_CODE (elm_type
),
396 TYPE_LENGTH (elm_type
),
397 TYPE_UNSIGNED (elm_type
), n
);
399 if (dst_type
== NULL
)
400 dst_type
= init_vector_type (elm_type
, n
);
402 make_cv_type (TYPE_CONST (type
), TYPE_VOLATILE (type
), dst_type
, NULL
);
404 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
405 ret
= allocate_value (dst_type
);
408 /* Check whether to create a lvalue or not. */
409 if (VALUE_LVAL (val
) != not_lval
&& !array_has_dups (indices
, n
))
411 struct lval_closure
*c
= allocate_lval_closure (indices
, n
, val
);
412 ret
= allocate_computed_value (dst_type
, &opencl_value_funcs
, c
);
418 ret
= allocate_value (dst_type
);
420 /* Copy src val contents into the destination value. */
421 for (i
= 0; i
< n
; i
++)
422 memcpy (value_contents_writeable (ret
)
423 + (i
* TYPE_LENGTH (elm_type
)),
425 + (indices
[i
] * TYPE_LENGTH (elm_type
)),
426 TYPE_LENGTH (elm_type
));
433 /* OpenCL vector component access. */
435 static struct value
*
436 opencl_component_ref (struct expression
*exp
, struct value
*val
, char *comps
,
445 if (!get_array_bounds (check_typedef (value_type (val
)), &lowb
, &highb
))
446 error (_("Could not determine the vector bounds"));
448 src_len
= highb
- lowb
+ 1;
450 /* Throw an error if the amount of array elements does not fit a
451 valid OpenCL vector size (2, 3, 4, 8, 16). */
452 if (src_len
!= 2 && src_len
!= 3 && src_len
!= 4 && src_len
!= 8
454 error (_("Invalid OpenCL vector size"));
456 if (strcmp (comps
, "lo") == 0 )
458 dst_len
= (src_len
== 3) ? 2 : src_len
/ 2;
460 for (i
= 0; i
< dst_len
; i
++)
463 else if (strcmp (comps
, "hi") == 0)
465 dst_len
= (src_len
== 3) ? 2 : src_len
/ 2;
467 for (i
= 0; i
< dst_len
; i
++)
468 indices
[i
] = dst_len
+ i
;
470 else if (strcmp (comps
, "even") == 0)
472 dst_len
= (src_len
== 3) ? 2 : src_len
/ 2;
474 for (i
= 0; i
< dst_len
; i
++)
477 else if (strcmp (comps
, "odd") == 0)
479 dst_len
= (src_len
== 3) ? 2 : src_len
/ 2;
481 for (i
= 0; i
< dst_len
; i
++)
484 else if (strncasecmp (comps
, "s", 1) == 0)
486 #define HEXCHAR_TO_INT(C) ((C >= '0' && C <= '9') ? \
487 C-'0' : ((C >= 'A' && C <= 'F') ? \
488 C-'A'+10 : ((C >= 'a' && C <= 'f') ? \
491 dst_len
= strlen (comps
);
492 /* Skip the s/S-prefix. */
495 for (i
= 0; i
< dst_len
; i
++)
497 indices
[i
] = HEXCHAR_TO_INT(comps
[i
+1]);
498 /* Check if the requested component is invalid or exceeds
500 if (indices
[i
] < 0 || indices
[i
] >= src_len
)
501 error (_("Invalid OpenCL vector component accessor %s"), comps
);
506 dst_len
= strlen (comps
);
508 for (i
= 0; i
< dst_len
; i
++)
521 error (_("Invalid OpenCL vector component accessor %s"), comps
);
526 error (_("Invalid OpenCL vector component accessor %s"), comps
);
530 error (_("Invalid OpenCL vector component accessor %s"), comps
);
536 /* Throw an error if the amount of requested components does not
537 result in a valid length (1, 2, 3, 4, 8, 16). */
538 if (dst_len
!= 1 && dst_len
!= 2 && dst_len
!= 3 && dst_len
!= 4
539 && dst_len
!= 8 && dst_len
!= 16)
540 error (_("Invalid OpenCL vector component accessor %s"), comps
);
542 v
= create_value (exp
->gdbarch
, val
, noside
, indices
, dst_len
);
547 /* Perform the unary logical not (!) operation. */
549 static struct value
*
550 opencl_logical_not (struct expression
*exp
, struct value
*arg
)
552 struct type
*type
= check_typedef (value_type (arg
));
553 struct type
*rettype
;
556 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
))
558 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
562 if (!get_array_bounds (type
, &lowb
, &highb
))
563 error (_("Could not determine the vector bounds"));
565 /* Determine the resulting type of the operation and allocate the
567 rettype
= lookup_opencl_vector_type (exp
->gdbarch
, TYPE_CODE_INT
,
568 TYPE_LENGTH (eltype
), 0,
570 ret
= allocate_value (rettype
);
572 for (i
= 0; i
< highb
- lowb
+ 1; i
++)
574 /* For vector types, the unary operator shall return a 0 if the
575 value of its operand compares unequal to 0, and -1 (i.e. all bits
576 set) if the value of its operand compares equal to 0. */
577 int tmp
= value_logical_not (value_subscript (arg
, i
)) ? -1 : 0;
578 memset (value_contents_writeable (ret
) + i
* TYPE_LENGTH (eltype
),
579 tmp
, TYPE_LENGTH (eltype
));
584 rettype
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
585 ret
= value_from_longest (rettype
, value_logical_not (arg
));
591 /* Perform a relational operation on two scalar operands. */
594 scalar_relop (struct value
*val1
, struct value
*val2
, enum exp_opcode op
)
601 ret
= value_equal (val1
, val2
);
604 ret
= !value_equal (val1
, val2
);
607 ret
= value_less (val1
, val2
);
610 ret
= value_less (val2
, val1
);
613 ret
= value_less (val2
, val1
) || value_equal (val1
, val2
);
616 ret
= value_less (val1
, val2
) || value_equal (val1
, val2
);
618 case BINOP_LOGICAL_AND
:
619 ret
= !value_logical_not (val1
) && !value_logical_not (val2
);
621 case BINOP_LOGICAL_OR
:
622 ret
= !value_logical_not (val1
) || !value_logical_not (val2
);
625 error (_("Attempt to perform an unsupported operation"));
631 /* Perform a relational operation on two vector operands. */
633 static struct value
*
634 vector_relop (struct expression
*exp
, struct value
*val1
, struct value
*val2
,
638 struct type
*type1
, *type2
, *eltype1
, *eltype2
, *rettype
;
639 int t1_is_vec
, t2_is_vec
, i
;
640 LONGEST lowb1
, lowb2
, highb1
, highb2
;
642 type1
= check_typedef (value_type (val1
));
643 type2
= check_typedef (value_type (val2
));
645 t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type1
));
646 t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type2
));
648 if (!t1_is_vec
|| !t2_is_vec
)
649 error (_("Vector operations are not supported on scalar types"));
651 eltype1
= check_typedef (TYPE_TARGET_TYPE (type1
));
652 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
));
654 if (!get_array_bounds (type1
,&lowb1
, &highb1
)
655 || !get_array_bounds (type2
, &lowb2
, &highb2
))
656 error (_("Could not determine the vector bounds"));
658 /* Check whether the vector types are compatible. */
659 if (TYPE_CODE (eltype1
) != TYPE_CODE (eltype2
)
660 || TYPE_LENGTH (eltype1
) != TYPE_LENGTH (eltype2
)
661 || TYPE_UNSIGNED (eltype1
) != TYPE_UNSIGNED (eltype2
)
662 || lowb1
!= lowb2
|| highb1
!= highb2
)
663 error (_("Cannot perform operation on vectors with different types"));
665 /* Determine the resulting type of the operation and allocate the value. */
666 rettype
= lookup_opencl_vector_type (exp
->gdbarch
, TYPE_CODE_INT
,
667 TYPE_LENGTH (eltype1
), 0,
669 ret
= allocate_value (rettype
);
671 for (i
= 0; i
< highb1
- lowb1
+ 1; i
++)
673 /* For vector types, the relational, equality and logical operators shall
674 return 0 if the specified relation is false and -1 (i.e. all bits set)
675 if the specified relation is true. */
676 int tmp
= scalar_relop (value_subscript (val1
, i
),
677 value_subscript (val2
, i
), op
) ? -1 : 0;
678 memset (value_contents_writeable (ret
) + i
* TYPE_LENGTH (eltype1
),
679 tmp
, TYPE_LENGTH (eltype1
));
685 /* Perform a relational operation on two operands. */
687 static struct value
*
688 opencl_relop (struct expression
*exp
, struct value
*arg1
, struct value
*arg2
,
692 struct type
*type1
= check_typedef (value_type (arg1
));
693 struct type
*type2
= check_typedef (value_type (arg2
));
694 int t1_is_vec
= (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
695 && TYPE_VECTOR (type1
));
696 int t2_is_vec
= (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
697 && TYPE_VECTOR (type2
));
699 if (!t1_is_vec
&& !t2_is_vec
)
701 int tmp
= scalar_relop (arg1
, arg2
, op
);
703 language_bool_type (exp
->language_defn
, exp
->gdbarch
);
705 val
= value_from_longest (type
, tmp
);
707 else if (t1_is_vec
&& t2_is_vec
)
709 val
= vector_relop (exp
, arg1
, arg2
, op
);
713 /* Widen the scalar operand to a vector. */
714 struct value
**v
= t1_is_vec
? &arg2
: &arg1
;
715 struct type
*t
= t1_is_vec
? type2
: type1
;
717 if (TYPE_CODE (t
) != TYPE_CODE_FLT
&& !is_integral_type (t
))
718 error (_("Argument to operation not a number or boolean."));
720 *v
= value_cast (t1_is_vec
? type1
: type2
, *v
);
721 val
= vector_relop (exp
, arg1
, arg2
, op
);
727 /* Expression evaluator for the OpenCL. Most operations are delegated to
728 evaluate_subexp_standard; see that function for a description of the
731 static struct value
*
732 evaluate_subexp_opencl (struct type
*expect_type
, struct expression
*exp
,
733 int *pos
, enum noside noside
)
735 enum exp_opcode op
= exp
->elts
[*pos
].opcode
;
736 struct value
*arg1
= NULL
;
737 struct value
*arg2
= NULL
;
738 struct type
*type1
, *type2
;
742 /* Handle binary relational and equality operators that are either not
743 or differently defined for GNU vectors. */
751 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
752 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
754 if (noside
== EVAL_SKIP
)
755 return value_from_longest (builtin_type (exp
->gdbarch
)->
758 return opencl_relop (exp
, arg1
, arg2
, op
);
760 /* Handle the logical unary operator not(!). */
761 case UNOP_LOGICAL_NOT
:
763 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
765 if (noside
== EVAL_SKIP
)
766 return value_from_longest (builtin_type (exp
->gdbarch
)->
769 return opencl_logical_not (exp
, arg1
);
771 /* Handle the logical operator and(&&) and or(||). */
772 case BINOP_LOGICAL_AND
:
773 case BINOP_LOGICAL_OR
:
775 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
777 if (noside
== EVAL_SKIP
)
779 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
781 return value_from_longest (builtin_type (exp
->gdbarch
)->
786 /* For scalar operations we need to avoid evaluating operands
787 unecessarily. However, for vector operations we always need to
788 evaluate both operands. Unfortunately we only know which of the
789 two cases apply after we know the type of the second operand.
790 Therefore we evaluate it once using EVAL_AVOID_SIDE_EFFECTS. */
793 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
794 EVAL_AVOID_SIDE_EFFECTS
);
796 type1
= check_typedef (value_type (arg1
));
797 type2
= check_typedef (value_type (arg2
));
799 if ((TYPE_CODE (type1
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type1
))
800 || (TYPE_CODE (type2
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type2
)))
802 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
804 return opencl_relop (exp
, arg1
, arg2
, op
);
808 /* For scalar built-in types, only evaluate the right
809 hand operand if the left hand operand compares
810 unequal(&&)/equal(||) to 0. */
812 int tmp
= value_logical_not (arg1
);
814 if (op
== BINOP_LOGICAL_OR
)
817 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
818 tmp
? EVAL_SKIP
: noside
);
819 type1
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
821 if (op
== BINOP_LOGICAL_AND
)
822 res
= !tmp
&& !value_logical_not (arg2
);
823 else /* BINOP_LOGICAL_OR */
824 res
= tmp
|| !value_logical_not (arg2
);
826 return value_from_longest (type1
, res
);
830 /* Handle the ternary selection operator. */
833 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
834 type1
= check_typedef (value_type (arg1
));
835 if (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type1
))
837 struct value
*arg3
, *tmp
, *ret
;
838 struct type
*eltype2
, *type3
, *eltype3
;
839 int t2_is_vec
, t3_is_vec
, i
;
840 LONGEST lowb1
, lowb2
, lowb3
, highb1
, highb2
, highb3
;
842 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
843 arg3
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
844 type2
= check_typedef (value_type (arg2
));
845 type3
= check_typedef (value_type (arg3
));
847 = TYPE_CODE (type2
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type2
);
849 = TYPE_CODE (type3
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type3
);
851 /* Widen the scalar operand to a vector if necessary. */
852 if (t2_is_vec
|| !t3_is_vec
)
854 arg3
= value_cast (type2
, arg3
);
855 type3
= value_type (arg3
);
857 else if (!t2_is_vec
|| t3_is_vec
)
859 arg2
= value_cast (type3
, arg2
);
860 type2
= value_type (arg2
);
862 else if (!t2_is_vec
|| !t3_is_vec
)
864 /* Throw an error if arg2 or arg3 aren't vectors. */
866 Cannot perform conditional operation on incompatible types"));
869 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
));
870 eltype3
= check_typedef (TYPE_TARGET_TYPE (type3
));
872 if (!get_array_bounds (type1
, &lowb1
, &highb1
)
873 || !get_array_bounds (type2
, &lowb2
, &highb2
)
874 || !get_array_bounds (type3
, &lowb3
, &highb3
))
875 error (_("Could not determine the vector bounds"));
877 /* Throw an error if the types of arg2 or arg3 are incompatible. */
878 if (TYPE_CODE (eltype2
) != TYPE_CODE (eltype3
)
879 || TYPE_LENGTH (eltype2
) != TYPE_LENGTH (eltype3
)
880 || TYPE_UNSIGNED (eltype2
) != TYPE_UNSIGNED (eltype3
)
881 || lowb2
!= lowb3
|| highb2
!= highb3
)
883 Cannot perform operation on vectors with different types"));
885 /* Throw an error if the sizes of arg1 and arg2/arg3 differ. */
886 if (lowb1
!= lowb2
|| lowb1
!= lowb3
887 || highb1
!= highb2
|| highb1
!= highb3
)
889 Cannot perform conditional operation on vectors with different sizes"));
891 ret
= allocate_value (type2
);
893 for (i
= 0; i
< highb1
- lowb1
+ 1; i
++)
895 tmp
= value_logical_not (value_subscript (arg1
, i
)) ?
896 value_subscript (arg3
, i
) : value_subscript (arg2
, i
);
897 memcpy (value_contents_writeable (ret
) +
898 i
* TYPE_LENGTH (eltype2
), value_contents_all (tmp
),
899 TYPE_LENGTH (eltype2
));
906 if (value_logical_not (arg1
))
908 /* Skip the second operand. */
909 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
911 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
915 /* Skip the third operand. */
916 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
917 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
923 /* Handle STRUCTOP_STRUCT to allow component access on OpenCL vectors. */
924 case STRUCTOP_STRUCT
:
927 int tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
929 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
930 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
931 type1
= check_typedef (value_type (arg1
));
933 if (noside
== EVAL_SKIP
)
935 return value_from_longest (builtin_type (exp
->gdbarch
)->
938 else if (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type1
))
940 return opencl_component_ref (exp
, arg1
, &exp
->elts
[pc
+ 2].string
,
945 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
947 value_zero (lookup_struct_elt_type
948 (value_type (arg1
),&exp
->elts
[pc
+ 2].string
, 0),
951 return value_struct_elt (&arg1
, NULL
,
952 &exp
->elts
[pc
+ 2].string
, NULL
,
960 return evaluate_subexp_c (expect_type
, exp
, pos
, noside
);
964 opencl_language_arch_info (struct gdbarch
*gdbarch
,
965 struct language_arch_info
*lai
)
967 struct type
**types
= builtin_opencl_type (gdbarch
);
969 /* Copy primitive types vector from gdbarch. */
970 lai
->primitive_type_vector
= types
;
972 /* Type of elements of strings. */
973 lai
->string_char_type
= types
[opencl_primitive_type_char
];
975 /* Specifies the return type of logical and relational operations. */
976 lai
->bool_type_symbol
= "int";
977 lai
->bool_type_default
= types
[opencl_primitive_type_int
];
980 const struct exp_descriptor exp_descriptor_opencl
=
982 print_subexp_standard
,
983 operator_length_standard
,
984 operator_check_standard
,
986 dump_subexp_body_standard
,
987 evaluate_subexp_opencl
990 const struct language_defn opencl_language_defn
=
992 "opencl", /* Language name */
999 &exp_descriptor_opencl
,
1003 c_printchar
, /* Print a character constant */
1004 c_printstr
, /* Function to print string constant */
1005 c_emit_char
, /* Print a single char */
1006 c_print_type
, /* Print a type using appropriate syntax */
1007 c_print_typedef
, /* Print a typedef using appropriate syntax */
1008 c_val_print
, /* Print a value using appropriate syntax */
1009 c_value_print
, /* Print a top-level value */
1010 NULL
, /* Language specific skip_trampoline */
1011 NULL
, /* name_of_this */
1012 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
1013 basic_lookup_transparent_type
,/* lookup_transparent_type */
1014 NULL
, /* Language specific symbol demangler */
1015 NULL
, /* Language specific
1016 class_name_from_physname */
1017 c_op_print_tab
, /* expression operators for printing */
1018 1, /* c-style arrays */
1019 0, /* String lower bound */
1020 default_word_break_characters
,
1021 default_make_symbol_completion_list
,
1022 opencl_language_arch_info
,
1023 default_print_array_index
,
1024 default_pass_by_reference
,
1030 build_opencl_types (struct gdbarch
*gdbarch
)
1033 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_opencl_primitive_types
+ 1,
1036 /* Helper macro to create strings. */
1037 #define OCL_STRING(S) #S
1038 /* This macro allocates and assigns the type struct pointers
1039 for the vector types. */
1040 #define BUILD_OCL_VTYPES(TYPE)\
1041 types[opencl_primitive_type_##TYPE##2] \
1042 = init_vector_type (types[opencl_primitive_type_##TYPE], 2); \
1043 TYPE_NAME (types[opencl_primitive_type_##TYPE##2]) = OCL_STRING(TYPE ## 2); \
1044 types[opencl_primitive_type_##TYPE##3] \
1045 = init_vector_type (types[opencl_primitive_type_##TYPE], 3); \
1046 TYPE_NAME (types[opencl_primitive_type_##TYPE##3]) = OCL_STRING(TYPE ## 3); \
1047 TYPE_LENGTH (types[opencl_primitive_type_##TYPE##3]) \
1048 = 4 * TYPE_LENGTH (types[opencl_primitive_type_##TYPE]); \
1049 types[opencl_primitive_type_##TYPE##4] \
1050 = init_vector_type (types[opencl_primitive_type_##TYPE], 4); \
1051 TYPE_NAME (types[opencl_primitive_type_##TYPE##4]) = OCL_STRING(TYPE ## 4); \
1052 types[opencl_primitive_type_##TYPE##8] \
1053 = init_vector_type (types[opencl_primitive_type_##TYPE], 8); \
1054 TYPE_NAME (types[opencl_primitive_type_##TYPE##8]) = OCL_STRING(TYPE ## 8); \
1055 types[opencl_primitive_type_##TYPE##16] \
1056 = init_vector_type (types[opencl_primitive_type_##TYPE], 16); \
1057 TYPE_NAME (types[opencl_primitive_type_##TYPE##16]) = OCL_STRING(TYPE ## 16)
1059 types
[opencl_primitive_type_char
]
1060 = arch_integer_type (gdbarch
, 8, 0, "char");
1061 BUILD_OCL_VTYPES (char);
1062 types
[opencl_primitive_type_uchar
]
1063 = arch_integer_type (gdbarch
, 8, 1, "uchar");
1064 BUILD_OCL_VTYPES (uchar
);
1065 types
[opencl_primitive_type_short
]
1066 = arch_integer_type (gdbarch
, 16, 0, "short");
1067 BUILD_OCL_VTYPES (short);
1068 types
[opencl_primitive_type_ushort
]
1069 = arch_integer_type (gdbarch
, 16, 1, "ushort");
1070 BUILD_OCL_VTYPES (ushort
);
1071 types
[opencl_primitive_type_int
]
1072 = arch_integer_type (gdbarch
, 32, 0, "int");
1073 BUILD_OCL_VTYPES (int);
1074 types
[opencl_primitive_type_uint
]
1075 = arch_integer_type (gdbarch
, 32, 1, "uint");
1076 BUILD_OCL_VTYPES (uint
);
1077 types
[opencl_primitive_type_long
]
1078 = arch_integer_type (gdbarch
, 64, 0, "long");
1079 BUILD_OCL_VTYPES (long);
1080 types
[opencl_primitive_type_ulong
]
1081 = arch_integer_type (gdbarch
, 64, 1, "ulong");
1082 BUILD_OCL_VTYPES (ulong
);
1083 types
[opencl_primitive_type_half
]
1084 = arch_float_type (gdbarch
, 16, "half", floatformats_ieee_half
);
1085 BUILD_OCL_VTYPES (half
);
1086 types
[opencl_primitive_type_float
]
1087 = arch_float_type (gdbarch
, 32, "float", floatformats_ieee_single
);
1088 BUILD_OCL_VTYPES (float);
1089 types
[opencl_primitive_type_double
]
1090 = arch_float_type (gdbarch
, 64, "double", floatformats_ieee_double
);
1091 BUILD_OCL_VTYPES (double);
1092 types
[opencl_primitive_type_bool
]
1093 = arch_boolean_type (gdbarch
, 8, 1, "bool");
1094 types
[opencl_primitive_type_unsigned_char
]
1095 = arch_integer_type (gdbarch
, 8, 1, "unsigned char");
1096 types
[opencl_primitive_type_unsigned_short
]
1097 = arch_integer_type (gdbarch
, 16, 1, "unsigned short");
1098 types
[opencl_primitive_type_unsigned_int
]
1099 = arch_integer_type (gdbarch
, 32, 1, "unsigned int");
1100 types
[opencl_primitive_type_unsigned_long
]
1101 = arch_integer_type (gdbarch
, 64, 1, "unsigned long");
1102 types
[opencl_primitive_type_size_t
]
1103 = arch_integer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
), 1, "size_t");
1104 types
[opencl_primitive_type_ptrdiff_t
]
1105 = arch_integer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
), 0, "ptrdiff_t");
1106 types
[opencl_primitive_type_intptr_t
]
1107 = arch_integer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
), 0, "intptr_t");
1108 types
[opencl_primitive_type_uintptr_t
]
1109 = arch_integer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
), 1, "uintptr_t");
1110 types
[opencl_primitive_type_void
]
1111 = arch_type (gdbarch
, TYPE_CODE_VOID
, 1, "void");
1117 _initialize_opencl_language (void)
1119 opencl_type_data
= gdbarch_data_register_post_init (build_opencl_types
);
1120 add_language (&opencl_language_defn
);