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