ef0214c4b7910b8c5ed2952e6427c128f9a3331a
[deliverable/binutils-gdb.git] / gdb / opencl-lang.c
1 /* OpenCL language support for GDB, the GNU debugger.
2 Copyright (C) 2010 Free Software Foundation, Inc.
3
4 Contributed by Ken Werner <ken.werner@de.ibm.com>.
5
6 This file is part of GDB.
7
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.
12
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.
17
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/>. */
20
21 #include "defs.h"
22 #include "gdb_string.h"
23 #include "gdbtypes.h"
24 #include "symtab.h"
25 #include "expression.h"
26 #include "parser-defs.h"
27 #include "symtab.h"
28 #include "language.h"
29 #include "c-lang.h"
30 #include "gdb_assert.h"
31
32 extern void _initialize_opencl_language (void);
33
34 /* This macro generates enum values from a given type. */
35
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
43
44 enum opencl_primitive_types {
45 OCL_P_TYPE (char),
46 OCL_P_TYPE (uchar),
47 OCL_P_TYPE (short),
48 OCL_P_TYPE (ushort),
49 OCL_P_TYPE (int),
50 OCL_P_TYPE (uint),
51 OCL_P_TYPE (long),
52 OCL_P_TYPE (ulong),
53 OCL_P_TYPE (half),
54 OCL_P_TYPE (float),
55 OCL_P_TYPE (double),
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
67 };
68
69 /* This macro generates the type struct declarations from a given type. */
70
71 #define STRUCT_OCL_TYPE(TYPE)\
72 struct type *builtin_##TYPE;\
73 struct type *builtin_##TYPE##2;\
74 struct type *builtin_##TYPE##3;\
75 struct type *builtin_##TYPE##4;\
76 struct type *builtin_##TYPE##8;\
77 struct type *builtin_##TYPE##16
78
79 struct builtin_opencl_type
80 {
81 STRUCT_OCL_TYPE (char);
82 STRUCT_OCL_TYPE (uchar);
83 STRUCT_OCL_TYPE (short);
84 STRUCT_OCL_TYPE (ushort);
85 STRUCT_OCL_TYPE (int);
86 STRUCT_OCL_TYPE (uint);
87 STRUCT_OCL_TYPE (long);
88 STRUCT_OCL_TYPE (ulong);
89 STRUCT_OCL_TYPE (half);
90 STRUCT_OCL_TYPE (float);
91 STRUCT_OCL_TYPE (double);
92 struct type *builtin_bool;
93 struct type *builtin_unsigned_char;
94 struct type *builtin_unsigned_short;
95 struct type *builtin_unsigned_int;
96 struct type *builtin_unsigned_long;
97 struct type *builtin_size_t;
98 struct type *builtin_ptrdiff_t;
99 struct type *builtin_intptr_t;
100 struct type *builtin_uintptr_t;
101 struct type *builtin_void;
102 };
103
104 static struct gdbarch_data *opencl_type_data;
105
106 const struct builtin_opencl_type *
107 builtin_opencl_type (struct gdbarch *gdbarch)
108 {
109 return gdbarch_data (gdbarch, opencl_type_data);
110 }
111
112 /* Returns the corresponding OpenCL vector type from the given type code,
113 the length of the element type, the unsigned flag and the amount of
114 elements (N). */
115
116 static struct type *
117 lookup_opencl_vector_type (struct gdbarch *gdbarch, enum type_code code,
118 unsigned int el_length, unsigned int flag_unsigned,
119 int n)
120 {
121 int i;
122 unsigned int length;
123 struct type *type = NULL;
124 struct type **types = (struct type **) builtin_opencl_type (gdbarch);
125
126 /* Check if n describes a valid OpenCL vector size (2, 3, 4, 8, 16). */
127 if (n != 2 && n != 3 && n != 4 && n != 8 && n != 16)
128 error (_("Invalid OpenCL vector size: %d"), n);
129
130 /* Triple vectors have the size of a quad vector. */
131 length = (n == 3) ? el_length * 4 : el_length * n;
132
133 for (i = 0; i < nr_opencl_primitive_types; i++)
134 {
135 LONGEST lowb, highb;
136
137 if (TYPE_CODE (types[i]) == TYPE_CODE_ARRAY && TYPE_VECTOR (types[i])
138 && get_array_bounds (types[i], &lowb, &highb)
139 && TYPE_CODE (TYPE_TARGET_TYPE (types[i])) == code
140 && TYPE_UNSIGNED (TYPE_TARGET_TYPE (types[i])) == flag_unsigned
141 && TYPE_LENGTH (TYPE_TARGET_TYPE (types[i])) == el_length
142 && TYPE_LENGTH (types[i]) == length
143 && highb - lowb + 1 == n)
144 {
145 type = types[i];
146 break;
147 }
148 }
149
150 return type;
151 }
152
153 /* Returns nonzero if the array ARR contains duplicates within
154 the first N elements. */
155
156 static int
157 array_has_dups (int *arr, int n)
158 {
159 int i, j;
160
161 for (i = 0; i < n; i++)
162 {
163 for (j = i + 1; j < n; j++)
164 {
165 if (arr[i] == arr[j])
166 return 1;
167 }
168 }
169
170 return 0;
171 }
172
173 /* The OpenCL component access syntax allows to create lvalues referring to
174 selected elements of an original OpenCL vector in arbitrary order. This
175 structure holds the information to describe such lvalues. */
176
177 struct lval_closure
178 {
179 /* Reference count. */
180 int refc;
181 /* The number of indices. */
182 int n;
183 /* The element indices themselves. */
184 int *indices;
185 /* A pointer to the original value. */
186 struct value *val;
187 };
188
189 /* Allocates an instance of struct lval_closure. */
190
191 static struct lval_closure *
192 allocate_lval_closure (int *indices, int n, struct value *val)
193 {
194 struct lval_closure *c = XZALLOC (struct lval_closure);
195
196 c->refc = 1;
197 c->n = n;
198 c->indices = XCALLOC (n, int);
199 memcpy (c->indices, indices, n * sizeof (int));
200 value_incref (val); /* Increment the reference counter of the value. */
201 c->val = val;
202
203 return c;
204 }
205
206 static void
207 lval_func_read (struct value *v)
208 {
209 struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
210 struct type *type = check_typedef (value_type (v));
211 struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val)));
212 int offset = value_offset (v);
213 int elsize = TYPE_LENGTH (eltype);
214 int n, i, j = 0;
215 LONGEST lowb = 0;
216 LONGEST highb = 0;
217
218 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
219 && !get_array_bounds (type, &lowb, &highb))
220 error (_("Could not determine the vector bounds"));
221
222 /* Assume elsize aligned offset. */
223 gdb_assert (offset % elsize == 0);
224 offset /= elsize;
225 n = offset + highb - lowb + 1;
226 gdb_assert (n <= c->n);
227
228 for (i = offset; i < n; i++)
229 memcpy (value_contents_raw (v) + j++ * elsize,
230 value_contents (c->val) + c->indices[i] * elsize,
231 elsize);
232 }
233
234 static void
235 lval_func_write (struct value *v, struct value *fromval)
236 {
237 struct value *mark = value_mark ();
238 struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
239 struct type *type = check_typedef (value_type (v));
240 struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val)));
241 int offset = value_offset (v);
242 int elsize = TYPE_LENGTH (eltype);
243 int n, i, j = 0;
244 LONGEST lowb = 0;
245 LONGEST highb = 0;
246
247 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
248 && !get_array_bounds (type, &lowb, &highb))
249 error (_("Could not determine the vector bounds"));
250
251 /* Assume elsize aligned offset. */
252 gdb_assert (offset % elsize == 0);
253 offset /= elsize;
254 n = offset + highb - lowb + 1;
255
256 /* Since accesses to the fourth component of a triple vector is undefined we
257 just skip writes to the fourth element. Imagine something like this:
258 int3 i3 = (int3)(0, 1, 2);
259 i3.hi.hi = 5;
260 In this case n would be 4 (offset=12/4 + 1) while c->n would be 3. */
261 if (n > c->n)
262 n = c->n;
263
264 for (i = offset; i < n; i++)
265 {
266 struct value *from_elm_val = allocate_value (eltype);
267 struct value *to_elm_val = value_subscript (c->val, c->indices[i]);
268
269 memcpy (value_contents_writeable (from_elm_val),
270 value_contents (fromval) + j++ * elsize,
271 elsize);
272 value_assign (to_elm_val, from_elm_val);
273 }
274
275 value_free_to_mark (mark);
276 }
277
278 /* Return nonzero if all bits in V within OFFSET and LENGTH are valid. */
279
280 static int
281 lval_func_check_validity (const struct value *v, int offset, int length)
282 {
283 struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
284 /* Size of the target type in bits. */
285 int elsize =
286 TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
287 int startrest = offset % elsize;
288 int start = offset / elsize;
289 int endrest = (offset + length) % elsize;
290 int end = (offset + length) / elsize;
291 int i;
292
293 if (endrest)
294 end++;
295
296 if (end > c->n)
297 return 0;
298
299 for (i = start; i < end; i++)
300 {
301 int startoffset = (i == start) ? startrest : 0;
302 int length = (i == end) ? endrest : elsize;
303
304 if (!value_bits_valid (c->val, c->indices[i] * elsize + startoffset,
305 length))
306 return 0;
307 }
308
309 return 1;
310 }
311
312 /* Return nonzero if any bit in V is valid. */
313
314 static int
315 lval_func_check_any_valid (const struct value *v)
316 {
317 struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
318 /* Size of the target type in bits. */
319 int elsize =
320 TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
321 int i;
322
323 for (i = 0; i < c->n; i++)
324 if (value_bits_valid (c->val, c->indices[i] * elsize, elsize))
325 return 1;
326
327 return 0;
328 }
329
330 /* Return nonzero if bits in V from OFFSET and LENGTH represent a
331 synthetic pointer. */
332
333 static int
334 lval_func_check_synthetic_pointer (const struct value *v,
335 int offset, int length)
336 {
337 struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
338 /* Size of the target type in bits. */
339 int elsize =
340 TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
341 int startrest = offset % elsize;
342 int start = offset / elsize;
343 int endrest = (offset + length) % elsize;
344 int end = (offset + length) / elsize;
345 int i;
346
347 if (endrest)
348 end++;
349
350 if (end > c->n)
351 return 0;
352
353 for (i = start; i < end; i++)
354 {
355 int startoffset = (i == start) ? startrest : 0;
356 int length = (i == end) ? endrest : elsize;
357
358 if (!value_bits_synthetic_pointer (c->val,
359 c->indices[i] * elsize + startoffset,
360 length))
361 return 0;
362 }
363
364 return 1;
365 }
366
367 static void *
368 lval_func_copy_closure (const struct value *v)
369 {
370 struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
371
372 ++c->refc;
373
374 return c;
375 }
376
377 static void
378 lval_func_free_closure (struct value *v)
379 {
380 struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
381
382 --c->refc;
383
384 if (c->refc == 0)
385 {
386 xfree (c->indices);
387 xfree (c);
388 value_free (c->val); /* Decrement the reference counter of the value. */
389 }
390 }
391
392 static struct lval_funcs opencl_value_funcs =
393 {
394 lval_func_read,
395 lval_func_write,
396 lval_func_check_validity,
397 lval_func_check_any_valid,
398 NULL,
399 lval_func_check_synthetic_pointer,
400 lval_func_copy_closure,
401 lval_func_free_closure
402 };
403
404 /* Creates a sub-vector from VAL. The elements are selected by the indices of
405 an array with the length of N. Supported values for NOSIDE are
406 EVAL_NORMAL and EVAL_AVOID_SIDE_EFFECTS. */
407
408 static struct value *
409 create_value (struct gdbarch *gdbarch, struct value *val, enum noside noside,
410 int *indices, int n)
411 {
412 struct type *type = check_typedef (value_type (val));
413 struct type *elm_type = TYPE_TARGET_TYPE (type);
414 struct value *ret;
415
416 /* Check if a single component of a vector is requested which means
417 the resulting type is a (primitive) scalar type. */
418 if (n == 1)
419 {
420 if (noside == EVAL_AVOID_SIDE_EFFECTS)
421 ret = value_zero (elm_type, not_lval);
422 else
423 ret = value_subscript (val, indices[0]);
424 }
425 else
426 {
427 /* Multiple components of the vector are requested which means the
428 resulting type is a vector as well. */
429 struct type *dst_type =
430 lookup_opencl_vector_type (gdbarch, TYPE_CODE (elm_type),
431 TYPE_LENGTH (elm_type),
432 TYPE_UNSIGNED (elm_type), n);
433
434 if (dst_type == NULL)
435 dst_type = init_vector_type (elm_type, n);
436
437 make_cv_type (TYPE_CONST (type), TYPE_VOLATILE (type), dst_type, NULL);
438
439 if (noside == EVAL_AVOID_SIDE_EFFECTS)
440 ret = allocate_value (dst_type);
441 else
442 {
443 /* Check whether to create a lvalue or not. */
444 if (VALUE_LVAL (val) != not_lval && !array_has_dups (indices, n))
445 {
446 struct lval_closure *c = allocate_lval_closure (indices, n, val);
447 ret = allocate_computed_value (dst_type, &opencl_value_funcs, c);
448 }
449 else
450 {
451 int i;
452
453 ret = allocate_value (dst_type);
454
455 /* Copy src val contents into the destination value. */
456 for (i = 0; i < n; i++)
457 memcpy (value_contents_writeable (ret)
458 + (i * TYPE_LENGTH (elm_type)),
459 value_contents (val)
460 + (indices[i] * TYPE_LENGTH (elm_type)),
461 TYPE_LENGTH (elm_type));
462 }
463 }
464 }
465 return ret;
466 }
467
468 /* OpenCL vector component access. */
469
470 static struct value *
471 opencl_component_ref (struct expression *exp, struct value *val, char *comps,
472 enum noside noside)
473 {
474 LONGEST lowb, highb;
475 int src_len;
476 struct value *v;
477 int indices[16], i;
478 int dst_len;
479
480 if (!get_array_bounds (check_typedef (value_type (val)), &lowb, &highb))
481 error (_("Could not determine the vector bounds"));
482
483 src_len = highb - lowb + 1;
484
485 /* Throw an error if the amount of array elements does not fit a
486 valid OpenCL vector size (2, 3, 4, 8, 16). */
487 if (src_len != 2 && src_len != 3 && src_len != 4 && src_len != 8
488 && src_len != 16)
489 error (_("Invalid OpenCL vector size"));
490
491 if (strcmp (comps, "lo") == 0 )
492 {
493 dst_len = (src_len == 3) ? 2 : src_len / 2;
494
495 for (i = 0; i < dst_len; i++)
496 indices[i] = i;
497 }
498 else if (strcmp (comps, "hi") == 0)
499 {
500 dst_len = (src_len == 3) ? 2 : src_len / 2;
501
502 for (i = 0; i < dst_len; i++)
503 indices[i] = dst_len + i;
504 }
505 else if (strcmp (comps, "even") == 0)
506 {
507 dst_len = (src_len == 3) ? 2 : src_len / 2;
508
509 for (i = 0; i < dst_len; i++)
510 indices[i] = i*2;
511 }
512 else if (strcmp (comps, "odd") == 0)
513 {
514 dst_len = (src_len == 3) ? 2 : src_len / 2;
515
516 for (i = 0; i < dst_len; i++)
517 indices[i] = i*2+1;
518 }
519 else if (strncasecmp (comps, "s", 1) == 0)
520 {
521 #define HEXCHAR_TO_INT(C) ((C >= '0' && C <= '9') ? \
522 C-'0' : ((C >= 'A' && C <= 'F') ? \
523 C-'A'+10 : ((C >= 'a' && C <= 'f') ? \
524 C-'a'+10 : -1)))
525
526 dst_len = strlen (comps);
527 /* Skip the s/S-prefix. */
528 dst_len--;
529
530 for (i = 0; i < dst_len; i++)
531 {
532 indices[i] = HEXCHAR_TO_INT(comps[i+1]);
533 /* Check if the requested component is invalid or exceeds
534 the vector. */
535 if (indices[i] < 0 || indices[i] >= src_len)
536 error (_("Invalid OpenCL vector component accessor %s"), comps);
537 }
538 }
539 else
540 {
541 dst_len = strlen (comps);
542
543 for (i = 0; i < dst_len; i++)
544 {
545 /* x, y, z, w */
546 switch (comps[i])
547 {
548 case 'x':
549 indices[i] = 0;
550 break;
551 case 'y':
552 indices[i] = 1;
553 break;
554 case 'z':
555 if (src_len < 3)
556 error (_("Invalid OpenCL vector component accessor %s"), comps);
557 indices[i] = 2;
558 break;
559 case 'w':
560 if (src_len < 4)
561 error (_("Invalid OpenCL vector component accessor %s"), comps);
562 indices[i] = 3;
563 break;
564 default:
565 error (_("Invalid OpenCL vector component accessor %s"), comps);
566 break;
567 }
568 }
569 }
570
571 /* Throw an error if the amount of requested components does not
572 result in a valid length (1, 2, 3, 4, 8, 16). */
573 if (dst_len != 1 && dst_len != 2 && dst_len != 3 && dst_len != 4
574 && dst_len != 8 && dst_len != 16)
575 error (_("Invalid OpenCL vector component accessor %s"), comps);
576
577 v = create_value (exp->gdbarch, val, noside, indices, dst_len);
578
579 return v;
580 }
581
582 /* Perform the unary logical not (!) operation. */
583
584 static struct value *
585 opencl_logical_not (struct expression *exp, struct value *arg)
586 {
587 struct type *type = check_typedef (value_type (arg));
588 struct type *rettype;
589 struct value *ret;
590
591 if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
592 {
593 struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
594 LONGEST lowb, highb;
595 int i;
596
597 if (!get_array_bounds (type, &lowb, &highb))
598 error (_("Could not determine the vector bounds"));
599
600 /* Determine the resulting type of the operation and allocate the
601 value. */
602 rettype = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT,
603 TYPE_LENGTH (eltype), 0,
604 highb - lowb + 1);
605 ret = allocate_value (rettype);
606
607 for (i = 0; i < highb - lowb + 1; i++)
608 {
609 /* For vector types, the unary operator shall return a 0 if the
610 value of its operand compares unequal to 0, and -1 (i.e. all bits
611 set) if the value of its operand compares equal to 0. */
612 int tmp = value_logical_not (value_subscript (arg, i)) ? -1 : 0;
613 memset (value_contents_writeable (ret) + i * TYPE_LENGTH (eltype),
614 tmp, TYPE_LENGTH (eltype));
615 }
616 }
617 else
618 {
619 rettype = language_bool_type (exp->language_defn, exp->gdbarch);
620 ret = value_from_longest (rettype, value_logical_not (arg));
621 }
622
623 return ret;
624 }
625
626 /* Perform a relational operation on two scalar operands. */
627
628 static int
629 scalar_relop (struct value *val1, struct value *val2, enum exp_opcode op)
630 {
631 int ret;
632
633 switch (op)
634 {
635 case BINOP_EQUAL:
636 ret = value_equal (val1, val2);
637 break;
638 case BINOP_NOTEQUAL:
639 ret = !value_equal (val1, val2);
640 break;
641 case BINOP_LESS:
642 ret = value_less (val1, val2);
643 break;
644 case BINOP_GTR:
645 ret = value_less (val2, val1);
646 break;
647 case BINOP_GEQ:
648 ret = value_less (val2, val1) || value_equal (val1, val2);
649 break;
650 case BINOP_LEQ:
651 ret = value_less (val1, val2) || value_equal (val1, val2);
652 break;
653 case BINOP_LOGICAL_AND:
654 ret = !value_logical_not (val1) && !value_logical_not (val2);
655 break;
656 case BINOP_LOGICAL_OR:
657 ret = !value_logical_not (val1) || !value_logical_not (val2);
658 break;
659 default:
660 error (_("Attempt to perform an unsupported operation"));
661 break;
662 }
663 return ret;
664 }
665
666 /* Perform a relational operation on two vector operands. */
667
668 static struct value *
669 vector_relop (struct expression *exp, struct value *val1, struct value *val2,
670 enum exp_opcode op)
671 {
672 struct value *ret;
673 struct type *type1, *type2, *eltype1, *eltype2, *rettype;
674 int t1_is_vec, t2_is_vec, i;
675 LONGEST lowb1, lowb2, highb1, highb2;
676
677 type1 = check_typedef (value_type (val1));
678 type2 = check_typedef (value_type (val2));
679
680 t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1));
681 t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2));
682
683 if (!t1_is_vec || !t2_is_vec)
684 error (_("Vector operations are not supported on scalar types"));
685
686 eltype1 = check_typedef (TYPE_TARGET_TYPE (type1));
687 eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
688
689 if (!get_array_bounds (type1,&lowb1, &highb1)
690 || !get_array_bounds (type2, &lowb2, &highb2))
691 error (_("Could not determine the vector bounds"));
692
693 /* Check whether the vector types are compatible. */
694 if (TYPE_CODE (eltype1) != TYPE_CODE (eltype2)
695 || TYPE_LENGTH (eltype1) != TYPE_LENGTH (eltype2)
696 || TYPE_UNSIGNED (eltype1) != TYPE_UNSIGNED (eltype2)
697 || lowb1 != lowb2 || highb1 != highb2)
698 error (_("Cannot perform operation on vectors with different types"));
699
700 /* Determine the resulting type of the operation and allocate the value. */
701 rettype = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT,
702 TYPE_LENGTH (eltype1), 0,
703 highb1 - lowb1 + 1);
704 ret = allocate_value (rettype);
705
706 for (i = 0; i < highb1 - lowb1 + 1; i++)
707 {
708 /* For vector types, the relational, equality and logical operators shall
709 return 0 if the specified relation is false and -1 (i.e. all bits set)
710 if the specified relation is true. */
711 int tmp = scalar_relop (value_subscript (val1, i),
712 value_subscript (val2, i), op) ? -1 : 0;
713 memset (value_contents_writeable (ret) + i * TYPE_LENGTH (eltype1),
714 tmp, TYPE_LENGTH (eltype1));
715 }
716
717 return ret;
718 }
719
720 /* Perform a relational operation on two operands. */
721
722 static struct value *
723 opencl_relop (struct expression *exp, struct value *arg1, struct value *arg2,
724 enum exp_opcode op)
725 {
726 struct value *val;
727 struct type *type1 = check_typedef (value_type (arg1));
728 struct type *type2 = check_typedef (value_type (arg2));
729 int t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
730 && TYPE_VECTOR (type1));
731 int t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
732 && TYPE_VECTOR (type2));
733
734 if (!t1_is_vec && !t2_is_vec)
735 {
736 int tmp = scalar_relop (arg1, arg2, op);
737 struct type *type =
738 language_bool_type (exp->language_defn, exp->gdbarch);
739
740 val = value_from_longest (type, tmp);
741 }
742 else if (t1_is_vec && t2_is_vec)
743 {
744 val = vector_relop (exp, arg1, arg2, op);
745 }
746 else
747 {
748 /* Widen the scalar operand to a vector. */
749 struct value **v = t1_is_vec ? &arg2 : &arg1;
750 struct type *t = t1_is_vec ? type2 : type1;
751
752 if (TYPE_CODE (t) != TYPE_CODE_FLT && !is_integral_type (t))
753 error (_("Argument to operation not a number or boolean."));
754
755 *v = value_cast (t1_is_vec ? type1 : type2, *v);
756 val = vector_relop (exp, arg1, arg2, op);
757 }
758
759 return val;
760 }
761
762 /* Expression evaluator for the OpenCL. Most operations are delegated to
763 evaluate_subexp_standard; see that function for a description of the
764 arguments. */
765
766 static struct value *
767 evaluate_subexp_opencl (struct type *expect_type, struct expression *exp,
768 int *pos, enum noside noside)
769 {
770 enum exp_opcode op = exp->elts[*pos].opcode;
771 struct value *arg1 = NULL;
772 struct value *arg2 = NULL;
773 struct type *type1, *type2;
774
775 switch (op)
776 {
777 /* Handle binary relational and equality operators that are either not
778 or differently defined for GNU vectors. */
779 case BINOP_EQUAL:
780 case BINOP_NOTEQUAL:
781 case BINOP_LESS:
782 case BINOP_GTR:
783 case BINOP_GEQ:
784 case BINOP_LEQ:
785 (*pos)++;
786 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
787 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
788
789 if (noside == EVAL_SKIP)
790 return value_from_longest (builtin_type (exp->gdbarch)->
791 builtin_int, 1);
792
793 return opencl_relop (exp, arg1, arg2, op);
794
795 /* Handle the logical unary operator not(!). */
796 case UNOP_LOGICAL_NOT:
797 (*pos)++;
798 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
799
800 if (noside == EVAL_SKIP)
801 return value_from_longest (builtin_type (exp->gdbarch)->
802 builtin_int, 1);
803
804 return opencl_logical_not (exp, arg1);
805
806 /* Handle the logical operator and(&&) and or(||). */
807 case BINOP_LOGICAL_AND:
808 case BINOP_LOGICAL_OR:
809 (*pos)++;
810 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
811
812 if (noside == EVAL_SKIP)
813 {
814 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
815
816 return value_from_longest (builtin_type (exp->gdbarch)->
817 builtin_int, 1);
818 }
819 else
820 {
821 /* For scalar operations we need to avoid evaluating operands
822 unecessarily. However, for vector operations we always need to
823 evaluate both operands. Unfortunately we only know which of the
824 two cases apply after we know the type of the second operand.
825 Therefore we evaluate it once using EVAL_AVOID_SIDE_EFFECTS. */
826 int oldpos = *pos;
827
828 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
829 *pos = oldpos;
830 type1 = check_typedef (value_type (arg1));
831 type2 = check_typedef (value_type (arg2));
832
833 if ((TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
834 || (TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2)))
835 {
836 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
837
838 return opencl_relop (exp, arg1, arg2, op);
839 }
840 else
841 {
842 /* For scalar built-in types, only evaluate the right
843 hand operand if the left hand operand compares
844 unequal(&&)/equal(||) to 0. */
845 int res;
846 int tmp = value_logical_not (arg1);
847
848 if (op == BINOP_LOGICAL_OR)
849 tmp = !tmp;
850
851 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
852 tmp ? EVAL_SKIP : noside);
853 type1 = language_bool_type (exp->language_defn, exp->gdbarch);
854
855 if (op == BINOP_LOGICAL_AND)
856 res = !tmp && !value_logical_not (arg2);
857 else /* BINOP_LOGICAL_OR */
858 res = tmp || !value_logical_not (arg2);
859
860 return value_from_longest (type1, res);
861 }
862 }
863
864 /* Handle the ternary selection operator. */
865 case TERNOP_COND:
866 (*pos)++;
867 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
868 type1 = check_typedef (value_type (arg1));
869 if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
870 {
871 struct value *arg3, *tmp, *ret;
872 struct type *eltype2, *type3, *eltype3;
873 int t2_is_vec, t3_is_vec, i;
874 LONGEST lowb1, lowb2, lowb3, highb1, highb2, highb3;
875
876 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
877 arg3 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
878 type2 = check_typedef (value_type (arg2));
879 type3 = check_typedef (value_type (arg3));
880 t2_is_vec
881 = TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2);
882 t3_is_vec
883 = TYPE_CODE (type3) == TYPE_CODE_ARRAY && TYPE_VECTOR (type3);
884
885 /* Widen the scalar operand to a vector if necessary. */
886 if (t2_is_vec || !t3_is_vec)
887 {
888 arg3 = value_cast (type2, arg3);
889 type3 = value_type (arg3);
890 }
891 else if (!t2_is_vec || t3_is_vec)
892 {
893 arg2 = value_cast (type3, arg2);
894 type2 = value_type (arg2);
895 }
896 else if (!t2_is_vec || !t3_is_vec)
897 {
898 /* Throw an error if arg2 or arg3 aren't vectors. */
899 error (_("\
900 Cannot perform conditional operation on incompatible types"));
901 }
902
903 eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
904 eltype3 = check_typedef (TYPE_TARGET_TYPE (type3));
905
906 if (!get_array_bounds (type1, &lowb1, &highb1)
907 || !get_array_bounds (type2, &lowb2, &highb2)
908 || !get_array_bounds (type3, &lowb3, &highb3))
909 error (_("Could not determine the vector bounds"));
910
911 /* Throw an error if the types of arg2 or arg3 are incompatible. */
912 if (TYPE_CODE (eltype2) != TYPE_CODE (eltype3)
913 || TYPE_LENGTH (eltype2) != TYPE_LENGTH (eltype3)
914 || TYPE_UNSIGNED (eltype2) != TYPE_UNSIGNED (eltype3)
915 || lowb2 != lowb3 || highb2 != highb3)
916 error (_("\
917 Cannot perform operation on vectors with different types"));
918
919 /* Throw an error if the sizes of arg1 and arg2/arg3 differ. */
920 if (lowb1 != lowb2 || lowb1 != lowb3
921 || highb1 != highb2 || highb1 != highb3)
922 error (_("\
923 Cannot perform conditional operation on vectors with different sizes"));
924
925 ret = allocate_value (type2);
926
927 for (i = 0; i < highb1 - lowb1 + 1; i++)
928 {
929 tmp = value_logical_not (value_subscript (arg1, i)) ?
930 value_subscript (arg3, i) : value_subscript (arg2, i);
931 memcpy (value_contents_writeable (ret) +
932 i * TYPE_LENGTH (eltype2), value_contents_all (tmp),
933 TYPE_LENGTH (eltype2));
934 }
935
936 return ret;
937 }
938 else
939 {
940 if (value_logical_not (arg1))
941 {
942 /* Skip the second operand. */
943 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
944
945 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
946 }
947 else
948 {
949 /* Skip the third operand. */
950 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
951 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
952
953 return arg2;
954 }
955 }
956
957 /* Handle STRUCTOP_STRUCT to allow component access on OpenCL vectors. */
958 case STRUCTOP_STRUCT:
959 {
960 int pc = (*pos)++;
961 int tem = longest_to_int (exp->elts[pc + 1].longconst);
962
963 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
964 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
965 type1 = check_typedef (value_type (arg1));
966
967 if (noside == EVAL_SKIP)
968 {
969 return value_from_longest (builtin_type (exp->gdbarch)->
970 builtin_int, 1);
971 }
972 else if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
973 {
974 return opencl_component_ref (exp, arg1, &exp->elts[pc + 2].string,
975 noside);
976 }
977 else
978 {
979 if (noside == EVAL_AVOID_SIDE_EFFECTS)
980 return
981 value_zero (lookup_struct_elt_type
982 (value_type (arg1),&exp->elts[pc + 2].string, 0),
983 lval_memory);
984 else
985 return value_struct_elt (&arg1, NULL,
986 &exp->elts[pc + 2].string, NULL,
987 "structure");
988 }
989 }
990 default:
991 break;
992 }
993
994 return evaluate_subexp_c (expect_type, exp, pos, noside);
995 }
996
997 void
998 opencl_language_arch_info (struct gdbarch *gdbarch,
999 struct language_arch_info *lai)
1000 {
1001 const struct builtin_opencl_type *builtin = builtin_opencl_type (gdbarch);
1002
1003 lai->string_char_type = builtin->builtin_char;
1004 lai->primitive_type_vector
1005 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_opencl_primitive_types + 1,
1006 struct type *);
1007
1008 /* This macro fills the primitive_type_vector from a given type. */
1009 #define FILL_TYPE_VECTOR(LAI, TYPE)\
1010 LAI->primitive_type_vector [opencl_primitive_type_##TYPE]\
1011 = builtin->builtin_##TYPE;\
1012 LAI->primitive_type_vector [opencl_primitive_type_##TYPE##2]\
1013 = builtin->builtin_##TYPE##2;\
1014 LAI->primitive_type_vector [opencl_primitive_type_##TYPE##3]\
1015 = builtin->builtin_##TYPE##3;\
1016 LAI->primitive_type_vector [opencl_primitive_type_##TYPE##4]\
1017 = builtin->builtin_##TYPE##4;\
1018 LAI->primitive_type_vector [opencl_primitive_type_##TYPE##8]\
1019 = builtin->builtin_##TYPE##8;\
1020 LAI->primitive_type_vector [opencl_primitive_type_##TYPE##16]\
1021 = builtin->builtin_##TYPE##16
1022
1023 FILL_TYPE_VECTOR (lai, char);
1024 FILL_TYPE_VECTOR (lai, uchar);
1025 FILL_TYPE_VECTOR (lai, short);
1026 FILL_TYPE_VECTOR (lai, ushort);
1027 FILL_TYPE_VECTOR (lai, int);
1028 FILL_TYPE_VECTOR (lai, uint);
1029 FILL_TYPE_VECTOR (lai, long);
1030 FILL_TYPE_VECTOR (lai, ulong);
1031 FILL_TYPE_VECTOR (lai, half);
1032 FILL_TYPE_VECTOR (lai, float);
1033 FILL_TYPE_VECTOR (lai, double);
1034 lai->primitive_type_vector [opencl_primitive_type_bool]
1035 = builtin->builtin_bool;
1036 lai->primitive_type_vector [opencl_primitive_type_unsigned_char]
1037 = builtin->builtin_unsigned_char;
1038 lai->primitive_type_vector [opencl_primitive_type_unsigned_short]
1039 = builtin->builtin_unsigned_short;
1040 lai->primitive_type_vector [opencl_primitive_type_unsigned_int]
1041 = builtin->builtin_unsigned_int;
1042 lai->primitive_type_vector [opencl_primitive_type_unsigned_long]
1043 = builtin->builtin_unsigned_long;
1044 lai->primitive_type_vector [opencl_primitive_type_half]
1045 = builtin->builtin_half;
1046 lai->primitive_type_vector [opencl_primitive_type_size_t]
1047 = builtin->builtin_size_t;
1048 lai->primitive_type_vector [opencl_primitive_type_ptrdiff_t]
1049 = builtin->builtin_ptrdiff_t;
1050 lai->primitive_type_vector [opencl_primitive_type_intptr_t]
1051 = builtin->builtin_intptr_t;
1052 lai->primitive_type_vector [opencl_primitive_type_uintptr_t]
1053 = builtin->builtin_uintptr_t;
1054 lai->primitive_type_vector [opencl_primitive_type_void]
1055 = builtin->builtin_void;
1056
1057 /* Specifies the return type of logical and relational operations. */
1058 lai->bool_type_symbol = "int";
1059 lai->bool_type_default = builtin->builtin_int;
1060 }
1061
1062 const struct exp_descriptor exp_descriptor_opencl =
1063 {
1064 print_subexp_standard,
1065 operator_length_standard,
1066 operator_check_standard,
1067 op_name_standard,
1068 dump_subexp_body_standard,
1069 evaluate_subexp_opencl
1070 };
1071
1072 const struct language_defn opencl_language_defn =
1073 {
1074 "opencl", /* Language name */
1075 language_opencl,
1076 range_check_off,
1077 type_check_off,
1078 case_sensitive_on,
1079 array_row_major,
1080 macro_expansion_c,
1081 &exp_descriptor_opencl,
1082 c_parse,
1083 c_error,
1084 null_post_parser,
1085 c_printchar, /* Print a character constant */
1086 c_printstr, /* Function to print string constant */
1087 c_emit_char, /* Print a single char */
1088 c_print_type, /* Print a type using appropriate syntax */
1089 c_print_typedef, /* Print a typedef using appropriate syntax */
1090 c_val_print, /* Print a value using appropriate syntax */
1091 c_value_print, /* Print a top-level value */
1092 NULL, /* Language specific skip_trampoline */
1093 NULL, /* name_of_this */
1094 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1095 basic_lookup_transparent_type,/* lookup_transparent_type */
1096 NULL, /* Language specific symbol demangler */
1097 NULL, /* Language specific class_name_from_physname */
1098 c_op_print_tab, /* expression operators for printing */
1099 1, /* c-style arrays */
1100 0, /* String lower bound */
1101 default_word_break_characters,
1102 default_make_symbol_completion_list,
1103 opencl_language_arch_info,
1104 default_print_array_index,
1105 default_pass_by_reference,
1106 c_get_string,
1107 LANG_MAGIC
1108 };
1109
1110 static void *
1111 build_opencl_types (struct gdbarch *gdbarch)
1112 {
1113 struct builtin_opencl_type *builtin_opencl_type
1114 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_opencl_type);
1115
1116 /* Helper macro to create strings. */
1117 #define STRINGIFY(S) #S
1118 /* This macro allocates and assigns the type struct pointers
1119 for the vector types. */
1120 #define BUILD_OCL_VTYPES(TYPE)\
1121 builtin_opencl_type->builtin_##TYPE##2\
1122 = init_vector_type (builtin_opencl_type->builtin_##TYPE, 2);\
1123 TYPE_NAME (builtin_opencl_type->builtin_##TYPE##2) = STRINGIFY(TYPE ## 2);\
1124 builtin_opencl_type->builtin_##TYPE##3\
1125 = init_vector_type (builtin_opencl_type->builtin_##TYPE, 3);\
1126 TYPE_NAME (builtin_opencl_type->builtin_##TYPE##3) = STRINGIFY(TYPE ## 3);\
1127 TYPE_LENGTH (builtin_opencl_type->builtin_##TYPE##3)\
1128 = 4 * TYPE_LENGTH (builtin_opencl_type->builtin_##TYPE);\
1129 builtin_opencl_type->builtin_##TYPE##4\
1130 = init_vector_type (builtin_opencl_type->builtin_##TYPE, 4);\
1131 TYPE_NAME (builtin_opencl_type->builtin_##TYPE##4) = STRINGIFY(TYPE ## 4);\
1132 builtin_opencl_type->builtin_##TYPE##8\
1133 = init_vector_type (builtin_opencl_type->builtin_##TYPE, 8);\
1134 TYPE_NAME (builtin_opencl_type->builtin_##TYPE##8) = STRINGIFY(TYPE ## 8);\
1135 builtin_opencl_type->builtin_##TYPE##16\
1136 = init_vector_type (builtin_opencl_type->builtin_##TYPE, 16);\
1137 TYPE_NAME (builtin_opencl_type->builtin_##TYPE##16) = STRINGIFY(TYPE ## 16)
1138
1139 builtin_opencl_type->builtin_char
1140 = arch_integer_type (gdbarch, 8, 0, "char");
1141 BUILD_OCL_VTYPES (char);
1142 builtin_opencl_type->builtin_uchar
1143 = arch_integer_type (gdbarch, 8, 1, "uchar");
1144 BUILD_OCL_VTYPES (uchar);
1145 builtin_opencl_type->builtin_short
1146 = arch_integer_type (gdbarch, 16, 0, "short");
1147 BUILD_OCL_VTYPES (short);
1148 builtin_opencl_type->builtin_ushort
1149 = arch_integer_type (gdbarch, 16, 1, "ushort");
1150 BUILD_OCL_VTYPES (ushort);
1151 builtin_opencl_type->builtin_int
1152 = arch_integer_type (gdbarch, 32, 0, "int");
1153 BUILD_OCL_VTYPES (int);
1154 builtin_opencl_type->builtin_uint
1155 = arch_integer_type (gdbarch, 32, 1, "uint");
1156 BUILD_OCL_VTYPES (uint);
1157 builtin_opencl_type->builtin_long
1158 = arch_integer_type (gdbarch, 64, 0, "long");
1159 BUILD_OCL_VTYPES (long);
1160 builtin_opencl_type->builtin_ulong
1161 = arch_integer_type (gdbarch, 64, 1, "ulong");
1162 BUILD_OCL_VTYPES (ulong);
1163 builtin_opencl_type->builtin_half
1164 = arch_float_type (gdbarch, 16, "half", floatformats_ieee_half);
1165 BUILD_OCL_VTYPES (half);
1166 builtin_opencl_type->builtin_float
1167 = arch_float_type (gdbarch, 32, "float", floatformats_ieee_single);
1168 BUILD_OCL_VTYPES (float);
1169 builtin_opencl_type->builtin_double
1170 = arch_float_type (gdbarch, 64, "double", floatformats_ieee_double);
1171 BUILD_OCL_VTYPES (double);
1172 builtin_opencl_type->builtin_bool
1173 = arch_boolean_type (gdbarch, 32, 1, "bool");
1174 builtin_opencl_type->builtin_unsigned_char
1175 = arch_integer_type (gdbarch, 8, 1, "unsigned char");
1176 builtin_opencl_type->builtin_unsigned_short
1177 = arch_integer_type (gdbarch, 16, 1, "unsigned short");
1178 builtin_opencl_type->builtin_unsigned_int
1179 = arch_integer_type (gdbarch, 32, 1, "unsigned int");
1180 builtin_opencl_type->builtin_unsigned_long
1181 = arch_integer_type (gdbarch, 64, 1, "unsigned long");
1182 builtin_opencl_type->builtin_size_t
1183 = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "size_t");
1184 builtin_opencl_type->builtin_ptrdiff_t
1185 = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "ptrdiff_t");
1186 builtin_opencl_type->builtin_intptr_t
1187 = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "intptr_t");
1188 builtin_opencl_type->builtin_uintptr_t
1189 = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "uintptr_t");
1190 builtin_opencl_type->builtin_void
1191 = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
1192
1193 return builtin_opencl_type;
1194 }
1195
1196 void
1197 _initialize_opencl_language (void)
1198 {
1199 opencl_type_data = gdbarch_data_register_post_init (build_opencl_types);
1200 add_language (&opencl_language_defn);
1201 }
This page took 0.055443 seconds and 4 git commands to generate.