contrib/gdb-7/gdb/opencl-lang.c

   1 /* OpenCL language support for GDB, the GNU debugger.
   2    Copyright (C) 2010, 2011 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 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 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,
 364     lval_func_check_synthetic_pointer,
 365     lval_func_copy_closure,
 366     lval_func_free_closure
 367   };
 368
 369 /* Creates a sub-vector from VAL.  The elements are selected by the indices of
 370    an array with the length of N.  Supported values for NOSIDE are
 371    EVAL_NORMAL and EVAL_AVOID_SIDE_EFFECTS.  */
 372
 373 static struct value *
 374 create_value (struct gdbarch *gdbarch, struct value *val, enum noside noside,
 375               int *indices, int n)
 376 {
 377   struct type *type = check_typedef (value_type (val));
 378   struct type *elm_type = TYPE_TARGET_TYPE (type);
 379   struct value *ret;
 380
 381   /* Check if a single component of a vector is requested which means
 382      the resulting type is a (primitive) scalar type.  */
 383   if (n == 1)
 384     {
 385       if (noside == EVAL_AVOID_SIDE_EFFECTS)
 386         ret = value_zero (elm_type, not_lval);
 387       else
 388         ret = value_subscript (val, indices[0]);
 389     }
 390   else
 391     {
 392       /* Multiple components of the vector are requested which means the
 393          resulting type is a vector as well.  */
 394       struct type *dst_type =
 395         lookup_opencl_vector_type (gdbarch, TYPE_CODE (elm_type),
 396                                    TYPE_LENGTH (elm_type),
 397                                    TYPE_UNSIGNED (elm_type), n);
 398
 399       if (dst_type == NULL)
 400         dst_type = init_vector_type (elm_type, n);
 401
 402       make_cv_type (TYPE_CONST (type), TYPE_VOLATILE (type), dst_type, NULL);
 403
 404       if (noside == EVAL_AVOID_SIDE_EFFECTS)
 405         ret = allocate_value (dst_type);
 406       else
 407         {
 408           /* Check whether to create a lvalue or not.  */
 409           if (VALUE_LVAL (val) != not_lval && !array_has_dups (indices, n))
 410             {
 411               struct lval_closure *c = allocate_lval_closure (indices, n, val);
 412               ret = allocate_computed_value (dst_type, &opencl_value_funcs, c);
 413             }
 414           else
 415             {
 416               int i;
 417
 418               ret = allocate_value (dst_type);
 419
 420               /* Copy src val contents into the destination value.  */
 421               for (i = 0; i < n; i++)
 422                 memcpy (value_contents_writeable (ret)
 423                         + (i * TYPE_LENGTH (elm_type)),
 424                         value_contents (val)
 425                         + (indices[i] * TYPE_LENGTH (elm_type)),
 426                         TYPE_LENGTH (elm_type));
 427             }
 428         }
 429     }
 430   return ret;
 431 }
 432
 433 /* OpenCL vector component access.  */
 434
 435 static struct value *
 436 opencl_component_ref (struct expression *exp, struct value *val, char *comps,
 437                       enum noside noside)
 438 {
 439   LONGEST lowb, highb;
 440   int src_len;
 441   struct value *v;
 442   int indices[16], i;
 443   int dst_len;
 444
 445   if (!get_array_bounds (check_typedef (value_type (val)), &lowb, &highb))
 446     error (_("Could not determine the vector bounds"));
 447
 448   src_len = highb - lowb + 1;
 449
 450   /* Throw an error if the amount of array elements does not fit a
 451      valid OpenCL vector size (2, 3, 4, 8, 16).  */
 452   if (src_len != 2 && src_len != 3 && src_len != 4 && src_len != 8
 453       && src_len != 16)
 454     error (_("Invalid OpenCL vector size"));
 455
 456   if (strcmp (comps, "lo") == 0 )
 457     {
 458       dst_len = (src_len == 3) ? 2 : src_len / 2;
 459
 460       for (i = 0; i < dst_len; i++)
 461         indices[i] = i;
 462     }
 463   else if (strcmp (comps, "hi") == 0)
 464     {
 465       dst_len = (src_len == 3) ? 2 : src_len / 2;
 466
 467       for (i = 0; i < dst_len; i++)
 468         indices[i] = dst_len + i;
 469     }
 470   else if (strcmp (comps, "even") == 0)
 471     {
 472       dst_len = (src_len == 3) ? 2 : src_len / 2;
 473
 474       for (i = 0; i < dst_len; i++)
 475         indices[i] = i*2;
 476     }
 477   else if (strcmp (comps, "odd") == 0)
 478     {
 479       dst_len = (src_len == 3) ? 2 : src_len / 2;
 480
 481       for (i = 0; i < dst_len; i++)
 482         indices[i] = i*2+1;
 483     }
 484   else if (strncasecmp (comps, "s", 1) == 0)
 485     {
 486 #define HEXCHAR_TO_INT(C) ((C >= '0' && C <= '9') ? \
 487                            C-'0' : ((C >= 'A' && C <= 'F') ? \
 488                            C-'A'+10 : ((C >= 'a' && C <= 'f') ? \
 489                            C-'a'+10 : -1)))
 490
 491       dst_len = strlen (comps);
 492       /* Skip the s/S-prefix.  */
 493       dst_len--;
 494
 495       for (i = 0; i < dst_len; i++)
 496         {
 497           indices[i] = HEXCHAR_TO_INT(comps[i+1]);
 498           /* Check if the requested component is invalid or exceeds
 499              the vector.  */
 500           if (indices[i] < 0 || indices[i] >= src_len)
 501             error (_("Invalid OpenCL vector component accessor %s"), comps);
 502         }
 503     }
 504   else
 505     {
 506       dst_len = strlen (comps);
 507
 508       for (i = 0; i < dst_len; i++)
 509         {
 510           /* x, y, z, w */
 511           switch (comps[i])
 512           {
 513           case 'x':
 514             indices[i] = 0;
 515             break;
 516           case 'y':
 517             indices[i] = 1;
 518             break;
 519           case 'z':
 520             if (src_len < 3)
 521               error (_("Invalid OpenCL vector component accessor %s"), comps);
 522             indices[i] = 2;
 523             break;
 524           case 'w':
 525             if (src_len < 4)
 526               error (_("Invalid OpenCL vector component accessor %s"), comps);
 527             indices[i] = 3;
 528             break;
 529           default:
 530             error (_("Invalid OpenCL vector component accessor %s"), comps);
 531             break;
 532           }
 533         }
 534     }
 535
 536   /* Throw an error if the amount of requested components does not
 537      result in a valid length (1, 2, 3, 4, 8, 16).  */
 538   if (dst_len != 1 && dst_len != 2 && dst_len != 3 && dst_len != 4
 539       && dst_len != 8 && dst_len != 16)
 540     error (_("Invalid OpenCL vector component accessor %s"), comps);
 541
 542   v = create_value (exp->gdbarch, val, noside, indices, dst_len);
 543
 544   return v;
 545 }
 546
 547 /* Perform the unary logical not (!) operation.  */
 548
 549 static struct value *
 550 opencl_logical_not (struct expression *exp, struct value *arg)
 551 {
 552   struct type *type = check_typedef (value_type (arg));
 553   struct type *rettype;
 554   struct value *ret;
 555
 556   if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
 557     {
 558       struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
 559       LONGEST lowb, highb;
 560       int i;
 561
 562       if (!get_array_bounds (type, &lowb, &highb))
 563         error (_("Could not determine the vector bounds"));
 564
 565       /* Determine the resulting type of the operation and allocate the
 566          value.  */
 567       rettype = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT,
 568                                            TYPE_LENGTH (eltype), 0,
 569                                            highb - lowb + 1);
 570       ret = allocate_value (rettype);
 571
 572       for (i = 0; i < highb - lowb + 1; i++)
 573         {
 574           /* For vector types, the unary operator shall return a 0 if the
 575           value of its operand compares unequal to 0, and -1 (i.e. all bits
 576           set) if the value of its operand compares equal to 0.  */
 577           int tmp = value_logical_not (value_subscript (arg, i)) ? -1 : 0;
 578           memset (value_contents_writeable (ret) + i * TYPE_LENGTH (eltype),
 579                   tmp, TYPE_LENGTH (eltype));
 580         }
 581     }
 582   else
 583     {
 584       rettype = language_bool_type (exp->language_defn, exp->gdbarch);
 585       ret = value_from_longest (rettype, value_logical_not (arg));
 586     }
 587
 588   return ret;
 589 }
 590
 591 /* Perform a relational operation on two scalar operands.  */
 592
 593 static int
 594 scalar_relop (struct value *val1, struct value *val2, enum exp_opcode op)
 595 {
 596   int ret;
 597
 598   switch (op)
 599     {
 600     case BINOP_EQUAL:
 601       ret = value_equal (val1, val2);
 602       break;
 603     case BINOP_NOTEQUAL:
 604       ret = !value_equal (val1, val2);
 605       break;
 606     case BINOP_LESS:
 607       ret = value_less (val1, val2);
 608       break;
 609     case BINOP_GTR:
 610       ret = value_less (val2, val1);
 611       break;
 612     case BINOP_GEQ:
 613       ret = value_less (val2, val1) || value_equal (val1, val2);
 614       break;
 615     case BINOP_LEQ:
 616       ret = value_less (val1, val2) || value_equal (val1, val2);
 617       break;
 618     case BINOP_LOGICAL_AND:
 619       ret = !value_logical_not (val1) && !value_logical_not (val2);
 620       break;
 621     case BINOP_LOGICAL_OR:
 622       ret = !value_logical_not (val1) || !value_logical_not (val2);
 623       break;
 624     default:
 625       error (_("Attempt to perform an unsupported operation"));
 626       break;
 627     }
 628   return ret;
 629 }
 630
 631 /* Perform a relational operation on two vector operands.  */
 632
 633 static struct value *
 634 vector_relop (struct expression *exp, struct value *val1, struct value *val2,
 635               enum exp_opcode op)
 636 {
 637   struct value *ret;
 638   struct type *type1, *type2, *eltype1, *eltype2, *rettype;
 639   int t1_is_vec, t2_is_vec, i;
 640   LONGEST lowb1, lowb2, highb1, highb2;
 641
 642   type1 = check_typedef (value_type (val1));
 643   type2 = check_typedef (value_type (val2));
 644
 645   t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1));
 646   t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2));
 647
 648   if (!t1_is_vec || !t2_is_vec)
 649     error (_("Vector operations are not supported on scalar types"));
 650
 651   eltype1 = check_typedef (TYPE_TARGET_TYPE (type1));
 652   eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
 653
 654   if (!get_array_bounds (type1,&lowb1, &highb1)
 655       || !get_array_bounds (type2, &lowb2, &highb2))
 656     error (_("Could not determine the vector bounds"));
 657
 658   /* Check whether the vector types are compatible.  */
 659   if (TYPE_CODE (eltype1) != TYPE_CODE (eltype2)
 660       || TYPE_LENGTH (eltype1) != TYPE_LENGTH (eltype2)
 661       || TYPE_UNSIGNED (eltype1) != TYPE_UNSIGNED (eltype2)
 662       || lowb1 != lowb2 || highb1 != highb2)
 663     error (_("Cannot perform operation on vectors with different types"));
 664
 665   /* Determine the resulting type of the operation and allocate the value.  */
 666   rettype = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT,
 667                                        TYPE_LENGTH (eltype1), 0,
 668                                        highb1 - lowb1 + 1);
 669   ret = allocate_value (rettype);
 670
 671   for (i = 0; i < highb1 - lowb1 + 1; i++)
 672     {
 673       /* For vector types, the relational, equality and logical operators shall
 674          return 0 if the specified relation is false and -1 (i.e. all bits set)
 675          if the specified relation is true.  */
 676       int tmp = scalar_relop (value_subscript (val1, i),
 677                               value_subscript (val2, i), op) ? -1 : 0;
 678       memset (value_contents_writeable (ret) + i * TYPE_LENGTH (eltype1),
 679               tmp, TYPE_LENGTH (eltype1));
 680      }
 681
 682   return ret;
 683 }
 684
 685 /* Perform a relational operation on two operands.  */
 686
 687 static struct value *
 688 opencl_relop (struct expression *exp, struct value *arg1, struct value *arg2,
 689               enum exp_opcode op)
 690 {
 691   struct value *val;
 692   struct type *type1 = check_typedef (value_type (arg1));
 693   struct type *type2 = check_typedef (value_type (arg2));
 694   int t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
 695                    && TYPE_VECTOR (type1));
 696   int t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
 697                    && TYPE_VECTOR (type2));
 698
 699   if (!t1_is_vec && !t2_is_vec)
 700     {
 701       int tmp = scalar_relop (arg1, arg2, op);
 702       struct type *type =
 703         language_bool_type (exp->language_defn, exp->gdbarch);
 704
 705       val = value_from_longest (type, tmp);
 706     }
 707   else if (t1_is_vec && t2_is_vec)
 708     {
 709       val = vector_relop (exp, arg1, arg2, op);
 710     }
 711   else
 712     {
 713       /* Widen the scalar operand to a vector.  */
 714       struct value **v = t1_is_vec ? &arg2 : &arg1;
 715       struct type *t = t1_is_vec ? type2 : type1;
 716
 717       if (TYPE_CODE (t) != TYPE_CODE_FLT && !is_integral_type (t))
 718         error (_("Argument to operation not a number or boolean."));
 719
 720       *v = value_cast (t1_is_vec ? type1 : type2, *v);
 721       val = vector_relop (exp, arg1, arg2, op);
 722     }
 723
 724   return val;
 725 }
 726
 727 /* Expression evaluator for the OpenCL.  Most operations are delegated to
 728    evaluate_subexp_standard; see that function for a description of the
 729    arguments.  */
 730
 731 static struct value *
 732 evaluate_subexp_opencl (struct type *expect_type, struct expression *exp,
 733                    int *pos, enum noside noside)
 734 {
 735   enum exp_opcode op = exp->elts[*pos].opcode;
 736   struct value *arg1 = NULL;
 737   struct value *arg2 = NULL;
 738   struct type *type1, *type2;
 739
 740   switch (op)
 741     {
 742     /* Handle binary relational and equality operators that are either not
 743        or differently defined for GNU vectors.  */
 744     case BINOP_EQUAL:
 745     case BINOP_NOTEQUAL:
 746     case BINOP_LESS:
 747     case BINOP_GTR:
 748     case BINOP_GEQ:
 749     case BINOP_LEQ:
 750       (*pos)++;
 751       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
 752       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
 753
 754       if (noside == EVAL_SKIP)
 755         return value_from_longest (builtin_type (exp->gdbarch)->
 756                                    builtin_int, 1);
 757
 758       return opencl_relop (exp, arg1, arg2, op);
 759
 760     /* Handle the logical unary operator not(!).  */
 761     case UNOP_LOGICAL_NOT:
 762       (*pos)++;
 763       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
 764
 765       if (noside == EVAL_SKIP)
 766         return value_from_longest (builtin_type (exp->gdbarch)->
 767                                    builtin_int, 1);
 768
 769       return opencl_logical_not (exp, arg1);
 770
 771     /* Handle the logical operator and(&&) and or(||).  */
 772     case BINOP_LOGICAL_AND:
 773     case BINOP_LOGICAL_OR:
 774       (*pos)++;
 775       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
 776
 777       if (noside == EVAL_SKIP)
 778         {
 779           evaluate_subexp (NULL_TYPE, exp, pos, noside);
 780
 781           return value_from_longest (builtin_type (exp->gdbarch)->
 782                                      builtin_int, 1);
 783         }
 784       else
 785         {
 786           /* For scalar operations we need to avoid evaluating operands
 787              unecessarily.  However, for vector operations we always need to
 788              evaluate both operands.  Unfortunately we only know which of the
 789              two cases apply after we know the type of the second operand.
 790              Therefore we evaluate it once using EVAL_AVOID_SIDE_EFFECTS.  */
 791           int oldpos = *pos;
 792
 793           arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
 794                                   EVAL_AVOID_SIDE_EFFECTS);
 795           *pos = oldpos;
 796           type1 = check_typedef (value_type (arg1));
 797           type2 = check_typedef (value_type (arg2));
 798
 799           if ((TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
 800               || (TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2)))
 801             {
 802               arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
 803
 804               return opencl_relop (exp, arg1, arg2, op);
 805             }
 806           else
 807             {
 808               /* For scalar built-in types, only evaluate the right
 809                  hand operand if the left hand operand compares
 810                  unequal(&&)/equal(||) to 0.  */
 811               int res;
 812               int tmp = value_logical_not (arg1);
 813
 814               if (op == BINOP_LOGICAL_OR)
 815                 tmp = !tmp;
 816
 817               arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
 818                                       tmp ? EVAL_SKIP : noside);
 819               type1 = language_bool_type (exp->language_defn, exp->gdbarch);
 820
 821               if (op == BINOP_LOGICAL_AND)
 822                 res = !tmp && !value_logical_not (arg2);
 823               else /* BINOP_LOGICAL_OR */
 824                 res = tmp || !value_logical_not (arg2);
 825
 826               return value_from_longest (type1, res);
 827             }
 828         }
 829
 830     /* Handle the ternary selection operator.  */
 831     case TERNOP_COND:
 832       (*pos)++;
 833       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
 834       type1 = check_typedef (value_type (arg1));
 835       if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
 836         {
 837           struct value *arg3, *tmp, *ret;
 838           struct type *eltype2, *type3, *eltype3;
 839           int t2_is_vec, t3_is_vec, i;
 840           LONGEST lowb1, lowb2, lowb3, highb1, highb2, highb3;
 841
 842           arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
 843           arg3 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
 844           type2 = check_typedef (value_type (arg2));
 845           type3 = check_typedef (value_type (arg3));
 846           t2_is_vec
 847             = TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2);
 848           t3_is_vec
 849             = TYPE_CODE (type3) == TYPE_CODE_ARRAY && TYPE_VECTOR (type3);
 850
 851           /* Widen the scalar operand to a vector if necessary.  */
 852           if (t2_is_vec || !t3_is_vec)
 853             {
 854               arg3 = value_cast (type2, arg3);
 855               type3 = value_type (arg3);
 856             }
 857           else if (!t2_is_vec || t3_is_vec)
 858             {
 859               arg2 = value_cast (type3, arg2);
 860               type2 = value_type (arg2);
 861             }
 862           else if (!t2_is_vec || !t3_is_vec)
 863             {
 864               /* Throw an error if arg2 or arg3 aren't vectors.  */
 865               error (_("\
 866 Cannot perform conditional operation on incompatible types"));
 867             }
 868
 869           eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
 870           eltype3 = check_typedef (TYPE_TARGET_TYPE (type3));
 871
 872           if (!get_array_bounds (type1, &lowb1, &highb1)
 873               || !get_array_bounds (type2, &lowb2, &highb2)
 874               || !get_array_bounds (type3, &lowb3, &highb3))
 875             error (_("Could not determine the vector bounds"));
 876
 877           /* Throw an error if the types of arg2 or arg3 are incompatible.  */
 878           if (TYPE_CODE (eltype2) != TYPE_CODE (eltype3)
 879               || TYPE_LENGTH (eltype2) != TYPE_LENGTH (eltype3)
 880               || TYPE_UNSIGNED (eltype2) != TYPE_UNSIGNED (eltype3)
 881               || lowb2 != lowb3 || highb2 != highb3)
 882             error (_("\
 883 Cannot perform operation on vectors with different types"));
 884
 885           /* Throw an error if the sizes of arg1 and arg2/arg3 differ.  */
 886           if (lowb1 != lowb2 || lowb1 != lowb3
 887               || highb1 != highb2 || highb1 != highb3)
 888             error (_("\
 889 Cannot perform conditional operation on vectors with different sizes"));
 890
 891           ret = allocate_value (type2);
 892
 893           for (i = 0; i < highb1 - lowb1 + 1; i++)
 894             {
 895               tmp = value_logical_not (value_subscript (arg1, i)) ?
 896                     value_subscript (arg3, i) : value_subscript (arg2, i);
 897               memcpy (value_contents_writeable (ret) +
 898                       i * TYPE_LENGTH (eltype2), value_contents_all (tmp),
 899                       TYPE_LENGTH (eltype2));
 900             }
 901
 902           return ret;
 903         }
 904       else
 905         {
 906           if (value_logical_not (arg1))
 907             {
 908               /* Skip the second operand.  */
 909               evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
 910
 911               return evaluate_subexp (NULL_TYPE, exp, pos, noside);
 912             }
 913           else
 914             {
 915               /* Skip the third operand.  */
 916               arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
 917               evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
 918
 919               return arg2;
 920             }
 921         }
 922
 923     /* Handle STRUCTOP_STRUCT to allow component access on OpenCL vectors.  */
 924     case STRUCTOP_STRUCT:
 925       {
 926         int pc = (*pos)++;
 927         int tem = longest_to_int (exp->elts[pc + 1].longconst);
 928
 929         (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
 930         arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
 931         type1 = check_typedef (value_type (arg1));
 932
 933         if (noside == EVAL_SKIP)
 934           {
 935             return value_from_longest (builtin_type (exp->gdbarch)->
 936                                        builtin_int, 1);
 937           }
 938         else if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
 939           {
 940             return opencl_component_ref (exp, arg1, &exp->elts[pc + 2].string,
 941                                          noside);
 942           }
 943         else
 944           {
 945             if (noside == EVAL_AVOID_SIDE_EFFECTS)
 946               return
 947                   value_zero (lookup_struct_elt_type
 948                               (value_type (arg1),&exp->elts[pc + 2].string, 0),
 949                               lval_memory);
 950             else
 951               return value_struct_elt (&arg1, NULL,
 952                                        &exp->elts[pc + 2].string, NULL,
 953                                        "structure");
 954           }
 955       }
 956     default:
 957       break;
 958     }
 959
 960   return evaluate_subexp_c (expect_type, exp, pos, noside);
 961 }
 962
 963 void
 964 opencl_language_arch_info (struct gdbarch *gdbarch,
 965                            struct language_arch_info *lai)
 966 {
 967   struct type **types = builtin_opencl_type (gdbarch);
 968
 969   /* Copy primitive types vector from gdbarch.  */
 970   lai->primitive_type_vector = types;
 971
 972   /* Type of elements of strings.  */
 973   lai->string_char_type = types [opencl_primitive_type_char];
 974
 975   /* Specifies the return type of logical and relational operations.  */
 976   lai->bool_type_symbol = "int";
 977   lai->bool_type_default = types [opencl_primitive_type_int];
 978 }
 979
 980 const struct exp_descriptor exp_descriptor_opencl =
 981 {
 982   print_subexp_standard,
 983   operator_length_standard,
 984   operator_check_standard,
 985   op_name_standard,
 986   dump_subexp_body_standard,
 987   evaluate_subexp_opencl
 988 };
 989
 990 const struct language_defn opencl_language_defn =
 991 {
 992   "opencl",                     /* Language name */
 993   language_opencl,
 994   range_check_off,
 995   type_check_off,
 996   case_sensitive_on,
 997   array_row_major,
 998   macro_expansion_c,
 999   &exp_descriptor_opencl,
1000   c_parse,
1001   c_error,
1002   null_post_parser,
1003   c_printchar,                  /* Print a character constant */
1004   c_printstr,                   /* Function to print string constant */
1005   c_emit_char,                  /* Print a single char */
1006   c_print_type,                 /* Print a type using appropriate syntax */
1007   c_print_typedef,              /* Print a typedef using appropriate syntax */
1008   c_val_print,                  /* Print a value using appropriate syntax */
1009   c_value_print,                /* Print a top-level value */
1010   NULL,                         /* Language specific skip_trampoline */
1011   NULL,                         /* name_of_this */
1012   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1013   basic_lookup_transparent_type,/* lookup_transparent_type */
1014   NULL,                         /* Language specific symbol demangler */
1015   NULL,                         /* Language specific
1016                                    class_name_from_physname */
1017   c_op_print_tab,               /* expression operators for printing */
1018   1,                            /* c-style arrays */
1019   0,                            /* String lower bound */
1020   default_word_break_characters,
1021   default_make_symbol_completion_list,
1022   opencl_language_arch_info,
1023   default_print_array_index,
1024   default_pass_by_reference,
1025   c_get_string,
1026   LANG_MAGIC
1027 };
1028
1029 static void *
1030 build_opencl_types (struct gdbarch *gdbarch)
1031 {
1032   struct type **types
1033     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_opencl_primitive_types + 1,
1034                               struct type *);
1035
1036 /* Helper macro to create strings.  */
1037 #define OCL_STRING(S) #S
1038 /* This macro allocates and assigns the type struct pointers
1039    for the vector types.  */
1040 #define BUILD_OCL_VTYPES(TYPE)\
1041   types[opencl_primitive_type_##TYPE##2] \
1042     = init_vector_type (types[opencl_primitive_type_##TYPE], 2); \
1043   TYPE_NAME (types[opencl_primitive_type_##TYPE##2]) = OCL_STRING(TYPE ## 2); \
1044   types[opencl_primitive_type_##TYPE##3] \
1045     = init_vector_type (types[opencl_primitive_type_##TYPE], 3); \
1046   TYPE_NAME (types[opencl_primitive_type_##TYPE##3]) = OCL_STRING(TYPE ## 3); \
1047   TYPE_LENGTH (types[opencl_primitive_type_##TYPE##3]) \
1048     = 4 * TYPE_LENGTH (types[opencl_primitive_type_##TYPE]); \
1049   types[opencl_primitive_type_##TYPE##4] \
1050     = init_vector_type (types[opencl_primitive_type_##TYPE], 4); \
1051   TYPE_NAME (types[opencl_primitive_type_##TYPE##4]) = OCL_STRING(TYPE ## 4); \
1052   types[opencl_primitive_type_##TYPE##8] \
1053     = init_vector_type (types[opencl_primitive_type_##TYPE], 8); \
1054   TYPE_NAME (types[opencl_primitive_type_##TYPE##8]) = OCL_STRING(TYPE ## 8); \
1055   types[opencl_primitive_type_##TYPE##16] \
1056     = init_vector_type (types[opencl_primitive_type_##TYPE], 16); \
1057   TYPE_NAME (types[opencl_primitive_type_##TYPE##16]) = OCL_STRING(TYPE ## 16)
1058
1059   types[opencl_primitive_type_char]
1060     = arch_integer_type (gdbarch, 8, 0, "char");
1061   BUILD_OCL_VTYPES (char);
1062   types[opencl_primitive_type_uchar]
1063     = arch_integer_type (gdbarch, 8, 1, "uchar");
1064   BUILD_OCL_VTYPES (uchar);
1065   types[opencl_primitive_type_short]
1066     = arch_integer_type (gdbarch, 16, 0, "short");
1067   BUILD_OCL_VTYPES (short);
1068   types[opencl_primitive_type_ushort]
1069     = arch_integer_type (gdbarch, 16, 1, "ushort");
1070   BUILD_OCL_VTYPES (ushort);
1071   types[opencl_primitive_type_int]
1072     = arch_integer_type (gdbarch, 32, 0, "int");
1073   BUILD_OCL_VTYPES (int);
1074   types[opencl_primitive_type_uint]
1075     = arch_integer_type (gdbarch, 32, 1, "uint");
1076   BUILD_OCL_VTYPES (uint);
1077   types[opencl_primitive_type_long]
1078     = arch_integer_type (gdbarch, 64, 0, "long");
1079   BUILD_OCL_VTYPES (long);
1080   types[opencl_primitive_type_ulong]
1081     = arch_integer_type (gdbarch, 64, 1, "ulong");
1082   BUILD_OCL_VTYPES (ulong);
1083   types[opencl_primitive_type_half]
1084     = arch_float_type (gdbarch, 16, "half", floatformats_ieee_half);
1085   BUILD_OCL_VTYPES (half);
1086   types[opencl_primitive_type_float]
1087     = arch_float_type (gdbarch, 32, "float", floatformats_ieee_single);
1088   BUILD_OCL_VTYPES (float);
1089   types[opencl_primitive_type_double]
1090     = arch_float_type (gdbarch, 64, "double", floatformats_ieee_double);
1091   BUILD_OCL_VTYPES (double);
1092   types[opencl_primitive_type_bool]
1093     = arch_boolean_type (gdbarch, 8, 1, "bool");
1094   types[opencl_primitive_type_unsigned_char]
1095     = arch_integer_type (gdbarch, 8, 1, "unsigned char");
1096   types[opencl_primitive_type_unsigned_short]
1097     = arch_integer_type (gdbarch, 16, 1, "unsigned short");
1098   types[opencl_primitive_type_unsigned_int]
1099     = arch_integer_type (gdbarch, 32, 1, "unsigned int");
1100   types[opencl_primitive_type_unsigned_long]
1101     = arch_integer_type (gdbarch, 64, 1, "unsigned long");
1102   types[opencl_primitive_type_size_t]
1103     = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "size_t");
1104   types[opencl_primitive_type_ptrdiff_t]
1105     = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "ptrdiff_t");
1106   types[opencl_primitive_type_intptr_t]
1107     = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "intptr_t");
1108   types[opencl_primitive_type_uintptr_t]
1109     = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "uintptr_t");
1110   types[opencl_primitive_type_void]
1111     = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
1112
1113   return types;
1114 }
1115
1116 void
1117 _initialize_opencl_language (void)
1118 {
1119   opencl_type_data = gdbarch_data_register_post_init (build_opencl_types);
1120   add_language (&opencl_language_defn);
1121 }