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