Commit | Line | Data |
---|---|---|
f4b8a18d | 1 | /* OpenCL language support for GDB, the GNU debugger. |
3666a048 | 2 | Copyright (C) 2010-2021 Free Software Foundation, Inc. |
f4b8a18d KW |
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" | |
f4b8a18d KW |
22 | #include "gdbtypes.h" |
23 | #include "symtab.h" | |
24 | #include "expression.h" | |
25 | #include "parser-defs.h" | |
f4b8a18d | 26 | #include "language.h" |
a53b64ea | 27 | #include "varobj.h" |
f4b8a18d | 28 | #include "c-lang.h" |
0d12e84c | 29 | #include "gdbarch.h" |
e9677704 | 30 | #include "c-exp.h" |
f4b8a18d | 31 | |
f4b8a18d KW |
32 | /* Returns the corresponding OpenCL vector type from the given type code, |
33 | the length of the element type, the unsigned flag and the amount of | |
34 | elements (N). */ | |
35 | ||
36 | static struct type * | |
37 | lookup_opencl_vector_type (struct gdbarch *gdbarch, enum type_code code, | |
38 | unsigned int el_length, unsigned int flag_unsigned, | |
39 | int n) | |
40 | { | |
f4b8a18d | 41 | unsigned int length; |
f4b8a18d KW |
42 | |
43 | /* Check if n describes a valid OpenCL vector size (2, 3, 4, 8, 16). */ | |
44 | if (n != 2 && n != 3 && n != 4 && n != 8 && n != 16) | |
45 | error (_("Invalid OpenCL vector size: %d"), n); | |
46 | ||
47 | /* Triple vectors have the size of a quad vector. */ | |
48 | length = (n == 3) ? el_length * 4 : el_length * n; | |
49 | ||
cbbcd7a7 | 50 | auto filter = [&] (struct type *type) |
7bea47f0 AB |
51 | { |
52 | LONGEST lowb, highb; | |
53 | ||
54 | return (type->code () == TYPE_CODE_ARRAY && type->is_vector () | |
55 | && get_array_bounds (type, &lowb, &highb) | |
56 | && TYPE_TARGET_TYPE (type)->code () == code | |
57 | && TYPE_TARGET_TYPE (type)->is_unsigned () == flag_unsigned | |
58 | && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == el_length | |
59 | && TYPE_LENGTH (type) == length | |
60 | && highb - lowb + 1 == n); | |
61 | }; | |
62 | const struct language_defn *lang = language_def (language_opencl); | |
63 | return language_lookup_primitive_type (lang, gdbarch, filter); | |
f4b8a18d KW |
64 | } |
65 | ||
66 | /* Returns nonzero if the array ARR contains duplicates within | |
67 | the first N elements. */ | |
68 | ||
69 | static int | |
70 | array_has_dups (int *arr, int n) | |
71 | { | |
72 | int i, j; | |
73 | ||
74 | for (i = 0; i < n; i++) | |
75 | { | |
76 | for (j = i + 1; j < n; j++) | |
dda83cd7 SM |
77 | { |
78 | if (arr[i] == arr[j]) | |
79 | return 1; | |
80 | } | |
f4b8a18d KW |
81 | } |
82 | ||
83 | return 0; | |
84 | } | |
85 | ||
86 | /* The OpenCL component access syntax allows to create lvalues referring to | |
87 | selected elements of an original OpenCL vector in arbitrary order. This | |
88 | structure holds the information to describe such lvalues. */ | |
89 | ||
90 | struct lval_closure | |
91 | { | |
92 | /* Reference count. */ | |
93 | int refc; | |
94 | /* The number of indices. */ | |
95 | int n; | |
96 | /* The element indices themselves. */ | |
97 | int *indices; | |
98 | /* A pointer to the original value. */ | |
99 | struct value *val; | |
100 | }; | |
101 | ||
102 | /* Allocates an instance of struct lval_closure. */ | |
103 | ||
104 | static struct lval_closure * | |
105 | allocate_lval_closure (int *indices, int n, struct value *val) | |
106 | { | |
41bf6aca | 107 | struct lval_closure *c = XCNEW (struct lval_closure); |
f4b8a18d KW |
108 | |
109 | c->refc = 1; | |
110 | c->n = n; | |
fc270c35 | 111 | c->indices = XCNEWVEC (int, n); |
f4b8a18d KW |
112 | memcpy (c->indices, indices, n * sizeof (int)); |
113 | value_incref (val); /* Increment the reference counter of the value. */ | |
114 | c->val = val; | |
115 | ||
116 | return c; | |
117 | } | |
118 | ||
119 | static void | |
120 | lval_func_read (struct value *v) | |
121 | { | |
122 | struct lval_closure *c = (struct lval_closure *) value_computed_closure (v); | |
123 | struct type *type = check_typedef (value_type (v)); | |
124 | struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val))); | |
6b850546 DT |
125 | LONGEST offset = value_offset (v); |
126 | LONGEST elsize = TYPE_LENGTH (eltype); | |
f4b8a18d KW |
127 | int n, i, j = 0; |
128 | LONGEST lowb = 0; | |
129 | LONGEST highb = 0; | |
130 | ||
78134374 | 131 | if (type->code () == TYPE_CODE_ARRAY |
f4b8a18d KW |
132 | && !get_array_bounds (type, &lowb, &highb)) |
133 | error (_("Could not determine the vector bounds")); | |
134 | ||
135 | /* Assume elsize aligned offset. */ | |
136 | gdb_assert (offset % elsize == 0); | |
137 | offset /= elsize; | |
138 | n = offset + highb - lowb + 1; | |
139 | gdb_assert (n <= c->n); | |
140 | ||
141 | for (i = offset; i < n; i++) | |
142 | memcpy (value_contents_raw (v) + j++ * elsize, | |
143 | value_contents (c->val) + c->indices[i] * elsize, | |
144 | elsize); | |
145 | } | |
146 | ||
147 | static void | |
148 | lval_func_write (struct value *v, struct value *fromval) | |
149 | { | |
150 | struct value *mark = value_mark (); | |
151 | struct lval_closure *c = (struct lval_closure *) value_computed_closure (v); | |
152 | struct type *type = check_typedef (value_type (v)); | |
153 | struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val))); | |
6b850546 DT |
154 | LONGEST offset = value_offset (v); |
155 | LONGEST elsize = TYPE_LENGTH (eltype); | |
f4b8a18d KW |
156 | int n, i, j = 0; |
157 | LONGEST lowb = 0; | |
158 | LONGEST highb = 0; | |
159 | ||
78134374 | 160 | if (type->code () == TYPE_CODE_ARRAY |
f4b8a18d KW |
161 | && !get_array_bounds (type, &lowb, &highb)) |
162 | error (_("Could not determine the vector bounds")); | |
163 | ||
164 | /* Assume elsize aligned offset. */ | |
165 | gdb_assert (offset % elsize == 0); | |
166 | offset /= elsize; | |
167 | n = offset + highb - lowb + 1; | |
168 | ||
169 | /* Since accesses to the fourth component of a triple vector is undefined we | |
170 | just skip writes to the fourth element. Imagine something like this: | |
171 | int3 i3 = (int3)(0, 1, 2); | |
172 | i3.hi.hi = 5; | |
173 | In this case n would be 4 (offset=12/4 + 1) while c->n would be 3. */ | |
174 | if (n > c->n) | |
175 | n = c->n; | |
176 | ||
177 | for (i = offset; i < n; i++) | |
178 | { | |
179 | struct value *from_elm_val = allocate_value (eltype); | |
180 | struct value *to_elm_val = value_subscript (c->val, c->indices[i]); | |
181 | ||
182 | memcpy (value_contents_writeable (from_elm_val), | |
183 | value_contents (fromval) + j++ * elsize, | |
184 | elsize); | |
185 | value_assign (to_elm_val, from_elm_val); | |
186 | } | |
187 | ||
188 | value_free_to_mark (mark); | |
189 | } | |
190 | ||
8cf6f0b1 TT |
191 | /* Return nonzero if bits in V from OFFSET and LENGTH represent a |
192 | synthetic pointer. */ | |
193 | ||
194 | static int | |
195 | lval_func_check_synthetic_pointer (const struct value *v, | |
6b850546 | 196 | LONGEST offset, int length) |
8cf6f0b1 TT |
197 | { |
198 | struct lval_closure *c = (struct lval_closure *) value_computed_closure (v); | |
199 | /* Size of the target type in bits. */ | |
200 | int elsize = | |
201 | TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8; | |
202 | int startrest = offset % elsize; | |
203 | int start = offset / elsize; | |
204 | int endrest = (offset + length) % elsize; | |
205 | int end = (offset + length) / elsize; | |
206 | int i; | |
207 | ||
208 | if (endrest) | |
209 | end++; | |
210 | ||
211 | if (end > c->n) | |
212 | return 0; | |
213 | ||
214 | for (i = start; i < end; i++) | |
215 | { | |
8f9a01ee MS |
216 | int comp_offset = (i == start) ? startrest : 0; |
217 | int comp_length = (i == end) ? endrest : elsize; | |
8cf6f0b1 TT |
218 | |
219 | if (!value_bits_synthetic_pointer (c->val, | |
8f9a01ee MS |
220 | c->indices[i] * elsize + comp_offset, |
221 | comp_length)) | |
8cf6f0b1 TT |
222 | return 0; |
223 | } | |
224 | ||
225 | return 1; | |
226 | } | |
227 | ||
f4b8a18d KW |
228 | static void * |
229 | lval_func_copy_closure (const struct value *v) | |
230 | { | |
231 | struct lval_closure *c = (struct lval_closure *) value_computed_closure (v); | |
232 | ||
233 | ++c->refc; | |
234 | ||
235 | return c; | |
236 | } | |
237 | ||
238 | static void | |
239 | lval_func_free_closure (struct value *v) | |
240 | { | |
241 | struct lval_closure *c = (struct lval_closure *) value_computed_closure (v); | |
242 | ||
243 | --c->refc; | |
244 | ||
245 | if (c->refc == 0) | |
246 | { | |
22bc8444 | 247 | value_decref (c->val); /* Decrement the reference counter of the value. */ |
f4b8a18d KW |
248 | xfree (c->indices); |
249 | xfree (c); | |
f4b8a18d KW |
250 | } |
251 | } | |
252 | ||
c8f2448a | 253 | static const struct lval_funcs opencl_value_funcs = |
f4b8a18d KW |
254 | { |
255 | lval_func_read, | |
256 | lval_func_write, | |
a471c594 JK |
257 | NULL, /* indirect */ |
258 | NULL, /* coerce_ref */ | |
8cf6f0b1 | 259 | lval_func_check_synthetic_pointer, |
f4b8a18d KW |
260 | lval_func_copy_closure, |
261 | lval_func_free_closure | |
262 | }; | |
263 | ||
264 | /* Creates a sub-vector from VAL. The elements are selected by the indices of | |
265 | an array with the length of N. Supported values for NOSIDE are | |
266 | EVAL_NORMAL and EVAL_AVOID_SIDE_EFFECTS. */ | |
267 | ||
268 | static struct value * | |
269 | create_value (struct gdbarch *gdbarch, struct value *val, enum noside noside, | |
270 | int *indices, int n) | |
271 | { | |
272 | struct type *type = check_typedef (value_type (val)); | |
273 | struct type *elm_type = TYPE_TARGET_TYPE (type); | |
274 | struct value *ret; | |
275 | ||
276 | /* Check if a single component of a vector is requested which means | |
277 | the resulting type is a (primitive) scalar type. */ | |
278 | if (n == 1) | |
279 | { | |
280 | if (noside == EVAL_AVOID_SIDE_EFFECTS) | |
dda83cd7 | 281 | ret = value_zero (elm_type, not_lval); |
f4b8a18d | 282 | else |
dda83cd7 | 283 | ret = value_subscript (val, indices[0]); |
f4b8a18d KW |
284 | } |
285 | else | |
286 | { | |
287 | /* Multiple components of the vector are requested which means the | |
288 | resulting type is a vector as well. */ | |
289 | struct type *dst_type = | |
78134374 | 290 | lookup_opencl_vector_type (gdbarch, elm_type->code (), |
f4b8a18d | 291 | TYPE_LENGTH (elm_type), |
c6d940a9 | 292 | elm_type->is_unsigned (), n); |
f4b8a18d KW |
293 | |
294 | if (dst_type == NULL) | |
295 | dst_type = init_vector_type (elm_type, n); | |
296 | ||
297 | make_cv_type (TYPE_CONST (type), TYPE_VOLATILE (type), dst_type, NULL); | |
298 | ||
299 | if (noside == EVAL_AVOID_SIDE_EFFECTS) | |
300 | ret = allocate_value (dst_type); | |
301 | else | |
302 | { | |
303 | /* Check whether to create a lvalue or not. */ | |
304 | if (VALUE_LVAL (val) != not_lval && !array_has_dups (indices, n)) | |
305 | { | |
306 | struct lval_closure *c = allocate_lval_closure (indices, n, val); | |
307 | ret = allocate_computed_value (dst_type, &opencl_value_funcs, c); | |
308 | } | |
309 | else | |
310 | { | |
311 | int i; | |
312 | ||
313 | ret = allocate_value (dst_type); | |
314 | ||
315 | /* Copy src val contents into the destination value. */ | |
316 | for (i = 0; i < n; i++) | |
317 | memcpy (value_contents_writeable (ret) | |
318 | + (i * TYPE_LENGTH (elm_type)), | |
319 | value_contents (val) | |
320 | + (indices[i] * TYPE_LENGTH (elm_type)), | |
321 | TYPE_LENGTH (elm_type)); | |
322 | } | |
323 | } | |
324 | } | |
325 | return ret; | |
326 | } | |
327 | ||
328 | /* OpenCL vector component access. */ | |
329 | ||
330 | static struct value * | |
749065b7 TT |
331 | opencl_component_ref (struct expression *exp, struct value *val, |
332 | const char *comps, enum noside noside) | |
f4b8a18d KW |
333 | { |
334 | LONGEST lowb, highb; | |
335 | int src_len; | |
336 | struct value *v; | |
337 | int indices[16], i; | |
338 | int dst_len; | |
339 | ||
340 | if (!get_array_bounds (check_typedef (value_type (val)), &lowb, &highb)) | |
341 | error (_("Could not determine the vector bounds")); | |
342 | ||
343 | src_len = highb - lowb + 1; | |
344 | ||
345 | /* Throw an error if the amount of array elements does not fit a | |
346 | valid OpenCL vector size (2, 3, 4, 8, 16). */ | |
347 | if (src_len != 2 && src_len != 3 && src_len != 4 && src_len != 8 | |
348 | && src_len != 16) | |
349 | error (_("Invalid OpenCL vector size")); | |
350 | ||
351 | if (strcmp (comps, "lo") == 0 ) | |
352 | { | |
353 | dst_len = (src_len == 3) ? 2 : src_len / 2; | |
354 | ||
355 | for (i = 0; i < dst_len; i++) | |
356 | indices[i] = i; | |
357 | } | |
358 | else if (strcmp (comps, "hi") == 0) | |
359 | { | |
360 | dst_len = (src_len == 3) ? 2 : src_len / 2; | |
361 | ||
362 | for (i = 0; i < dst_len; i++) | |
363 | indices[i] = dst_len + i; | |
364 | } | |
365 | else if (strcmp (comps, "even") == 0) | |
366 | { | |
367 | dst_len = (src_len == 3) ? 2 : src_len / 2; | |
368 | ||
369 | for (i = 0; i < dst_len; i++) | |
370 | indices[i] = i*2; | |
371 | } | |
372 | else if (strcmp (comps, "odd") == 0) | |
373 | { | |
374 | dst_len = (src_len == 3) ? 2 : src_len / 2; | |
375 | ||
376 | for (i = 0; i < dst_len; i++) | |
dda83cd7 | 377 | indices[i] = i*2+1; |
f4b8a18d KW |
378 | } |
379 | else if (strncasecmp (comps, "s", 1) == 0) | |
380 | { | |
381 | #define HEXCHAR_TO_INT(C) ((C >= '0' && C <= '9') ? \ | |
dda83cd7 SM |
382 | C-'0' : ((C >= 'A' && C <= 'F') ? \ |
383 | C-'A'+10 : ((C >= 'a' && C <= 'f') ? \ | |
384 | C-'a'+10 : -1))) | |
f4b8a18d KW |
385 | |
386 | dst_len = strlen (comps); | |
387 | /* Skip the s/S-prefix. */ | |
388 | dst_len--; | |
389 | ||
390 | for (i = 0; i < dst_len; i++) | |
391 | { | |
392 | indices[i] = HEXCHAR_TO_INT(comps[i+1]); | |
393 | /* Check if the requested component is invalid or exceeds | |
394 | the vector. */ | |
395 | if (indices[i] < 0 || indices[i] >= src_len) | |
396 | error (_("Invalid OpenCL vector component accessor %s"), comps); | |
397 | } | |
398 | } | |
399 | else | |
400 | { | |
401 | dst_len = strlen (comps); | |
402 | ||
403 | for (i = 0; i < dst_len; i++) | |
404 | { | |
405 | /* x, y, z, w */ | |
406 | switch (comps[i]) | |
407 | { | |
408 | case 'x': | |
409 | indices[i] = 0; | |
410 | break; | |
411 | case 'y': | |
412 | indices[i] = 1; | |
413 | break; | |
414 | case 'z': | |
415 | if (src_len < 3) | |
416 | error (_("Invalid OpenCL vector component accessor %s"), comps); | |
417 | indices[i] = 2; | |
418 | break; | |
419 | case 'w': | |
420 | if (src_len < 4) | |
421 | error (_("Invalid OpenCL vector component accessor %s"), comps); | |
422 | indices[i] = 3; | |
423 | break; | |
424 | default: | |
425 | error (_("Invalid OpenCL vector component accessor %s"), comps); | |
426 | break; | |
427 | } | |
428 | } | |
429 | } | |
430 | ||
431 | /* Throw an error if the amount of requested components does not | |
432 | result in a valid length (1, 2, 3, 4, 8, 16). */ | |
433 | if (dst_len != 1 && dst_len != 2 && dst_len != 3 && dst_len != 4 | |
434 | && dst_len != 8 && dst_len != 16) | |
435 | error (_("Invalid OpenCL vector component accessor %s"), comps); | |
436 | ||
437 | v = create_value (exp->gdbarch, val, noside, indices, dst_len); | |
438 | ||
439 | return v; | |
440 | } | |
441 | ||
442 | /* Perform the unary logical not (!) operation. */ | |
443 | ||
444 | static struct value * | |
445 | opencl_logical_not (struct expression *exp, struct value *arg) | |
446 | { | |
447 | struct type *type = check_typedef (value_type (arg)); | |
448 | struct type *rettype; | |
449 | struct value *ret; | |
450 | ||
bd63c870 | 451 | if (type->code () == TYPE_CODE_ARRAY && type->is_vector ()) |
f4b8a18d KW |
452 | { |
453 | struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type)); | |
454 | LONGEST lowb, highb; | |
455 | int i; | |
456 | ||
457 | if (!get_array_bounds (type, &lowb, &highb)) | |
458 | error (_("Could not determine the vector bounds")); | |
459 | ||
460 | /* Determine the resulting type of the operation and allocate the | |
461 | value. */ | |
462 | rettype = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT, | |
463 | TYPE_LENGTH (eltype), 0, | |
464 | highb - lowb + 1); | |
465 | ret = allocate_value (rettype); | |
466 | ||
467 | for (i = 0; i < highb - lowb + 1; i++) | |
468 | { | |
469 | /* For vector types, the unary operator shall return a 0 if the | |
470 | value of its operand compares unequal to 0, and -1 (i.e. all bits | |
471 | set) if the value of its operand compares equal to 0. */ | |
472 | int tmp = value_logical_not (value_subscript (arg, i)) ? -1 : 0; | |
473 | memset (value_contents_writeable (ret) + i * TYPE_LENGTH (eltype), | |
474 | tmp, TYPE_LENGTH (eltype)); | |
475 | } | |
476 | } | |
477 | else | |
478 | { | |
479 | rettype = language_bool_type (exp->language_defn, exp->gdbarch); | |
480 | ret = value_from_longest (rettype, value_logical_not (arg)); | |
481 | } | |
482 | ||
483 | return ret; | |
484 | } | |
485 | ||
486 | /* Perform a relational operation on two scalar operands. */ | |
487 | ||
488 | static int | |
489 | scalar_relop (struct value *val1, struct value *val2, enum exp_opcode op) | |
490 | { | |
491 | int ret; | |
492 | ||
493 | switch (op) | |
494 | { | |
495 | case BINOP_EQUAL: | |
496 | ret = value_equal (val1, val2); | |
497 | break; | |
498 | case BINOP_NOTEQUAL: | |
499 | ret = !value_equal (val1, val2); | |
500 | break; | |
501 | case BINOP_LESS: | |
502 | ret = value_less (val1, val2); | |
503 | break; | |
504 | case BINOP_GTR: | |
505 | ret = value_less (val2, val1); | |
506 | break; | |
507 | case BINOP_GEQ: | |
508 | ret = value_less (val2, val1) || value_equal (val1, val2); | |
509 | break; | |
510 | case BINOP_LEQ: | |
511 | ret = value_less (val1, val2) || value_equal (val1, val2); | |
512 | break; | |
513 | case BINOP_LOGICAL_AND: | |
514 | ret = !value_logical_not (val1) && !value_logical_not (val2); | |
515 | break; | |
516 | case BINOP_LOGICAL_OR: | |
517 | ret = !value_logical_not (val1) || !value_logical_not (val2); | |
518 | break; | |
519 | default: | |
520 | error (_("Attempt to perform an unsupported operation")); | |
521 | break; | |
522 | } | |
523 | return ret; | |
524 | } | |
525 | ||
526 | /* Perform a relational operation on two vector operands. */ | |
527 | ||
528 | static struct value * | |
529 | vector_relop (struct expression *exp, struct value *val1, struct value *val2, | |
530 | enum exp_opcode op) | |
531 | { | |
532 | struct value *ret; | |
533 | struct type *type1, *type2, *eltype1, *eltype2, *rettype; | |
534 | int t1_is_vec, t2_is_vec, i; | |
535 | LONGEST lowb1, lowb2, highb1, highb2; | |
536 | ||
537 | type1 = check_typedef (value_type (val1)); | |
538 | type2 = check_typedef (value_type (val2)); | |
539 | ||
bd63c870 SM |
540 | t1_is_vec = (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ()); |
541 | t2_is_vec = (type2->code () == TYPE_CODE_ARRAY && type2->is_vector ()); | |
f4b8a18d KW |
542 | |
543 | if (!t1_is_vec || !t2_is_vec) | |
544 | error (_("Vector operations are not supported on scalar types")); | |
545 | ||
546 | eltype1 = check_typedef (TYPE_TARGET_TYPE (type1)); | |
547 | eltype2 = check_typedef (TYPE_TARGET_TYPE (type2)); | |
548 | ||
549 | if (!get_array_bounds (type1,&lowb1, &highb1) | |
550 | || !get_array_bounds (type2, &lowb2, &highb2)) | |
551 | error (_("Could not determine the vector bounds")); | |
552 | ||
553 | /* Check whether the vector types are compatible. */ | |
78134374 | 554 | if (eltype1->code () != eltype2->code () |
f4b8a18d | 555 | || TYPE_LENGTH (eltype1) != TYPE_LENGTH (eltype2) |
c6d940a9 | 556 | || eltype1->is_unsigned () != eltype2->is_unsigned () |
f4b8a18d KW |
557 | || lowb1 != lowb2 || highb1 != highb2) |
558 | error (_("Cannot perform operation on vectors with different types")); | |
559 | ||
560 | /* Determine the resulting type of the operation and allocate the value. */ | |
561 | rettype = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT, | |
562 | TYPE_LENGTH (eltype1), 0, | |
563 | highb1 - lowb1 + 1); | |
564 | ret = allocate_value (rettype); | |
565 | ||
566 | for (i = 0; i < highb1 - lowb1 + 1; i++) | |
567 | { | |
568 | /* For vector types, the relational, equality and logical operators shall | |
569 | return 0 if the specified relation is false and -1 (i.e. all bits set) | |
570 | if the specified relation is true. */ | |
571 | int tmp = scalar_relop (value_subscript (val1, i), | |
572 | value_subscript (val2, i), op) ? -1 : 0; | |
573 | memset (value_contents_writeable (ret) + i * TYPE_LENGTH (eltype1), | |
574 | tmp, TYPE_LENGTH (eltype1)); | |
575 | } | |
576 | ||
577 | return ret; | |
578 | } | |
579 | ||
8954db33 AB |
580 | /* Perform a cast of ARG into TYPE. There's sadly a lot of duplication in |
581 | here from valops.c:value_cast, opencl is different only in the | |
582 | behaviour of scalar to vector casting. As far as possibly we're going | |
583 | to try and delegate back to the standard value_cast function. */ | |
584 | ||
e9677704 | 585 | struct value * |
8954db33 AB |
586 | opencl_value_cast (struct type *type, struct value *arg) |
587 | { | |
588 | if (type != value_type (arg)) | |
589 | { | |
590 | /* Casting scalar to vector is a special case for OpenCL, scalar | |
591 | is cast to element type of vector then replicated into each | |
592 | element of the vector. First though, we need to work out if | |
593 | this is a scalar to vector cast; code lifted from | |
594 | valops.c:value_cast. */ | |
595 | enum type_code code1, code2; | |
596 | struct type *to_type; | |
597 | int scalar; | |
598 | ||
599 | to_type = check_typedef (type); | |
600 | ||
78134374 SM |
601 | code1 = to_type->code (); |
602 | code2 = check_typedef (value_type (arg))->code (); | |
8954db33 AB |
603 | |
604 | if (code2 == TYPE_CODE_REF) | |
78134374 | 605 | code2 = check_typedef (value_type (coerce_ref(arg)))->code (); |
8954db33 AB |
606 | |
607 | scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL | |
608 | || code2 == TYPE_CODE_CHAR || code2 == TYPE_CODE_FLT | |
609 | || code2 == TYPE_CODE_DECFLOAT || code2 == TYPE_CODE_ENUM | |
610 | || code2 == TYPE_CODE_RANGE); | |
611 | ||
bd63c870 | 612 | if (code1 == TYPE_CODE_ARRAY && to_type->is_vector () && scalar) |
8954db33 AB |
613 | { |
614 | struct type *eltype; | |
615 | ||
616 | /* Cast to the element type of the vector here as | |
617 | value_vector_widen will error if the scalar value is | |
618 | truncated by the cast. To avoid the error, cast (and | |
619 | possibly truncate) here. */ | |
620 | eltype = check_typedef (TYPE_TARGET_TYPE (to_type)); | |
621 | arg = value_cast (eltype, arg); | |
622 | ||
623 | return value_vector_widen (arg, type); | |
624 | } | |
625 | else | |
626 | /* Standard cast handler. */ | |
627 | arg = value_cast (type, arg); | |
628 | } | |
629 | return arg; | |
630 | } | |
631 | ||
f4b8a18d KW |
632 | /* Perform a relational operation on two operands. */ |
633 | ||
634 | static struct value * | |
635 | opencl_relop (struct expression *exp, struct value *arg1, struct value *arg2, | |
636 | enum exp_opcode op) | |
637 | { | |
638 | struct value *val; | |
639 | struct type *type1 = check_typedef (value_type (arg1)); | |
640 | struct type *type2 = check_typedef (value_type (arg2)); | |
78134374 | 641 | int t1_is_vec = (type1->code () == TYPE_CODE_ARRAY |
bd63c870 | 642 | && type1->is_vector ()); |
78134374 | 643 | int t2_is_vec = (type2->code () == TYPE_CODE_ARRAY |
bd63c870 | 644 | && type2->is_vector ()); |
f4b8a18d KW |
645 | |
646 | if (!t1_is_vec && !t2_is_vec) | |
647 | { | |
648 | int tmp = scalar_relop (arg1, arg2, op); | |
649 | struct type *type = | |
650 | language_bool_type (exp->language_defn, exp->gdbarch); | |
651 | ||
652 | val = value_from_longest (type, tmp); | |
653 | } | |
654 | else if (t1_is_vec && t2_is_vec) | |
655 | { | |
656 | val = vector_relop (exp, arg1, arg2, op); | |
657 | } | |
658 | else | |
659 | { | |
660 | /* Widen the scalar operand to a vector. */ | |
661 | struct value **v = t1_is_vec ? &arg2 : &arg1; | |
662 | struct type *t = t1_is_vec ? type2 : type1; | |
663 | ||
78134374 | 664 | if (t->code () != TYPE_CODE_FLT && !is_integral_type (t)) |
f4b8a18d KW |
665 | error (_("Argument to operation not a number or boolean.")); |
666 | ||
8954db33 | 667 | *v = opencl_value_cast (t1_is_vec ? type1 : type2, *v); |
f4b8a18d KW |
668 | val = vector_relop (exp, arg1, arg2, op); |
669 | } | |
670 | ||
671 | return val; | |
672 | } | |
673 | ||
3634f669 TT |
674 | /* A helper function for BINOP_ASSIGN. */ |
675 | ||
676 | static struct value * | |
677 | eval_opencl_assign (struct type *expect_type, struct expression *exp, | |
678 | enum noside noside, | |
679 | struct value *arg1, struct value *arg2) | |
680 | { | |
681 | if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS) | |
682 | return arg1; | |
683 | ||
684 | struct type *type1 = value_type (arg1); | |
685 | if (deprecated_value_modifiable (arg1) | |
686 | && VALUE_LVAL (arg1) != lval_internalvar) | |
687 | arg2 = opencl_value_cast (type1, arg2); | |
688 | ||
689 | return value_assign (arg1, arg2); | |
690 | } | |
691 | ||
f4b8a18d KW |
692 | /* Expression evaluator for the OpenCL. Most operations are delegated to |
693 | evaluate_subexp_standard; see that function for a description of the | |
694 | arguments. */ | |
695 | ||
696 | static struct value * | |
697 | evaluate_subexp_opencl (struct type *expect_type, struct expression *exp, | |
698 | int *pos, enum noside noside) | |
699 | { | |
700 | enum exp_opcode op = exp->elts[*pos].opcode; | |
701 | struct value *arg1 = NULL; | |
702 | struct value *arg2 = NULL; | |
703 | struct type *type1, *type2; | |
704 | ||
705 | switch (op) | |
706 | { | |
8954db33 AB |
707 | /* Handle assignment and cast operators to support OpenCL-style |
708 | scalar-to-vector widening. */ | |
709 | case BINOP_ASSIGN: | |
710 | (*pos)++; | |
fe1fe7ea | 711 | arg1 = evaluate_subexp (nullptr, exp, pos, noside); |
8954db33 AB |
712 | type1 = value_type (arg1); |
713 | arg2 = evaluate_subexp (type1, exp, pos, noside); | |
714 | ||
3634f669 | 715 | return eval_opencl_assign (expect_type, exp, noside, arg1, arg2); |
8954db33 AB |
716 | |
717 | case UNOP_CAST: | |
718 | type1 = exp->elts[*pos + 1].type; | |
719 | (*pos) += 2; | |
720 | arg1 = evaluate_subexp (type1, exp, pos, noside); | |
721 | ||
722 | if (noside == EVAL_SKIP) | |
723 | return value_from_longest (builtin_type (exp->gdbarch)-> | |
724 | builtin_int, 1); | |
725 | ||
726 | return opencl_value_cast (type1, arg1); | |
727 | ||
728 | case UNOP_CAST_TYPE: | |
729 | (*pos)++; | |
730 | arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS); | |
731 | type1 = value_type (arg1); | |
732 | arg1 = evaluate_subexp (type1, exp, pos, noside); | |
733 | ||
734 | if (noside == EVAL_SKIP) | |
735 | return value_from_longest (builtin_type (exp->gdbarch)-> | |
736 | builtin_int, 1); | |
737 | ||
738 | return opencl_value_cast (type1, arg1); | |
739 | ||
f4b8a18d KW |
740 | /* Handle binary relational and equality operators that are either not |
741 | or differently defined for GNU vectors. */ | |
742 | case BINOP_EQUAL: | |
743 | case BINOP_NOTEQUAL: | |
744 | case BINOP_LESS: | |
745 | case BINOP_GTR: | |
746 | case BINOP_GEQ: | |
747 | case BINOP_LEQ: | |
748 | (*pos)++; | |
fe1fe7ea | 749 | arg1 = evaluate_subexp (nullptr, exp, pos, noside); |
f4b8a18d KW |
750 | arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); |
751 | ||
752 | if (noside == EVAL_SKIP) | |
753 | return value_from_longest (builtin_type (exp->gdbarch)-> | |
754 | builtin_int, 1); | |
755 | ||
756 | return opencl_relop (exp, arg1, arg2, op); | |
757 | ||
758 | /* Handle the logical unary operator not(!). */ | |
759 | case UNOP_LOGICAL_NOT: | |
760 | (*pos)++; | |
fe1fe7ea | 761 | arg1 = evaluate_subexp (nullptr, exp, pos, noside); |
f4b8a18d KW |
762 | |
763 | if (noside == EVAL_SKIP) | |
764 | return value_from_longest (builtin_type (exp->gdbarch)-> | |
765 | builtin_int, 1); | |
766 | ||
767 | return opencl_logical_not (exp, arg1); | |
768 | ||
769 | /* Handle the logical operator and(&&) and or(||). */ | |
770 | case BINOP_LOGICAL_AND: | |
771 | case BINOP_LOGICAL_OR: | |
772 | (*pos)++; | |
fe1fe7ea | 773 | arg1 = evaluate_subexp (nullptr, exp, pos, noside); |
f4b8a18d KW |
774 | |
775 | if (noside == EVAL_SKIP) | |
776 | { | |
fe1fe7ea | 777 | evaluate_subexp (nullptr, exp, pos, noside); |
f4b8a18d KW |
778 | |
779 | return value_from_longest (builtin_type (exp->gdbarch)-> | |
780 | builtin_int, 1); | |
781 | } | |
782 | else | |
783 | { | |
784 | /* For scalar operations we need to avoid evaluating operands | |
85102364 | 785 | unnecessarily. However, for vector operations we always need to |
f4b8a18d KW |
786 | evaluate both operands. Unfortunately we only know which of the |
787 | two cases apply after we know the type of the second operand. | |
788 | Therefore we evaluate it once using EVAL_AVOID_SIDE_EFFECTS. */ | |
789 | int oldpos = *pos; | |
790 | ||
fe1fe7ea | 791 | arg2 = evaluate_subexp (nullptr, exp, pos, EVAL_AVOID_SIDE_EFFECTS); |
f4b8a18d KW |
792 | *pos = oldpos; |
793 | type1 = check_typedef (value_type (arg1)); | |
794 | type2 = check_typedef (value_type (arg2)); | |
795 | ||
bd63c870 SM |
796 | if ((type1->code () == TYPE_CODE_ARRAY && type1->is_vector ()) |
797 | || (type2->code () == TYPE_CODE_ARRAY && type2->is_vector ())) | |
f4b8a18d | 798 | { |
fe1fe7ea | 799 | arg2 = evaluate_subexp (nullptr, exp, pos, noside); |
f4b8a18d KW |
800 | |
801 | return opencl_relop (exp, arg1, arg2, op); | |
802 | } | |
803 | else | |
804 | { | |
805 | /* For scalar built-in types, only evaluate the right | |
806 | hand operand if the left hand operand compares | |
807 | unequal(&&)/equal(||) to 0. */ | |
808 | int res; | |
809 | int tmp = value_logical_not (arg1); | |
810 | ||
811 | if (op == BINOP_LOGICAL_OR) | |
812 | tmp = !tmp; | |
813 | ||
fe1fe7ea SM |
814 | arg2 |
815 | = evaluate_subexp (nullptr, exp, pos, tmp ? EVAL_SKIP : noside); | |
f4b8a18d KW |
816 | type1 = language_bool_type (exp->language_defn, exp->gdbarch); |
817 | ||
818 | if (op == BINOP_LOGICAL_AND) | |
819 | res = !tmp && !value_logical_not (arg2); | |
820 | else /* BINOP_LOGICAL_OR */ | |
821 | res = tmp || !value_logical_not (arg2); | |
822 | ||
823 | return value_from_longest (type1, res); | |
824 | } | |
825 | } | |
826 | ||
827 | /* Handle the ternary selection operator. */ | |
828 | case TERNOP_COND: | |
829 | (*pos)++; | |
fe1fe7ea | 830 | arg1 = evaluate_subexp (nullptr, exp, pos, noside); |
f4b8a18d | 831 | type1 = check_typedef (value_type (arg1)); |
bd63c870 | 832 | if (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ()) |
f4b8a18d KW |
833 | { |
834 | struct value *arg3, *tmp, *ret; | |
835 | struct type *eltype2, *type3, *eltype3; | |
836 | int t2_is_vec, t3_is_vec, i; | |
837 | LONGEST lowb1, lowb2, lowb3, highb1, highb2, highb3; | |
838 | ||
fe1fe7ea SM |
839 | arg2 = evaluate_subexp (nullptr, exp, pos, noside); |
840 | arg3 = evaluate_subexp (nullptr, exp, pos, noside); | |
f4b8a18d KW |
841 | type2 = check_typedef (value_type (arg2)); |
842 | type3 = check_typedef (value_type (arg3)); | |
843 | t2_is_vec | |
bd63c870 | 844 | = type2->code () == TYPE_CODE_ARRAY && type2->is_vector (); |
f4b8a18d | 845 | t3_is_vec |
bd63c870 | 846 | = type3->code () == TYPE_CODE_ARRAY && type3->is_vector (); |
f4b8a18d KW |
847 | |
848 | /* Widen the scalar operand to a vector if necessary. */ | |
849 | if (t2_is_vec || !t3_is_vec) | |
850 | { | |
8954db33 | 851 | arg3 = opencl_value_cast (type2, arg3); |
f4b8a18d KW |
852 | type3 = value_type (arg3); |
853 | } | |
854 | else if (!t2_is_vec || t3_is_vec) | |
855 | { | |
8954db33 | 856 | arg2 = opencl_value_cast (type3, arg2); |
f4b8a18d KW |
857 | type2 = value_type (arg2); |
858 | } | |
859 | else if (!t2_is_vec || !t3_is_vec) | |
860 | { | |
861 | /* Throw an error if arg2 or arg3 aren't vectors. */ | |
862 | error (_("\ | |
863 | Cannot perform conditional operation on incompatible types")); | |
864 | } | |
865 | ||
866 | eltype2 = check_typedef (TYPE_TARGET_TYPE (type2)); | |
867 | eltype3 = check_typedef (TYPE_TARGET_TYPE (type3)); | |
868 | ||
869 | if (!get_array_bounds (type1, &lowb1, &highb1) | |
870 | || !get_array_bounds (type2, &lowb2, &highb2) | |
871 | || !get_array_bounds (type3, &lowb3, &highb3)) | |
872 | error (_("Could not determine the vector bounds")); | |
873 | ||
874 | /* Throw an error if the types of arg2 or arg3 are incompatible. */ | |
78134374 | 875 | if (eltype2->code () != eltype3->code () |
f4b8a18d | 876 | || TYPE_LENGTH (eltype2) != TYPE_LENGTH (eltype3) |
c6d940a9 | 877 | || eltype2->is_unsigned () != eltype3->is_unsigned () |
f4b8a18d KW |
878 | || lowb2 != lowb3 || highb2 != highb3) |
879 | error (_("\ | |
880 | Cannot perform operation on vectors with different types")); | |
881 | ||
882 | /* Throw an error if the sizes of arg1 and arg2/arg3 differ. */ | |
883 | if (lowb1 != lowb2 || lowb1 != lowb3 | |
884 | || highb1 != highb2 || highb1 != highb3) | |
885 | error (_("\ | |
886 | Cannot perform conditional operation on vectors with different sizes")); | |
887 | ||
888 | ret = allocate_value (type2); | |
889 | ||
890 | for (i = 0; i < highb1 - lowb1 + 1; i++) | |
891 | { | |
892 | tmp = value_logical_not (value_subscript (arg1, i)) ? | |
893 | value_subscript (arg3, i) : value_subscript (arg2, i); | |
894 | memcpy (value_contents_writeable (ret) + | |
895 | i * TYPE_LENGTH (eltype2), value_contents_all (tmp), | |
896 | TYPE_LENGTH (eltype2)); | |
897 | } | |
898 | ||
899 | return ret; | |
900 | } | |
901 | else | |
902 | { | |
903 | if (value_logical_not (arg1)) | |
904 | { | |
905 | /* Skip the second operand. */ | |
fe1fe7ea | 906 | evaluate_subexp (nullptr, exp, pos, EVAL_SKIP); |
f4b8a18d | 907 | |
fe1fe7ea | 908 | return evaluate_subexp (nullptr, exp, pos, noside); |
f4b8a18d KW |
909 | } |
910 | else | |
911 | { | |
912 | /* Skip the third operand. */ | |
fe1fe7ea SM |
913 | arg2 = evaluate_subexp (nullptr, exp, pos, noside); |
914 | evaluate_subexp (nullptr, exp, pos, EVAL_SKIP); | |
f4b8a18d KW |
915 | |
916 | return arg2; | |
917 | } | |
918 | } | |
919 | ||
920 | /* Handle STRUCTOP_STRUCT to allow component access on OpenCL vectors. */ | |
921 | case STRUCTOP_STRUCT: | |
922 | { | |
923 | int pc = (*pos)++; | |
924 | int tem = longest_to_int (exp->elts[pc + 1].longconst); | |
925 | ||
926 | (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1); | |
fe1fe7ea | 927 | arg1 = evaluate_subexp (nullptr, exp, pos, noside); |
f4b8a18d KW |
928 | type1 = check_typedef (value_type (arg1)); |
929 | ||
930 | if (noside == EVAL_SKIP) | |
931 | { | |
932 | return value_from_longest (builtin_type (exp->gdbarch)-> | |
933 | builtin_int, 1); | |
934 | } | |
bd63c870 | 935 | else if (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ()) |
f4b8a18d KW |
936 | { |
937 | return opencl_component_ref (exp, arg1, &exp->elts[pc + 2].string, | |
938 | noside); | |
939 | } | |
940 | else | |
941 | { | |
ac1ca910 TT |
942 | struct value *v = value_struct_elt (&arg1, NULL, |
943 | &exp->elts[pc + 2].string, NULL, | |
944 | "structure"); | |
945 | ||
946 | if (noside == EVAL_AVOID_SIDE_EFFECTS) | |
51415b9f | 947 | v = value_zero (value_type (v), VALUE_LVAL (v)); |
ac1ca910 | 948 | return v; |
f4b8a18d KW |
949 | } |
950 | } | |
951 | default: | |
952 | break; | |
953 | } | |
954 | ||
955 | return evaluate_subexp_c (expect_type, exp, pos, noside); | |
956 | } | |
957 | ||
f4b8a18d KW |
958 | const struct exp_descriptor exp_descriptor_opencl = |
959 | { | |
960 | print_subexp_standard, | |
961 | operator_length_standard, | |
962 | operator_check_standard, | |
f4b8a18d KW |
963 | dump_subexp_body_standard, |
964 | evaluate_subexp_opencl | |
965 | }; | |
966 | ||
0874fd07 AB |
967 | /* Class representing the OpenCL language. */ |
968 | ||
969 | class opencl_language : public language_defn | |
970 | { | |
971 | public: | |
972 | opencl_language () | |
0e25e767 | 973 | : language_defn (language_opencl) |
0874fd07 | 974 | { /* Nothing. */ } |
1fb314aa | 975 | |
6f7664a9 AB |
976 | /* See language.h. */ |
977 | ||
978 | const char *name () const override | |
979 | { return "opencl"; } | |
980 | ||
981 | /* See language.h. */ | |
982 | ||
983 | const char *natural_name () const override | |
984 | { return "OpenCL C"; } | |
985 | ||
1fb314aa AB |
986 | /* See language.h. */ |
987 | void language_arch_info (struct gdbarch *gdbarch, | |
988 | struct language_arch_info *lai) const override | |
989 | { | |
7bea47f0 AB |
990 | /* Helper function to allow shorter lines below. */ |
991 | auto add = [&] (struct type * t) -> struct type * | |
992 | { | |
993 | lai->add_primitive_type (t); | |
994 | return t; | |
995 | }; | |
1fb314aa | 996 | |
7bea47f0 AB |
997 | /* Helper macro to create strings. */ |
998 | #define OCL_STRING(S) #S | |
999 | ||
1000 | /* This macro allocates and assigns the type struct pointers | |
1001 | for the vector types. */ | |
1002 | #define BUILD_OCL_VTYPES(TYPE, ELEMENT_TYPE) \ | |
1003 | do \ | |
1004 | { \ | |
1005 | struct type *tmp; \ | |
1006 | tmp = add (init_vector_type (ELEMENT_TYPE, 2)); \ | |
1007 | tmp->set_name (OCL_STRING(TYPE ## 2)); \ | |
1008 | tmp = add (init_vector_type (ELEMENT_TYPE, 3)); \ | |
1009 | tmp->set_name (OCL_STRING(TYPE ## 3)); \ | |
1010 | TYPE_LENGTH (tmp) = 4 * TYPE_LENGTH (ELEMENT_TYPE); \ | |
1011 | tmp = add (init_vector_type (ELEMENT_TYPE, 4)); \ | |
1012 | tmp->set_name (OCL_STRING(TYPE ## 4)); \ | |
1013 | tmp = add (init_vector_type (ELEMENT_TYPE, 8)); \ | |
1014 | tmp->set_name (OCL_STRING(TYPE ## 8)); \ | |
1015 | tmp = init_vector_type (ELEMENT_TYPE, 16); \ | |
1016 | tmp->set_name (OCL_STRING(TYPE ## 16)); \ | |
1017 | } \ | |
1018 | while (false) | |
1019 | ||
1020 | struct type *el_type, *char_type, *int_type; | |
1021 | ||
1022 | char_type = el_type = add (arch_integer_type (gdbarch, 8, 0, "char")); | |
1023 | BUILD_OCL_VTYPES (char, el_type); | |
1024 | el_type = add (arch_integer_type (gdbarch, 8, 1, "uchar")); | |
1025 | BUILD_OCL_VTYPES (uchar, el_type); | |
1026 | el_type = add (arch_integer_type (gdbarch, 16, 0, "short")); | |
1027 | BUILD_OCL_VTYPES (short, el_type); | |
1028 | el_type = add (arch_integer_type (gdbarch, 16, 1, "ushort")); | |
1029 | BUILD_OCL_VTYPES (ushort, el_type); | |
1030 | int_type = el_type = add (arch_integer_type (gdbarch, 32, 0, "int")); | |
1031 | BUILD_OCL_VTYPES (int, el_type); | |
1032 | el_type = add (arch_integer_type (gdbarch, 32, 1, "uint")); | |
1033 | BUILD_OCL_VTYPES (uint, el_type); | |
1034 | el_type = add (arch_integer_type (gdbarch, 64, 0, "long")); | |
1035 | BUILD_OCL_VTYPES (long, el_type); | |
1036 | el_type = add (arch_integer_type (gdbarch, 64, 1, "ulong")); | |
1037 | BUILD_OCL_VTYPES (ulong, el_type); | |
1038 | el_type = add (arch_float_type (gdbarch, 16, "half", floatformats_ieee_half)); | |
1039 | BUILD_OCL_VTYPES (half, el_type); | |
1040 | el_type = add (arch_float_type (gdbarch, 32, "float", floatformats_ieee_single)); | |
1041 | BUILD_OCL_VTYPES (float, el_type); | |
1042 | el_type = add (arch_float_type (gdbarch, 64, "double", floatformats_ieee_double)); | |
1043 | BUILD_OCL_VTYPES (double, el_type); | |
1044 | ||
1045 | add (arch_boolean_type (gdbarch, 8, 1, "bool")); | |
1046 | add (arch_integer_type (gdbarch, 8, 1, "unsigned char")); | |
1047 | add (arch_integer_type (gdbarch, 16, 1, "unsigned short")); | |
1048 | add (arch_integer_type (gdbarch, 32, 1, "unsigned int")); | |
1049 | add (arch_integer_type (gdbarch, 64, 1, "unsigned long")); | |
1050 | add (arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "size_t")); | |
1051 | add (arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "ptrdiff_t")); | |
1052 | add (arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "intptr_t")); | |
1053 | add (arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "uintptr_t")); | |
1054 | add (arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void")); | |
1fb314aa AB |
1055 | |
1056 | /* Type of elements of strings. */ | |
7bea47f0 | 1057 | lai->set_string_char_type (char_type); |
1fb314aa AB |
1058 | |
1059 | /* Specifies the return type of logical and relational operations. */ | |
7bea47f0 | 1060 | lai->set_bool_type (int_type, "int"); |
1fb314aa | 1061 | } |
fbfb0a46 AB |
1062 | |
1063 | /* See language.h. */ | |
1064 | ||
1065 | void print_type (struct type *type, const char *varstring, | |
1066 | struct ui_file *stream, int show, int level, | |
1067 | const struct type_print_options *flags) const override | |
1068 | { | |
1069 | /* We nearly always defer to C type printing, except that vector types | |
1070 | are considered primitive in OpenCL, and should always be printed | |
1071 | using their TYPE_NAME. */ | |
1072 | if (show > 0) | |
1073 | { | |
1074 | type = check_typedef (type); | |
bd63c870 | 1075 | if (type->code () == TYPE_CODE_ARRAY && type->is_vector () |
fbfb0a46 AB |
1076 | && type->name () != NULL) |
1077 | show = 0; | |
1078 | } | |
1079 | ||
1080 | c_print_type (type, varstring, stream, show, level, flags); | |
1081 | } | |
1ac14a04 AB |
1082 | |
1083 | /* See language.h. */ | |
1084 | ||
1085 | enum macro_expansion macro_expansion () const override | |
1086 | { return macro_expansion_c; } | |
5aba6ebe AB |
1087 | |
1088 | /* See language.h. */ | |
1089 | ||
1090 | const struct exp_descriptor *expression_ops () const override | |
1091 | { return &exp_descriptor_opencl; } | |
b7c6e27d AB |
1092 | |
1093 | /* See language.h. */ | |
1094 | ||
1095 | const struct op_print *opcode_print_table () const override | |
1096 | { return c_op_print_tab; } | |
0874fd07 AB |
1097 | }; |
1098 | ||
1099 | /* Single instance of the OpenCL language class. */ | |
1100 | ||
1101 | static opencl_language opencl_language_defn; |